diff --git a/.github/dependabot.yml b/.github/dependabot.yml deleted file mode 100644 index 8e03414c7..000000000 --- a/.github/dependabot.yml +++ /dev/null @@ -1,18 +0,0 @@ -# To get started with Dependabot version updates, you'll need to specify which -# package ecosystems to update and where the package manifests are located. -# Please see the documentation for all configuration options: -# https://docs.github.com/github/administering-a-repository/configuration-options-for-dependency-updates - -version: 2 -updates: - - package-ecosystem: "gradle" # See documentation for possible values - directory: "/" # Location of package manifests - schedule: - interval: "daily" - - - package-ecosystem: "github-actions" - # Workflow files stored in the - # default location of `.github/workflows` - directory: "/" - schedule: - interval: "daily" diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml deleted file mode 100644 index 5c933d8f4..000000000 --- a/.github/workflows/build.yml +++ /dev/null @@ -1,36 +0,0 @@ -name: Build project - -#workflow_dispatch -- for manual trigger -on: [ push, workflow_dispatch ] - -jobs: - build: - - runs-on: ubuntu-latest - - steps: - - name: Checkout - uses: actions/checkout@v3 - - - name: Set up JDK 11 - uses: actions/setup-java@v3 - with: - java-version: '11' - distribution: 'temurin' - - - name: Install JFlex - run: | - sudo apt-get install -y jflex - - - name: Install ANTLR4 files - run: | - sudo apt-get install antlr4 - - - name: Generate files - run: | - ./benchmarks/scripts/generate_all.sh - - - name: Build with Gradle - uses: gradle/gradle-build-action@bd5760595778326ba7f1441bcf7e88b49de61a25 # v2.6.0 - with: - arguments: build diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml new file mode 100644 index 000000000..56b8970e7 --- /dev/null +++ b/.github/workflows/ci.yaml @@ -0,0 +1,32 @@ +name: ci +on: + push: + branches: + - main + - bachish/add-docs-pages +permissions: + contents: write +jobs: + deploy: + runs-on: ubuntu-latest + defaults: + run: + working-directory: docs + steps: + - uses: actions/checkout@v4 + - name: Configure Git Credentials + run: | + git config user.name github-actions[bot] + git config user.email 41898282+github-actions[bot]@users.noreply.github.com + - uses: actions/setup-python@v5 + with: + python-version: 3.x + - run: echo "cache_id=$(date --utc '+%V')" >> $GITHUB_ENV + - uses: actions/cache@v4 + with: + key: mkdocs-material-${{ env.cache_id }} + path: ~/.cache + restore-keys: | + mkdocs-material- + - run: pip install mkdocs-material + - run: mkdocs gh-deploy --force \ No newline at end of file diff --git a/.github/workflows/jar.yml b/.github/workflows/jar.yml deleted file mode 100644 index 7b9645986..000000000 --- a/.github/workflows/jar.yml +++ /dev/null @@ -1,38 +0,0 @@ -name: Jar - -on: [ push, pull_request, workflow_dispatch ] - -env: - GRADLE_BUILD_ACTION_CACHE_DEBUG_ENABLED: true - -jobs: - jar: - runs-on: ubuntu-latest - - steps: - - name: Checkout - uses: actions/checkout@v4 - - - name: Setup JDK 11 - uses: actions/setup-java@v3 - with: - distribution: temurin - java-version: 11 - - - name: Execute Gradle `jar` task - uses: gradle/gradle-build-action@v2 - with: - arguments: jar - cache-read-only: | - ${{ github.ref != 'refs/heads/main' && - github.ref != 'refs/heads/dev' }} - gradle-home-cache-includes: | - caches - notifications - jdks - - - name: Upload `jar` - if: always() - uses: actions/upload-artifact@v3 - with: - path: build/libs/kotgll-*.jar \ No newline at end of file diff --git a/.github/workflows/jekyll-gh-pages.yml b/.github/workflows/jekyll-gh-pages.yml deleted file mode 100644 index e31d81c58..000000000 --- a/.github/workflows/jekyll-gh-pages.yml +++ /dev/null @@ -1,51 +0,0 @@ -# Sample workflow for building and deploying a Jekyll site to GitHub Pages -name: Deploy Jekyll with GitHub Pages dependencies preinstalled - -on: - # Runs on pushes targeting the default branch - push: - branches: ["main"] - - # Allows you to run this workflow manually from the Actions tab - workflow_dispatch: - -# Sets permissions of the GITHUB_TOKEN to allow deployment to GitHub Pages -permissions: - contents: read - pages: write - id-token: write - -# Allow only one concurrent deployment, skipping runs queued between the run in-progress and latest queued. -# However, do NOT cancel in-progress runs as we want to allow these production deployments to complete. -concurrency: - group: "pages" - cancel-in-progress: false - -jobs: - # Build job - build: - runs-on: ubuntu-latest - steps: - - name: Checkout - uses: actions/checkout@v4 - - name: Setup Pages - uses: actions/configure-pages@v5 - - name: Build with Jekyll - uses: actions/jekyll-build-pages@v1 - with: - source: ./ - destination: ./_site - - name: Upload artifact - uses: actions/upload-pages-artifact@v3 - - # Deployment job - deploy: - environment: - name: github-pages - url: ${{ steps.deployment.outputs.page_url }} - runs-on: ubuntu-latest - needs: build - steps: - - name: Deploy to GitHub Pages - id: deployment - uses: actions/deploy-pages@v4 diff --git a/.github/workflows/publish.yml b/.github/workflows/publish.yml deleted file mode 100644 index 726f11a85..000000000 --- a/.github/workflows/publish.yml +++ /dev/null @@ -1,43 +0,0 @@ -name: Publish - -on: - release: - types: [ created ] - -env: - GRADLE_BUILD_ACTION_CACHE_DEBUG_ENABLED: true - -jobs: - publish: - runs-on: ubuntu-latest - permissions: - contents: write - packages: write - steps: - - name: Checkout - uses: actions/checkout@v4 - - - name: Setup JDK 11 - uses: actions/setup-java@v3 - with: - distribution: temurin - java-version: 11 - - - name: Publish package - uses: gradle/gradle-build-action@v2 - with: - arguments: publish - cache-read-only: | - ${{ github.ref != 'refs/heads/main' && - github.ref != 'refs/heads/dev' }} - gradle-home-cache-includes: | - caches - notifications - jdks - env: - GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} - - - name: Release - uses: softprops/action-gh-release@v1 - with: - files: build/libs/kotgll-*.jar diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml deleted file mode 100644 index b0dd8fc78..000000000 --- a/.github/workflows/test.yml +++ /dev/null @@ -1,42 +0,0 @@ -name: Test - -on: [ push, pull_request, workflow_dispatch ] - -env: - GRADLE_BUILD_ACTION_CACHE_DEBUG_ENABLED: true - -jobs: - test: - strategy: - matrix: - os: [ ubuntu-latest, macos-latest, windows-latest ] - runs-on: ${{ matrix.os }} - - steps: - - name: Checkout - uses: actions/checkout@v4 - - - name: Setup JDK 11 - uses: actions/setup-java@v3 - with: - distribution: temurin - java-version: 11 - - - name: Execute Gradle `test` task - uses: gradle/gradle-build-action@v2 - with: - arguments: test --scan - cache-read-only: | - ${{ github.ref != 'refs/heads/main' && - github.ref != 'refs/heads/dev' }} - gradle-home-cache-includes: | - caches - notifications - jdks - - - name: Upload `test` report - if: always() - uses: actions/upload-artifact@v3 - with: - name: TestReport-${{ matrix.os }} - path: build/reports/tests/ \ No newline at end of file diff --git a/README.md b/README.md index b93303d56..ca5985e7c 100644 --- a/README.md +++ b/README.md @@ -2,6 +2,8 @@ > Note: project under heavy development! +Please, see [documentation](https://formallanguageconstrainedpathquerying.github.io/UCFS/) for details. + ## What is UCFS? UCFS is an **U**niversal **C**ontext-**F**ree **S**olver: a GLL‑based tool for problems at the intersection of context‑free languages @@ -22,12 +24,11 @@ over edge‑labeled directed graphs. Examples of such problems: ### Repository layout (high‑level) ``` -benchmarks/ # ANTLR4 comparison & perf harness (examples, scripts) -examples/ # Grammar examples (A*, Dyck, etc.) -generator/ # Parser & AST node‑class generator +docs/ # documentation pages +generator/ # Parser & AST node‑class generator solver/ # Core UCFS logic (GLL + RSM) -src/ # CLI and library entry points -test-shared/ # Testcases, grammars, inputs +test-shared/ # Testcases, grammars, inputs, ANTLR4 comparison + # grammar examples and experiments ``` ### Requirements @@ -42,4 +43,4 @@ test-shared/ # Testcases, grammars, inputs ## Core Algorithm -UCFS is based on Generalized LL (GLL) parsing algorithm modified to handle language specification in form of Recursive State Machines (RSM-s) and input in form of arbitratry directed edge-labelled graph. Basic ideas described [here](https://arxiv.org/pdf/2312.11925.pdf). +UCFS is based on Generalized LL (GLL) parsing algorithm modified to handle language specification in form of Recursive State Machines (RSM) and input in form of arbitratry directed edge-labelled graph. Basic ideas described [here](https://arxiv.org/pdf/2312.11925.pdf). diff --git a/benchmarks/README.md b/benchmarks/README.md deleted file mode 100644 index afccf1dce..000000000 --- a/benchmarks/README.md +++ /dev/null @@ -1,19 +0,0 @@ -# UCFSBenchmarks - -## Prerequisites - -```text -(1) Gradle (version >= 7.2) -(2) Antlr V4 -(3) Jflex -``` -## Generate files -Run `/scripts/generate_all.sh` -## Run benchmarks -From root project folder run `./gradlew :benchmarks:jmh -PtoolName=${toolRegexp} -Pdataset=${absolutePathToDatasetFolder}` - -## Logging - -Logs are stored in `logs` - -Results are stored in `build/reports/benchmarks` diff --git a/benchmarks/build.gradle.kts b/benchmarks/build.gradle.kts deleted file mode 100644 index a2944b5b1..000000000 --- a/benchmarks/build.gradle.kts +++ /dev/null @@ -1,36 +0,0 @@ -plugins { - java - kotlin("jvm") version "1.9.20" - application -} - -application{ - mainClass = "org.ucfs.GeneratorKt" -} - -repositories { - mavenCentral() - maven("https://releases.usethesource.io/maven/") -} - -dependencies { - // Other dependencies. - testImplementation(kotlin("test")) - testImplementation("org.junit.jupiter:junit-jupiter-api:5.11.0") - //compared projects - // 1. for ucfs - implementation(project(":solver")) - implementation(project(":generator")) - implementation(project(":examples")) - // 2. for antlr - implementation("org.antlr:antlr4:4.13.1") - implementation(kotlin("stdlib-jdk8")) -} - -kotlin { - jvmToolchain(17) -} - -tasks.test { - useJUnitPlatform() -} \ No newline at end of file diff --git a/benchmarks/gradle.properties b/benchmarks/gradle.properties deleted file mode 100644 index 2de43ab72..000000000 --- a/benchmarks/gradle.properties +++ /dev/null @@ -1,3 +0,0 @@ -kotlin.code.style=official -org.gradle.daemon=true -org.gradle.jvmargs=-Xmx4096m -Xss4m -XX:+UseG1GC \ No newline at end of file diff --git a/benchmarks/gradle/wrapper/gradle-wrapper.properties b/benchmarks/gradle/wrapper/gradle-wrapper.properties deleted file mode 100644 index 06febab41..000000000 --- a/benchmarks/gradle/wrapper/gradle-wrapper.properties +++ /dev/null @@ -1,5 +0,0 @@ -distributionBase=GRADLE_USER_HOME -distributionPath=wrapper/dists -distributionUrl=https\://services.gradle.org/distributions/gradle-8.2-bin.zip -zipStoreBase=GRADLE_USER_HOME -zipStorePath=wrapper/dists \ No newline at end of file diff --git a/benchmarks/gradlew b/benchmarks/gradlew deleted file mode 100755 index 1b6c78733..000000000 --- a/benchmarks/gradlew +++ /dev/null @@ -1,234 +0,0 @@ -#!/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" "$@" diff --git a/benchmarks/gradlew.bat b/benchmarks/gradlew.bat deleted file mode 100644 index 107acd32c..000000000 --- a/benchmarks/gradlew.bat +++ /dev/null @@ -1,89 +0,0 @@ -@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 diff --git a/benchmarks/scripts/extract_all_java_files.sh b/benchmarks/scripts/extract_all_java_files.sh deleted file mode 100755 index a626537d3..000000000 --- a/benchmarks/scripts/extract_all_java_files.sh +++ /dev/null @@ -1,43 +0,0 @@ -#!/bin/bash - -# Check if the correct number of arguments are provided -if [ "$#" -ne 2 ]; then - echo "Usage: $0 " - exit 1 -fi - -# Assign arguments to variables -destination=$1 -search_path=$2 - -# Check if the destination directory exists, if not, create it -if [ ! -d "$destination" ]; then - mkdir -p "$destination" -fi - -# Initialize counters -file_count=0 -line_count=0 -char_count=0 -size=0 - -# Find, copy all .java files, and calculate the stats -while IFS= read -r -d '' file; do - cp "$file" "$destination" - ((file_count++)) - line_count=$(($line_count + $(wc -l < "$file"))) - char_count=$(($char_count + $(wc -m < "$file"))) - size=$(($size + $(stat --format=%s "$file"))) -done < <(find "$search_path" -name "*.java" -print0) - -echo "$file_count .java files have been copied to the $destination folder." -echo "Total lines: $line_count" -echo "Total characters: $char_count" -echo "Total size on disk: $size bytes" - -# Convert size from bytes to megabytes -size_mb=$(awk "BEGIN {printf \"%.2f\", $size/1024/1024}") - - -echo "#Files,#Chars,SLOC,Size (on disk)" -echo "$file_count,$char_count,$line_count,$size_mb" \ No newline at end of file diff --git a/benchmarks/scripts/generate_all.sh b/benchmarks/scripts/generate_all.sh deleted file mode 100755 index d8b8ba3ec..000000000 --- a/benchmarks/scripts/generate_all.sh +++ /dev/null @@ -1,42 +0,0 @@ -#!/bin/bash -shopt -s nullglob #ingore failed patterns -rootPrj=$(pwd) - -parserDest="benchmarks/src/main/kotlin/org/ucfs" -antlrSrc="benchmarks/src/main/java/org/antlr" -fastAntlrSrc="benchmarks/src/main/java/org/antlr/fast" -antlrPackage="org.antlr" -antlrFastPackage="org.antlr.fast" - -lexerSrc="benchmarks/src/main/java/org/ucfs/scanner" - -printf "\n\nINSTALL PACKAGES\n" -apt-get install jflex -apt-get install antlr4 - -printf "\n\nGENERATE FILES\n" - -printf "\nGenerate ANTLR4 files" - -cd $antlrSrc -antlr4 -package $antlrPackage Java8Lexer.g4 -antlr4 -package $antlrPackage Java8Parser.g4 -cd $rootPrj - -printf "\nGenerate fast ANTLR4 files" -cd $fastAntlrSrc -antlr4 -package $antlrFastPackage JavaLexer.g4 -antlr4 -package $antlrFastPackage JavaParser.g4 -cd $rootPrj - -printf "\nGenerate lexers" -cd $lexerSrc -for lexer_name in *.jflex *.jlex *.lex *.flex *.x -do - jflex $lexer_name -done -cd $rootPrj - -printf $(pwd) -printf "\nGenerate UCFS parser files at" -echo $parserDest \ No newline at end of file diff --git a/benchmarks/scripts/mem_measure_bin_search.py b/benchmarks/scripts/mem_measure_bin_search.py deleted file mode 100644 index ccf3d38e7..000000000 --- a/benchmarks/scripts/mem_measure_bin_search.py +++ /dev/null @@ -1,71 +0,0 @@ - -import os -import subprocess -import sys - -cp_path = '/home/olga/gllgen/ucfs/simpleApp/build/install/simpleApp/lib/*' -files_dir = '/home/olga/gllgen/java7/junit/' - -tool = sys.argv[1] -files_dir = sys.argv[2] -cp_path = sys.argv[3] - -def run_tool_for_file(tool, file_path): - def get_cmd(mem): - return ['java', '-cp', cp_path, f'-Xmx{mem}m', 'org.ucfs.MainKt', tool, file_path] - - - cache = {} - - def execute(mem): - if mem in cache: - return cache[mem] - - cmd = get_cmd(mem) - process = subprocess.run(cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL) - return_code = process.returncode - if return_code == 42: - print("it return 42") - exit(1) - cache[mem] = return_code - return return_code - - l = 1 - r = 64 - max = 4*1024 - while r <= max: - return_code = execute(r) - if return_code != 0: - l = r - r *= 2 - else: - break - print(f"calculate r = {r}") - if r == 2*max: - return r - - - while l < r - 1: - m = (l + r) // 2 - return_code = execute(m) - print(f"for {m} mem get code {return_code}") - - if return_code != 0: - l = m - else: - r = m - - return l - - -files = os.listdir(files_dir) - -print(tool) -with open(f"{tool}_res.txt", "w") as output: - output.write(f"file,mem\n") - output.flush() - for file in files: - mem = run_tool_for_file(tool, files_dir + file) - print(f"Got for tool = {tool}, file = {file}: {mem}mb") - output.write(f"{file},{mem}\n") - output.flush() diff --git a/benchmarks/src/main/java/org/antlr/Java8Lexer.g4 b/benchmarks/src/main/java/org/antlr/Java8Lexer.g4 deleted file mode 100644 index 7beefbe55..000000000 --- a/benchmarks/src/main/java/org/antlr/Java8Lexer.g4 +++ /dev/null @@ -1,977 +0,0 @@ -/* - * [The "BSD license"] - * Copyright (c) 2014 Terence Parr - * Copyright (c) 2014 Sam Harwell - * Copyright (c) 2019 Student Main (Make it universal) - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * 3. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR - * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES - * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. - * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, - * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, - * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 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 OF - * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -/** - * A Java 8 grammar for ANTLR 4 derived from the Java Language Specification - * chapter 19. - * - * NOTE: This grammar results in a generated parser that is much slower - * than the Java 7 grammar in the grammars-v4/java directory. This - * one is, however, extremely close to the spec. - * - * You can test with - * - * $ antlr4 Java8.g4 - * $ javac *.java - * $ grun Java8 compilationUnit *.java - * - * Or, -~/antlr/code/grammars-v4/java8 $ java Test . -/Users/parrt/antlr/code/grammars-v4/java8/./Java8BaseListener.java -/Users/parrt/antlr/code/grammars-v4/java8/./Java8Lexer.java -/Users/parrt/antlr/code/grammars-v4/java8/./Java8Listener.java -/Users/parrt/antlr/code/grammars-v4/java8/./Java8Parser.java -/Users/parrt/antlr/code/grammars-v4/java8/./Test.java -Total lexer+parser time 30844ms. - */ - -// $antlr-format alignTrailingComments true, columnLimit 150, maxEmptyLinesToKeep 1, reflowComments false, useTab false -// $antlr-format allowShortRulesOnASingleLine true, allowShortBlocksOnASingleLine true, minEmptyLines 0, alignSemicolons ownLine -// $antlr-format alignColons trailing, singleLineOverrulesHangingColon true, alignLexerCommands true, alignLabels true, alignTrailers true - -lexer grammar Java8Lexer; - -// LEXER - -// §3.9 Keywords - -ABSTRACT : 'abstract'; -ASSERT : 'assert'; -BOOLEAN : 'boolean'; -BREAK : 'break'; -BYTE : 'byte'; -CASE : 'case'; -CATCH : 'catch'; -CHAR : 'char'; -CLASS : 'class'; -CONST : 'const'; -CONTINUE : 'continue'; -DEFAULT : 'default'; -DO : 'do'; -DOUBLE : 'double'; -ELSE : 'else'; -ENUM : 'enum'; -EXTENDS : 'extends'; -FINAL : 'final'; -FINALLY : 'finally'; -FLOAT : 'float'; -FOR : 'for'; -IF : 'if'; -GOTO : 'goto'; -IMPLEMENTS : 'implements'; -IMPORT : 'import'; -INSTANCEOF : 'instanceof'; -INT : 'int'; -INTERFACE : 'interface'; -LONG : 'long'; -NATIVE : 'native'; -NEW : 'new'; -PACKAGE : 'package'; -PRIVATE : 'private'; -PROTECTED : 'protected'; -PUBLIC : 'public'; -RETURN : 'return'; -SHORT : 'short'; -STATIC : 'static'; -STRICTFP : 'strictfp'; -SUPER : 'super'; -SWITCH : 'switch'; -SYNCHRONIZED : 'synchronized'; -THIS : 'this'; -THROW : 'throw'; -THROWS : 'throws'; -TRANSIENT : 'transient'; -TRY : 'try'; -VOID : 'void'; -VOLATILE : 'volatile'; -WHILE : 'while'; - -// §3.10.1 Integer Literals - -IntegerLiteral: - DecimalIntegerLiteral - | HexIntegerLiteral - | OctalIntegerLiteral - | BinaryIntegerLiteral -; - -fragment DecimalIntegerLiteral: DecimalNumeral IntegerTypeSuffix?; - -fragment HexIntegerLiteral: HexNumeral IntegerTypeSuffix?; - -fragment OctalIntegerLiteral: OctalNumeral IntegerTypeSuffix?; - -fragment BinaryIntegerLiteral: BinaryNumeral IntegerTypeSuffix?; - -fragment IntegerTypeSuffix: [lL]; - -fragment DecimalNumeral: '0' | NonZeroDigit (Digits? | Underscores Digits); - -fragment Digits: Digit (DigitsAndUnderscores? Digit)?; - -fragment Digit: '0' | NonZeroDigit; - -fragment NonZeroDigit: [1-9]; - -fragment DigitsAndUnderscores: DigitOrUnderscore+; - -fragment DigitOrUnderscore: Digit | '_'; - -fragment Underscores: '_'+; - -fragment HexNumeral: '0' [xX] HexDigits; - -fragment HexDigits: HexDigit (HexDigitsAndUnderscores? HexDigit)?; - -fragment HexDigit: [0-9a-fA-F]; - -fragment HexDigitsAndUnderscores: HexDigitOrUnderscore+; - -fragment HexDigitOrUnderscore: HexDigit | '_'; - -fragment OctalNumeral: '0' Underscores? OctalDigits; - -fragment OctalDigits: OctalDigit (OctalDigitsAndUnderscores? OctalDigit)?; - -fragment OctalDigit: [0-7]; - -fragment OctalDigitsAndUnderscores: OctalDigitOrUnderscore+; - -fragment OctalDigitOrUnderscore: OctalDigit | '_'; - -fragment BinaryNumeral: '0' [bB] BinaryDigits; - -fragment BinaryDigits: BinaryDigit (BinaryDigitsAndUnderscores? BinaryDigit)?; - -fragment BinaryDigit: [01]; - -fragment BinaryDigitsAndUnderscores: BinaryDigitOrUnderscore+; - -fragment BinaryDigitOrUnderscore: BinaryDigit | '_'; - -// §3.10.2 Floating-Point Literals - -FloatingPointLiteral: DecimalFloatingPointLiteral | HexadecimalFloatingPointLiteral; - -fragment DecimalFloatingPointLiteral: - Digits '.' Digits? ExponentPart? FloatTypeSuffix? - | '.' Digits ExponentPart? FloatTypeSuffix? - | Digits ExponentPart FloatTypeSuffix? - | Digits FloatTypeSuffix -; - -fragment ExponentPart: ExponentIndicator SignedInteger; - -fragment ExponentIndicator: [eE]; - -fragment SignedInteger: Sign? Digits; - -fragment Sign: [+-]; - -fragment FloatTypeSuffix: [fFdD]; - -fragment HexadecimalFloatingPointLiteral: HexSignificand BinaryExponent FloatTypeSuffix?; - -fragment HexSignificand: HexNumeral '.'? | '0' [xX] HexDigits? '.' HexDigits; - -fragment BinaryExponent: BinaryExponentIndicator SignedInteger; - -fragment BinaryExponentIndicator: [pP]; - -// §3.10.3 Boolean Literals - -BooleanLiteral: 'true' | 'false'; - -// §3.10.4 Character Literals - -CharacterLiteral: '\'' SingleCharacter '\'' | '\'' EscapeSequence '\''; - -fragment SingleCharacter: ~['\\\r\n]; - -// §3.10.5 String Literals - -StringLiteral: '"' StringCharacters? '"'; - -fragment StringCharacters: StringCharacter+; - -fragment StringCharacter: ~["\\\r\n] | EscapeSequence; - -// §3.10.6 Escape Sequences for Character and String Literals - -fragment EscapeSequence: - '\\' 'u005c'? [btnfr"'\\] - | OctalEscape - | UnicodeEscape // This is not in the spec but prevents having to preprocess the input -; - -fragment OctalEscape: - '\\' 'u005c'? OctalDigit - | '\\' 'u005c'? OctalDigit OctalDigit - | '\\' 'u005c'? ZeroToThree OctalDigit OctalDigit -; - -fragment ZeroToThree: [0-3]; - -// This is not in the spec but prevents having to preprocess the input -fragment UnicodeEscape: '\\' 'u'+ HexDigit HexDigit HexDigit HexDigit; - -// §3.10.7 The Null Literal - -NullLiteral: 'null'; - -// §3.11 Separators - -LPAREN : '('; -RPAREN : ')'; -LBRACE : '{'; -RBRACE : '}'; -LBRACK : '['; -RBRACK : ']'; -SEMI : ';'; -COMMA : ','; -DOT : '.'; - -// §3.12 Operators - -ASSIGN : '='; -GT : '>'; -LT : '<'; -BANG : '!'; -TILDE : '~'; -QUESTION : '?'; -COLON : ':'; -EQUAL : '=='; -LE : '<='; -GE : '>='; -NOTEQUAL : '!='; -AND : '&&'; -OR : '||'; -INC : '++'; -DEC : '--'; -ADD : '+'; -SUB : '-'; -MUL : '*'; -DIV : '/'; -BITAND : '&'; -BITOR : '|'; -CARET : '^'; -MOD : '%'; -ARROW : '->'; -COLONCOLON : '::'; - -ADD_ASSIGN : '+='; -SUB_ASSIGN : '-='; -MUL_ASSIGN : '*='; -DIV_ASSIGN : '/='; -AND_ASSIGN : '&='; -OR_ASSIGN : '|='; -XOR_ASSIGN : '^='; -MOD_ASSIGN : '%='; -LSHIFT_ASSIGN : '<<='; -RSHIFT_ASSIGN : '>>='; -URSHIFT_ASSIGN : '>>>='; - -// §3.8 Identifiers (must appear after all keywords in the grammar) - -Identifier: IdentifierStart IdentifierPart*; -/* -fragment -JavaLetter - : [a-zA-Z$_] // these are the "java letters" below 0x7F - | // covers all characters above 0x7F which are not a surrogate - ~[\u0000-\u007F\uD800-\uDBFF] {this.wasJavaIdentiferStart()}? - | // covers UTF-16 surrogate pairs encodings for U+10000 to U+10FFFF - [\uD800-\uDBFF] [\uDC00-\uDFFF] {this.wasJavaIdentiferStartUTF16()}? - ; - -fragment -JavaLetterOrDigit - : [a-zA-Z0-9$_] // these are the "java letters or digits" below 0x7F - | // covers all characters above 0x7F which are not a surrogate - ~[\u0000-\u007F\uD800-\uDBFF] {this.wasJavaIdentiferPart()}? - | // covers UTF-16 surrogate pairs encodings for U+10000 to U+10FFFF - [\uD800-\uDBFF] [\uDC00-\uDFFF] {this.wasJavaIdentiferPartUTF16()}? - ;*/ - -// Dropped SMP support as ANTLR has no native support for it -fragment IdentifierStart: - [\u0024] - | [\u0041-\u005A] - | [\u005F] - | [\u0061-\u007A] - | [\u00A2-\u00A5] - | [\u00AA] - | [\u00B5] - | [\u00BA] - | [\u00C0-\u00D6] - | [\u00D8-\u00F6] - | [\u00F8-\u02C1] - | [\u02C6-\u02D1] - | [\u02E0-\u02E4] - | [\u02EC] - | [\u02EE] - | [\u0370-\u0374] - | [\u0376-\u0377] - | [\u037A-\u037D] - | [\u037F] - | [\u0386] - | [\u0388-\u038A] - | [\u038C] - | [\u038E-\u03A1] - | [\u03A3-\u03F5] - | [\u03F7-\u0481] - | [\u048A-\u052F] - | [\u0531-\u0556] - | [\u0559] - | [\u0561-\u0587] - | [\u058F] - | [\u05D0-\u05EA] - | [\u05F0-\u05F2] - | [\u060B] - | [\u0620-\u064A] - | [\u066E-\u066F] - | [\u0671-\u06D3] - | [\u06D5] - | [\u06E5-\u06E6] - | [\u06EE-\u06EF] - | [\u06FA-\u06FC] - | [\u06FF] - | [\u0710] - | [\u0712-\u072F] - | [\u074D-\u07A5] - | [\u07B1] - | [\u07CA-\u07EA] - | [\u07F4-\u07F5] - | [\u07FA] - | [\u0800-\u0815] - | [\u081A] - | [\u0824] - | [\u0828] - | [\u0840-\u0858] - | [\u0860-\u086A] - | [\u08A0-\u08B4] - | [\u08B6-\u08BD] - | [\u0904-\u0939] - | [\u093D] - | [\u0950] - | [\u0958-\u0961] - | [\u0971-\u0980] - | [\u0985-\u098C] - | [\u098F-\u0990] - | [\u0993-\u09A8] - | [\u09AA-\u09B0] - | [\u09B2] - | [\u09B6-\u09B9] - | [\u09BD] - | [\u09CE] - | [\u09DC-\u09DD] - | [\u09DF-\u09E1] - | [\u09F0-\u09F3] - | [\u09FB-\u09FC] - | [\u0A05-\u0A0A] - | [\u0A0F-\u0A10] - | [\u0A13-\u0A28] - | [\u0A2A-\u0A30] - | [\u0A32-\u0A33] - | [\u0A35-\u0A36] - | [\u0A38-\u0A39] - | [\u0A59-\u0A5C] - | [\u0A5E] - | [\u0A72-\u0A74] - | [\u0A85-\u0A8D] - | [\u0A8F-\u0A91] - | [\u0A93-\u0AA8] - | [\u0AAA-\u0AB0] - | [\u0AB2-\u0AB3] - | [\u0AB5-\u0AB9] - | [\u0ABD] - | [\u0AD0] - | [\u0AE0-\u0AE1] - | [\u0AF1] - | [\u0AF9] - | [\u0B05-\u0B0C] - | [\u0B0F-\u0B10] - | [\u0B13-\u0B28] - | [\u0B2A-\u0B30] - | [\u0B32-\u0B33] - | [\u0B35-\u0B39] - | [\u0B3D] - | [\u0B5C-\u0B5D] - | [\u0B5F-\u0B61] - | [\u0B71] - | [\u0B83] - | [\u0B85-\u0B8A] - | [\u0B8E-\u0B90] - | [\u0B92-\u0B95] - | [\u0B99-\u0B9A] - | [\u0B9C] - | [\u0B9E-\u0B9F] - | [\u0BA3-\u0BA4] - | [\u0BA8-\u0BAA] - | [\u0BAE-\u0BB9] - | [\u0BD0] - | [\u0BF9] - | [\u0C05-\u0C0C] - | [\u0C0E-\u0C10] - | [\u0C12-\u0C28] - | [\u0C2A-\u0C39] - | [\u0C3D] - | [\u0C58-\u0C5A] - | [\u0C60-\u0C61] - | [\u0C80] - | [\u0C85-\u0C8C] - | [\u0C8E-\u0C90] - | [\u0C92-\u0CA8] - | [\u0CAA-\u0CB3] - | [\u0CB5-\u0CB9] - | [\u0CBD] - | [\u0CDE] - | [\u0CE0-\u0CE1] - | [\u0CF1-\u0CF2] - | [\u0D05-\u0D0C] - | [\u0D0E-\u0D10] - | [\u0D12-\u0D3A] - | [\u0D3D] - | [\u0D4E] - | [\u0D54-\u0D56] - | [\u0D5F-\u0D61] - | [\u0D7A-\u0D7F] - | [\u0D85-\u0D96] - | [\u0D9A-\u0DB1] - | [\u0DB3-\u0DBB] - | [\u0DBD] - | [\u0DC0-\u0DC6] - | [\u0E01-\u0E30] - | [\u0E32-\u0E33] - | [\u0E3F-\u0E46] - | [\u0E81-\u0E82] - | [\u0E84] - | [\u0E87-\u0E88] - | [\u0E8A] - | [\u0E8D] - | [\u0E94-\u0E97] - | [\u0E99-\u0E9F] - | [\u0EA1-\u0EA3] - | [\u0EA5] - | [\u0EA7] - | [\u0EAA-\u0EAB] - | [\u0EAD-\u0EB0] - | [\u0EB2-\u0EB3] - | [\u0EBD] - | [\u0EC0-\u0EC4] - | [\u0EC6] - | [\u0EDC-\u0EDF] - | [\u0F00] - | [\u0F40-\u0F47] - | [\u0F49-\u0F6C] - | [\u0F88-\u0F8C] - | [\u1000-\u102A] - | [\u103F] - | [\u1050-\u1055] - | [\u105A-\u105D] - | [\u1061] - | [\u1065-\u1066] - | [\u106E-\u1070] - | [\u1075-\u1081] - | [\u108E] - | [\u10A0-\u10C5] - | [\u10C7] - | [\u10CD] - | [\u10D0-\u10FA] - | [\u10FC-\u1248] - | [\u124A-\u124D] - | [\u1250-\u1256] - | [\u1258] - | [\u125A-\u125D] - | [\u1260-\u1288] - | [\u128A-\u128D] - | [\u1290-\u12B0] - | [\u12B2-\u12B5] - | [\u12B8-\u12BE] - | [\u12C0] - | [\u12C2-\u12C5] - | [\u12C8-\u12D6] - | [\u12D8-\u1310] - | [\u1312-\u1315] - | [\u1318-\u135A] - | [\u1380-\u138F] - | [\u13A0-\u13F5] - | [\u13F8-\u13FD] - | [\u1401-\u166C] - | [\u166F-\u167F] - | [\u1681-\u169A] - | [\u16A0-\u16EA] - | [\u16EE-\u16F8] - | [\u1700-\u170C] - | [\u170E-\u1711] - | [\u1720-\u1731] - | [\u1740-\u1751] - | [\u1760-\u176C] - | [\u176E-\u1770] - | [\u1780-\u17B3] - | [\u17D7] - | [\u17DB-\u17DC] - | [\u1820-\u1877] - | [\u1880-\u1884] - | [\u1887-\u18A8] - | [\u18AA] - | [\u18B0-\u18F5] - | [\u1900-\u191E] - | [\u1950-\u196D] - | [\u1970-\u1974] - | [\u1980-\u19AB] - | [\u19B0-\u19C9] - | [\u1A00-\u1A16] - | [\u1A20-\u1A54] - | [\u1AA7] - | [\u1B05-\u1B33] - | [\u1B45-\u1B4B] - | [\u1B83-\u1BA0] - | [\u1BAE-\u1BAF] - | [\u1BBA-\u1BE5] - | [\u1C00-\u1C23] - | [\u1C4D-\u1C4F] - | [\u1C5A-\u1C7D] - | [\u1C80-\u1C88] - | [\u1CE9-\u1CEC] - | [\u1CEE-\u1CF1] - | [\u1CF5-\u1CF6] - | [\u1D00-\u1DBF] - | [\u1E00-\u1F15] - | [\u1F18-\u1F1D] - | [\u1F20-\u1F45] - | [\u1F48-\u1F4D] - | [\u1F50-\u1F57] - | [\u1F59] - | [\u1F5B] - | [\u1F5D] - | [\u1F5F-\u1F7D] - | [\u1F80-\u1FB4] - | [\u1FB6-\u1FBC] - | [\u1FBE] - | [\u1FC2-\u1FC4] - | [\u1FC6-\u1FCC] - | [\u1FD0-\u1FD3] - | [\u1FD6-\u1FDB] - | [\u1FE0-\u1FEC] - | [\u1FF2-\u1FF4] - | [\u1FF6-\u1FFC] - | [\u203F-\u2040] - | [\u2054] - | [\u2071] - | [\u207F] - | [\u2090-\u209C] - | [\u20A0-\u20BF] - | [\u2102] - | [\u2107] - | [\u210A-\u2113] - | [\u2115] - | [\u2119-\u211D] - | [\u2124] - | [\u2126] - | [\u2128] - | [\u212A-\u212D] - | [\u212F-\u2139] - | [\u213C-\u213F] - | [\u2145-\u2149] - | [\u214E] - | [\u2160-\u2188] - | [\u2C00-\u2C2E] - | [\u2C30-\u2C5E] - | [\u2C60-\u2CE4] - | [\u2CEB-\u2CEE] - | [\u2CF2-\u2CF3] - | [\u2D00-\u2D25] - | [\u2D27] - | [\u2D2D] - | [\u2D30-\u2D67] - | [\u2D6F] - | [\u2D80-\u2D96] - | [\u2DA0-\u2DA6] - | [\u2DA8-\u2DAE] - | [\u2DB0-\u2DB6] - | [\u2DB8-\u2DBE] - | [\u2DC0-\u2DC6] - | [\u2DC8-\u2DCE] - | [\u2DD0-\u2DD6] - | [\u2DD8-\u2DDE] - | [\u2E2F] - | [\u3005-\u3007] - | [\u3021-\u3029] - | [\u3031-\u3035] - | [\u3038-\u303C] - | [\u3041-\u3096] - | [\u309D-\u309F] - | [\u30A1-\u30FA] - | [\u30FC-\u30FF] - | [\u3105-\u312E] - | [\u3131-\u318E] - | [\u31A0-\u31BA] - | [\u31F0-\u31FF] - | [\u3400-\u4DB5] - | [\u4E00-\u9FEA] - | [\uA000-\uA48C] - | [\uA4D0-\uA4FD] - | [\uA500-\uA60C] - | [\uA610-\uA61F] - | [\uA62A-\uA62B] - | [\uA640-\uA66E] - | [\uA67F-\uA69D] - | [\uA6A0-\uA6EF] - | [\uA717-\uA71F] - | [\uA722-\uA788] - | [\uA78B-\uA7AE] - | [\uA7B0-\uA7B7] - | [\uA7F7-\uA801] - | [\uA803-\uA805] - | [\uA807-\uA80A] - | [\uA80C-\uA822] - | [\uA838] - | [\uA840-\uA873] - | [\uA882-\uA8B3] - | [\uA8F2-\uA8F7] - | [\uA8FB] - | [\uA8FD] - | [\uA90A-\uA925] - | [\uA930-\uA946] - | [\uA960-\uA97C] - | [\uA984-\uA9B2] - | [\uA9CF] - | [\uA9E0-\uA9E4] - | [\uA9E6-\uA9EF] - | [\uA9FA-\uA9FE] - | [\uAA00-\uAA28] - | [\uAA40-\uAA42] - | [\uAA44-\uAA4B] - | [\uAA60-\uAA76] - | [\uAA7A] - | [\uAA7E-\uAAAF] - | [\uAAB1] - | [\uAAB5-\uAAB6] - | [\uAAB9-\uAABD] - | [\uAAC0] - | [\uAAC2] - | [\uAADB-\uAADD] - | [\uAAE0-\uAAEA] - | [\uAAF2-\uAAF4] - | [\uAB01-\uAB06] - | [\uAB09-\uAB0E] - | [\uAB11-\uAB16] - | [\uAB20-\uAB26] - | [\uAB28-\uAB2E] - | [\uAB30-\uAB5A] - | [\uAB5C-\uAB65] - | [\uAB70-\uABE2] - | [\uAC00-\uD7A3] - | [\uD7B0-\uD7C6] - | [\uD7CB-\uD7FB] - | [\uF900-\uFA6D] - | [\uFA70-\uFAD9] - | [\uFB00-\uFB06] - | [\uFB13-\uFB17] - | [\uFB1D] - | [\uFB1F-\uFB28] - | [\uFB2A-\uFB36] - | [\uFB38-\uFB3C] - | [\uFB3E] - | [\uFB40-\uFB41] - | [\uFB43-\uFB44] - | [\uFB46-\uFBB1] - | [\uFBD3-\uFD3D] - | [\uFD50-\uFD8F] - | [\uFD92-\uFDC7] - | [\uFDF0-\uFDFC] - | [\uFE33-\uFE34] - | [\uFE4D-\uFE4F] - | [\uFE69] - | [\uFE70-\uFE74] - | [\uFE76-\uFEFC] - | [\uFF04] - | [\uFF21-\uFF3A] - | [\uFF3F] - | [\uFF41-\uFF5A] - | [\uFF66-\uFFBE] - | [\uFFC2-\uFFC7] - | [\uFFCA-\uFFCF] - | [\uFFD2-\uFFD7] - | [\uFFDA-\uFFDC] - | [\uFFE0-\uFFE1] - | [\uFFE5-\uFFE6] -; - -fragment IdentifierPart: - IdentifierStart - | [\u0030-\u0039] - | [\u007F-\u009F] - | [\u00AD] - | [\u0300-\u036F] - | [\u0483-\u0487] - | [\u0591-\u05BD] - | [\u05BF] - | [\u05C1-\u05C2] - | [\u05C4-\u05C5] - | [\u05C7] - | [\u0600-\u0605] - | [\u0610-\u061A] - | [\u061C] - | [\u064B-\u0669] - | [\u0670] - | [\u06D6-\u06DD] - | [\u06DF-\u06E4] - | [\u06E7-\u06E8] - | [\u06EA-\u06ED] - | [\u06F0-\u06F9] - | [\u070F] - | [\u0711] - | [\u0730-\u074A] - | [\u07A6-\u07B0] - | [\u07C0-\u07C9] - | [\u07EB-\u07F3] - | [\u0816-\u0819] - | [\u081B-\u0823] - | [\u0825-\u0827] - | [\u0829-\u082D] - | [\u0859-\u085B] - | [\u08D4-\u0903] - | [\u093A-\u093C] - | [\u093E-\u094F] - | [\u0951-\u0957] - | [\u0962-\u0963] - | [\u0966-\u096F] - | [\u0981-\u0983] - | [\u09BC] - | [\u09BE-\u09C4] - | [\u09C7-\u09C8] - | [\u09CB-\u09CD] - | [\u09D7] - | [\u09E2-\u09E3] - | [\u09E6-\u09EF] - | [\u0A01-\u0A03] - | [\u0A3C] - | [\u0A3E-\u0A42] - | [\u0A47-\u0A48] - | [\u0A4B-\u0A4D] - | [\u0A51] - | [\u0A66-\u0A71] - | [\u0A75] - | [\u0A81-\u0A83] - | [\u0ABC] - | [\u0ABE-\u0AC5] - | [\u0AC7-\u0AC9] - | [\u0ACB-\u0ACD] - | [\u0AE2-\u0AE3] - | [\u0AE6-\u0AEF] - | [\u0AFA-\u0AFF] - | [\u0B01-\u0B03] - | [\u0B3C] - | [\u0B3E-\u0B44] - | [\u0B47-\u0B48] - | [\u0B4B-\u0B4D] - | [\u0B56-\u0B57] - | [\u0B62-\u0B63] - | [\u0B66-\u0B6F] - | [\u0B82] - | [\u0BBE-\u0BC2] - | [\u0BC6-\u0BC8] - | [\u0BCA-\u0BCD] - | [\u0BD7] - | [\u0BE6-\u0BEF] - | [\u0C00-\u0C03] - | [\u0C3E-\u0C44] - | [\u0C46-\u0C48] - | [\u0C4A-\u0C4D] - | [\u0C55-\u0C56] - | [\u0C62-\u0C63] - | [\u0C66-\u0C6F] - | [\u0C81-\u0C83] - | [\u0CBC] - | [\u0CBE-\u0CC4] - | [\u0CC6-\u0CC8] - | [\u0CCA-\u0CCD] - | [\u0CD5-\u0CD6] - | [\u0CE2-\u0CE3] - | [\u0CE6-\u0CEF] - | [\u0D00-\u0D03] - | [\u0D3B-\u0D3C] - | [\u0D3E-\u0D44] - | [\u0D46-\u0D48] - | [\u0D4A-\u0D4D] - | [\u0D57] - | [\u0D62-\u0D63] - | [\u0D66-\u0D6F] - | [\u0D82-\u0D83] - | [\u0DCA] - | [\u0DCF-\u0DD4] - | [\u0DD6] - | [\u0DD8-\u0DDF] - | [\u0DE6-\u0DEF] - | [\u0DF2-\u0DF3] - | [\u0E31] - | [\u0E34-\u0E3A] - | [\u0E47-\u0E4E] - | [\u0E50-\u0E59] - | [\u0EB1] - | [\u0EB4-\u0EB9] - | [\u0EBB-\u0EBC] - | [\u0EC8-\u0ECD] - | [\u0ED0-\u0ED9] - | [\u0F18-\u0F19] - | [\u0F20-\u0F29] - | [\u0F35] - | [\u0F37] - | [\u0F39] - | [\u0F3E-\u0F3F] - | [\u0F71-\u0F84] - | [\u0F86-\u0F87] - | [\u0F8D-\u0F97] - | [\u0F99-\u0FBC] - | [\u0FC6] - | [\u102B-\u103E] - | [\u1040-\u1049] - | [\u1056-\u1059] - | [\u105E-\u1060] - | [\u1062-\u1064] - | [\u1067-\u106D] - | [\u1071-\u1074] - | [\u1082-\u108D] - | [\u108F-\u109D] - | [\u135D-\u135F] - | [\u1712-\u1714] - | [\u1732-\u1734] - | [\u1752-\u1753] - | [\u1772-\u1773] - | [\u17B4-\u17D3] - | [\u17DD] - | [\u17E0-\u17E9] - | [\u180B-\u180E] - | [\u1810-\u1819] - | [\u1885-\u1886] - | [\u18A9] - | [\u1920-\u192B] - | [\u1930-\u193B] - | [\u1946-\u194F] - | [\u19D0-\u19D9] - | [\u1A17-\u1A1B] - | [\u1A55-\u1A5E] - | [\u1A60-\u1A7C] - | [\u1A7F-\u1A89] - | [\u1A90-\u1A99] - | [\u1AB0-\u1ABD] - | [\u1B00-\u1B04] - | [\u1B34-\u1B44] - | [\u1B50-\u1B59] - | [\u1B6B-\u1B73] - | [\u1B80-\u1B82] - | [\u1BA1-\u1BAD] - | [\u1BB0-\u1BB9] - | [\u1BE6-\u1BF3] - | [\u1C24-\u1C37] - | [\u1C40-\u1C49] - | [\u1C50-\u1C59] - | [\u1CD0-\u1CD2] - | [\u1CD4-\u1CE8] - | [\u1CED] - | [\u1CF2-\u1CF4] - | [\u1CF7-\u1CF9] - | [\u1DC0-\u1DF9] - | [\u1DFB-\u1DFF] - | [\u200B-\u200F] - | [\u202A-\u202E] - | [\u2060-\u2064] - | [\u2066-\u206F] - | [\u20D0-\u20DC] - | [\u20E1] - | [\u20E5-\u20F0] - | [\u2CEF-\u2CF1] - | [\u2D7F] - | [\u2DE0-\u2DFF] - | [\u302A-\u302F] - | [\u3099-\u309A] - | [\uA620-\uA629] - | [\uA66F] - | [\uA674-\uA67D] - | [\uA69E-\uA69F] - | [\uA6F0-\uA6F1] - | [\uA802] - | [\uA806] - | [\uA80B] - | [\uA823-\uA827] - | [\uA880-\uA881] - | [\uA8B4-\uA8C5] - | [\uA8D0-\uA8D9] - | [\uA8E0-\uA8F1] - | [\uA900-\uA909] - | [\uA926-\uA92D] - | [\uA947-\uA953] - | [\uA980-\uA983] - | [\uA9B3-\uA9C0] - | [\uA9D0-\uA9D9] - | [\uA9E5] - | [\uA9F0-\uA9F9] - | [\uAA29-\uAA36] - | [\uAA43] - | [\uAA4C-\uAA4D] - | [\uAA50-\uAA59] - | [\uAA7B-\uAA7D] - | [\uAAB0] - | [\uAAB2-\uAAB4] - | [\uAAB7-\uAAB8] - | [\uAABE-\uAABF] - | [\uAAC1] - | [\uAAEB-\uAAEF] - | [\uAAF5-\uAAF6] - | [\uABE3-\uABEA] - | [\uABEC-\uABED] - | [\uABF0-\uABF9] - | [\uFB1E] - | [\uFE00-\uFE0F] - | [\uFE20-\uFE2F] - | [\uFEFF] - | [\uFF10-\uFF19] - | [\uFFF9-\uFFFB] -; - -// -// Additional symbols not defined in the lexical specification -// - -AT : '@'; -ELLIPSIS : '...'; - -// -// Whitespace and comments -// - -WS: [ \t\r\n\u000C]+ -> skip; - -COMMENT: '/*' .*? '*/' -> skip; - -LINE_COMMENT: '//' ~[\r\n]* -> skip; \ No newline at end of file diff --git a/benchmarks/src/main/java/org/antlr/Java8Parser.g4 b/benchmarks/src/main/java/org/antlr/Java8Parser.g4 deleted file mode 100644 index 8b6b46615..000000000 --- a/benchmarks/src/main/java/org/antlr/Java8Parser.g4 +++ /dev/null @@ -1,1335 +0,0 @@ -/* - * [The "BSD license"] - * Copyright (c) 2014 Terence Parr - * Copyright (c) 2014 Sam Harwell - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * 3. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR - * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES - * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. - * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, - * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, - * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 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 OF - * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -/** - * A Java 8 grammar for ANTLR 4 derived from the Java Language Specification - * chapter 19. - * - * NOTE: This grammar results in a generated parser that is much slower - * than the Java 7 grammar in the grammars-v4/java directory. This - * one is, however, extremely close to the spec. - * - * You can test with - * - * $ antlr4 Java8.g4 - * $ javac *.java - * $ grun Java8 compilationUnit *.java - * - * Or, -~/antlr/code/grammars-v4/java8 $ java Test . -/Users/parrt/antlr/code/grammars-v4/java8/./Java8BaseListener.java -/Users/parrt/antlr/code/grammars-v4/java8/./Java8Lexer.java -/Users/parrt/antlr/code/grammars-v4/java8/./Java8Listener.java -/Users/parrt/antlr/code/grammars-v4/java8/./Java8Parser.java -/Users/parrt/antlr/code/grammars-v4/java8/./Test.java -Total lexer+parser time 30844ms. - */ - -// $antlr-format alignTrailingComments true, columnLimit 150, minEmptyLines 1, maxEmptyLinesToKeep 1, reflowComments false, useTab false -// $antlr-format allowShortRulesOnASingleLine false, allowShortBlocksOnASingleLine true, alignSemicolons hanging, alignColons hanging - -parser grammar Java8Parser; - -options { - tokenVocab = Java8Lexer; -} - -/* - * Productions from §3 (Lexical Structure) - */ - -literal - : IntegerLiteral - | FloatingPointLiteral - | BooleanLiteral - | CharacterLiteral - | StringLiteral - | NullLiteral - ; - -/* - * Productions from §4 (Types, Values, and Variables) - */ - -primitiveType - : annotation* numericType - | annotation* 'boolean' - ; - -numericType - : integralType - | floatingPointType - ; - -integralType - : 'byte' - | 'short' - | 'int' - | 'long' - | 'char' - ; - -floatingPointType - : 'float' - | 'double' - ; - -referenceType - : classOrInterfaceType - | typeVariable - | arrayType - ; - -classOrInterfaceType - : (classType_lfno_classOrInterfaceType | interfaceType_lfno_classOrInterfaceType) ( - classType_lf_classOrInterfaceType - | interfaceType_lf_classOrInterfaceType - )* - ; - -classType - : annotation* Identifier typeArguments? - | classOrInterfaceType '.' annotation* Identifier typeArguments? - ; - -classType_lf_classOrInterfaceType - : '.' annotation* Identifier typeArguments? - ; - -classType_lfno_classOrInterfaceType - : annotation* Identifier typeArguments? - ; - -interfaceType - : classType - ; - -interfaceType_lf_classOrInterfaceType - : classType_lf_classOrInterfaceType - ; - -interfaceType_lfno_classOrInterfaceType - : classType_lfno_classOrInterfaceType - ; - -typeVariable - : annotation* Identifier - ; - -arrayType - : primitiveType dims - | classOrInterfaceType dims - | typeVariable dims - ; - -dims - : annotation* '[' ']' (annotation* '[' ']')* - ; - -typeParameter - : typeParameterModifier* Identifier typeBound? - ; - -typeParameterModifier - : annotation - ; - -typeBound - : 'extends' typeVariable - | 'extends' classOrInterfaceType additionalBound* - ; - -additionalBound - : '&' interfaceType - ; - -typeArguments - : '<' typeArgumentList '>' - ; - -typeArgumentList - : typeArgument (',' typeArgument)* - ; - -typeArgument - : referenceType - | wildcard - ; - -wildcard - : annotation* '?' wildcardBounds? - ; - -wildcardBounds - : 'extends' referenceType - | 'super' referenceType - ; - -/* - * Productions from §6 (Names) - */ - -packageName - : Identifier - | packageName '.' Identifier - ; - -typeName - : Identifier - | packageOrTypeName '.' Identifier - ; - -packageOrTypeName - : Identifier - | packageOrTypeName '.' Identifier - ; - -expressionName - : Identifier - | ambiguousName '.' Identifier - ; - -methodName - : Identifier - ; - -ambiguousName - : Identifier - | ambiguousName '.' Identifier - ; - -/* - * Productions from §7 (Packages) - */ - -compilationUnit - : packageDeclaration? importDeclaration* typeDeclaration* EOF - ; - -packageDeclaration - : packageModifier* 'package' packageName ';' - ; - -packageModifier - : annotation - ; - -importDeclaration - : singleTypeImportDeclaration - | typeImportOnDemandDeclaration - | singleStaticImportDeclaration - | staticImportOnDemandDeclaration - ; - -singleTypeImportDeclaration - : 'import' typeName ';' - ; - -typeImportOnDemandDeclaration - : 'import' packageOrTypeName '.' '*' ';' - ; - -singleStaticImportDeclaration - : 'import' 'static' typeName '.' Identifier ';' - ; - -staticImportOnDemandDeclaration - : 'import' 'static' typeName '.' '*' ';' - ; - -typeDeclaration - : classDeclaration - | interfaceDeclaration - | ';' - ; - -/* - * Productions from §8 (Classes) - */ - -classDeclaration - : normalClassDeclaration - | enumDeclaration - ; - -normalClassDeclaration - : classModifier* 'class' Identifier typeParameters? superclass? superinterfaces? classBody - ; - -classModifier - : annotation - | 'public' - | 'protected' - | 'private' - | 'abstract' - | 'static' - | 'final' - | 'strictfp' - ; - -typeParameters - : '<' typeParameterList '>' - ; - -typeParameterList - : typeParameter (',' typeParameter)* - ; - -superclass - : 'extends' classType - ; - -superinterfaces - : 'implements' interfaceTypeList - ; - -interfaceTypeList - : interfaceType (',' interfaceType)* - ; - -classBody - : '{' classBodyDeclaration* '}' - ; - -classBodyDeclaration - : classMemberDeclaration - | instanceInitializer - | staticInitializer - | constructorDeclaration - ; - -classMemberDeclaration - : fieldDeclaration - | methodDeclaration - | classDeclaration - | interfaceDeclaration - | ';' - ; - -fieldDeclaration - : fieldModifier* unannType variableDeclaratorList ';' - ; - -fieldModifier - : annotation - | 'public' - | 'protected' - | 'private' - | 'static' - | 'final' - | 'transient' - | 'volatile' - ; - -variableDeclaratorList - : variableDeclarator (',' variableDeclarator)* - ; - -variableDeclarator - : variableDeclaratorId ('=' variableInitializer)? - ; - -variableDeclaratorId - : Identifier dims? - ; - -variableInitializer - : expression - | arrayInitializer - ; - -unannType - : unannPrimitiveType - | unannReferenceType - ; - -unannPrimitiveType - : numericType - | 'boolean' - ; - -unannReferenceType - : unannClassOrInterfaceType - | unannTypeVariable - | unannArrayType - ; - -unannClassOrInterfaceType - : ( - unannClassType_lfno_unannClassOrInterfaceType - | unannInterfaceType_lfno_unannClassOrInterfaceType - ) ( - unannClassType_lf_unannClassOrInterfaceType - | unannInterfaceType_lf_unannClassOrInterfaceType - )* - ; - -unannClassType - : Identifier typeArguments? - | unannClassOrInterfaceType '.' annotation* Identifier typeArguments? - ; - -unannClassType_lf_unannClassOrInterfaceType - : '.' annotation* Identifier typeArguments? - ; - -unannClassType_lfno_unannClassOrInterfaceType - : Identifier typeArguments? - ; - -unannInterfaceType - : unannClassType - ; - -unannInterfaceType_lf_unannClassOrInterfaceType - : unannClassType_lf_unannClassOrInterfaceType - ; - -unannInterfaceType_lfno_unannClassOrInterfaceType - : unannClassType_lfno_unannClassOrInterfaceType - ; - -unannTypeVariable - : Identifier - ; - -unannArrayType - : unannPrimitiveType dims - | unannClassOrInterfaceType dims - | unannTypeVariable dims - ; - -methodDeclaration - : methodModifier* methodHeader methodBody - ; - -methodModifier - : annotation - | 'public' - | 'protected' - | 'private' - | 'abstract' - | 'static' - | 'final' - | 'synchronized' - | 'native' - | 'strictfp' - ; - -methodHeader - : result methodDeclarator throws_? - | typeParameters annotation* result methodDeclarator throws_? - ; - -result - : unannType - | 'void' - ; - -methodDeclarator - : Identifier '(' formalParameterList? ')' dims? - ; - -formalParameterList - : receiverParameter - | formalParameters ',' lastFormalParameter - | lastFormalParameter - ; - -formalParameters - : formalParameter (',' formalParameter)* - | receiverParameter (',' formalParameter)* - ; - -formalParameter - : variableModifier* unannType variableDeclaratorId - ; - -variableModifier - : annotation - | 'final' - ; - -lastFormalParameter - : variableModifier* unannType annotation* '...' variableDeclaratorId - | formalParameter - ; - -receiverParameter - : annotation* unannType (Identifier '.')? 'this' - ; - -throws_ - : 'throws' exceptionTypeList - ; - -exceptionTypeList - : exceptionType (',' exceptionType)* - ; - -exceptionType - : classType - | typeVariable - ; - -methodBody - : block - | ';' - ; - -instanceInitializer - : block - ; - -staticInitializer - : 'static' block - ; - -constructorDeclaration - : constructorModifier* constructorDeclarator throws_? constructorBody - ; - -constructorModifier - : annotation - | 'public' - | 'protected' - | 'private' - ; - -constructorDeclarator - : typeParameters? simpleTypeName '(' formalParameterList? ')' - ; - -simpleTypeName - : Identifier - ; - -constructorBody - : '{' explicitConstructorInvocation? blockStatements? '}' - ; - -explicitConstructorInvocation - : typeArguments? 'this' '(' argumentList? ')' ';' - | typeArguments? 'super' '(' argumentList? ')' ';' - | expressionName '.' typeArguments? 'super' '(' argumentList? ')' ';' - | primary '.' typeArguments? 'super' '(' argumentList? ')' ';' - ; - -enumDeclaration - : classModifier* 'enum' Identifier superinterfaces? enumBody - ; - -enumBody - : '{' enumConstantList? ','? enumBodyDeclarations? '}' - ; - -enumConstantList - : enumConstant (',' enumConstant)* - ; - -enumConstant - : enumConstantModifier* Identifier ('(' argumentList? ')')? classBody? - ; - -enumConstantModifier - : annotation - ; - -enumBodyDeclarations - : ';' classBodyDeclaration* - ; - -/* - * Productions from §9 (Interfaces) - */ - -interfaceDeclaration - : normalInterfaceDeclaration - | annotationTypeDeclaration - ; - -normalInterfaceDeclaration - : interfaceModifier* 'interface' Identifier typeParameters? extendsInterfaces? interfaceBody - ; - -interfaceModifier - : annotation - | 'public' - | 'protected' - | 'private' - | 'abstract' - | 'static' - | 'strictfp' - ; - -extendsInterfaces - : 'extends' interfaceTypeList - ; - -interfaceBody - : '{' interfaceMemberDeclaration* '}' - ; - -interfaceMemberDeclaration - : constantDeclaration - | interfaceMethodDeclaration - | classDeclaration - | interfaceDeclaration - | ';' - ; - -constantDeclaration - : constantModifier* unannType variableDeclaratorList ';' - ; - -constantModifier - : annotation - | 'public' - | 'static' - | 'final' - ; - -interfaceMethodDeclaration - : interfaceMethodModifier* methodHeader methodBody - ; - -interfaceMethodModifier - : annotation - | 'public' - | 'abstract' - | 'default' - | 'static' - | 'strictfp' - ; - -annotationTypeDeclaration - : interfaceModifier* '@' 'interface' Identifier annotationTypeBody - ; - -annotationTypeBody - : '{' annotationTypeMemberDeclaration* '}' - ; - -annotationTypeMemberDeclaration - : annotationTypeElementDeclaration - | constantDeclaration - | classDeclaration - | interfaceDeclaration - | ';' - ; - -annotationTypeElementDeclaration - : annotationTypeElementModifier* unannType Identifier '(' ')' dims? defaultValue? ';' - ; - -annotationTypeElementModifier - : annotation - | 'public' - | 'abstract' - ; - -defaultValue - : 'default' elementValue - ; - -annotation - : normalAnnotation - | markerAnnotation - | singleElementAnnotation - ; - -normalAnnotation - : '@' typeName '(' elementValuePairList? ')' - ; - -elementValuePairList - : elementValuePair (',' elementValuePair)* - ; - -elementValuePair - : Identifier '=' elementValue - ; - -elementValue - : conditionalExpression - | elementValueArrayInitializer - | annotation - ; - -elementValueArrayInitializer - : '{' elementValueList? ','? '}' - ; - -elementValueList - : elementValue (',' elementValue)* - ; - -markerAnnotation - : '@' typeName - ; - -singleElementAnnotation - : '@' typeName '(' elementValue ')' - ; - -/* - * Productions from §10 (Arrays) - */ - -arrayInitializer - : '{' variableInitializerList? ','? '}' - ; - -variableInitializerList - : variableInitializer (',' variableInitializer)* - ; - -/* - * Productions from §14 (Blocks and Statements) - */ - -block - : '{' blockStatements? '}' - ; - -blockStatements - : blockStatement+ - ; - -blockStatement - : localVariableDeclarationStatement - | classDeclaration - | statement - ; - -localVariableDeclarationStatement - : localVariableDeclaration ';' - ; - -localVariableDeclaration - : variableModifier* unannType variableDeclaratorList - ; - -statement - : statementWithoutTrailingSubstatement - | labeledStatement - | ifThenStatement - | ifThenElseStatement - | whileStatement - | forStatement - ; - -statementNoShortIf - : statementWithoutTrailingSubstatement - | labeledStatementNoShortIf - | ifThenElseStatementNoShortIf - | whileStatementNoShortIf - | forStatementNoShortIf - ; - -statementWithoutTrailingSubstatement - : block - | emptyStatement_ - | expressionStatement - | assertStatement - | switchStatement - | doStatement - | breakStatement - | continueStatement - | returnStatement - | synchronizedStatement - | throwStatement - | tryStatement - ; - -emptyStatement_ - : ';' - ; - -labeledStatement - : Identifier ':' statement - ; - -labeledStatementNoShortIf - : Identifier ':' statementNoShortIf - ; - -expressionStatement - : statementExpression ';' - ; - -statementExpression - : assignment - | preIncrementExpression - | preDecrementExpression - | postIncrementExpression - | postDecrementExpression - | methodInvocation - | classInstanceCreationExpression - ; - -ifThenStatement - : 'if' '(' expression ')' statement - ; - -ifThenElseStatement - : 'if' '(' expression ')' statementNoShortIf 'else' statement - ; - -ifThenElseStatementNoShortIf - : 'if' '(' expression ')' statementNoShortIf 'else' statementNoShortIf - ; - -assertStatement - : 'assert' expression ';' - | 'assert' expression ':' expression ';' - ; - -switchStatement - : 'switch' '(' expression ')' switchBlock - ; - -switchBlock - : '{' switchBlockStatementGroup* switchLabel* '}' - ; - -switchBlockStatementGroup - : switchLabels blockStatements - ; - -switchLabels - : switchLabel switchLabel* - ; - -switchLabel - : 'case' constantExpression ':' - | 'case' enumConstantName ':' - | 'default' ':' - ; - -enumConstantName - : Identifier - ; - -whileStatement - : 'while' '(' expression ')' statement - ; - -whileStatementNoShortIf - : 'while' '(' expression ')' statementNoShortIf - ; - -doStatement - : 'do' statement 'while' '(' expression ')' ';' - ; - -forStatement - : basicForStatement - | enhancedForStatement - ; - -forStatementNoShortIf - : basicForStatementNoShortIf - | enhancedForStatementNoShortIf - ; - -basicForStatement - : 'for' '(' forInit? ';' expression? ';' forUpdate? ')' statement - ; - -basicForStatementNoShortIf - : 'for' '(' forInit? ';' expression? ';' forUpdate? ')' statementNoShortIf - ; - -forInit - : statementExpressionList - | localVariableDeclaration - ; - -forUpdate - : statementExpressionList - ; - -statementExpressionList - : statementExpression (',' statementExpression)* - ; - -enhancedForStatement - : 'for' '(' variableModifier* unannType variableDeclaratorId ':' expression ')' statement - ; - -enhancedForStatementNoShortIf - : 'for' '(' variableModifier* unannType variableDeclaratorId ':' expression ')' statementNoShortIf - ; - -breakStatement - : 'break' Identifier? ';' - ; - -continueStatement - : 'continue' Identifier? ';' - ; - -returnStatement - : 'return' expression? ';' - ; - -throwStatement - : 'throw' expression ';' - ; - -synchronizedStatement - : 'synchronized' '(' expression ')' block - ; - -tryStatement - : 'try' block catches - | 'try' block catches? finally_ - | tryWithResourcesStatement - ; - -catches - : catchClause catchClause* - ; - -catchClause - : 'catch' '(' catchFormalParameter ')' block - ; - -catchFormalParameter - : variableModifier* catchType variableDeclaratorId - ; - -catchType - : unannClassType ('|' classType)* - ; - -finally_ - : 'finally' block - ; - -tryWithResourcesStatement - : 'try' resourceSpecification block catches? finally_? - ; - -resourceSpecification - : '(' resourceList ';'? ')' - ; - -resourceList - : resource (';' resource)* - ; - -resource - : variableModifier* unannType variableDeclaratorId '=' expression - ; - -/* - * Productions from §15 (Expressions) - */ - -primary - : (primaryNoNewArray_lfno_primary | arrayCreationExpression) primaryNoNewArray_lf_primary* - ; - -primaryNoNewArray - : literal - | typeName ('[' ']')* '.' 'class' - | 'void' '.' 'class' - | 'this' - | typeName '.' 'this' - | '(' expression ')' - | classInstanceCreationExpression - | fieldAccess - | arrayAccess - | methodInvocation - | methodReference - ; - -primaryNoNewArray_lf_arrayAccess - : - ; - -primaryNoNewArray_lfno_arrayAccess - : literal - | typeName ('[' ']')* '.' 'class' - | 'void' '.' 'class' - | 'this' - | typeName '.' 'this' - | '(' expression ')' - | classInstanceCreationExpression - | fieldAccess - | methodInvocation - | methodReference - ; - -primaryNoNewArray_lf_primary - : classInstanceCreationExpression_lf_primary - | fieldAccess_lf_primary - | arrayAccess_lf_primary - | methodInvocation_lf_primary - | methodReference_lf_primary - ; - -primaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary - : - ; - -primaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary - : classInstanceCreationExpression_lf_primary - | fieldAccess_lf_primary - | methodInvocation_lf_primary - | methodReference_lf_primary - ; - -primaryNoNewArray_lfno_primary - : literal - | typeName ('[' ']')* '.' 'class' - | unannPrimitiveType ('[' ']')* '.' 'class' - | 'void' '.' 'class' - | 'this' - | typeName '.' 'this' - | '(' expression ')' - | classInstanceCreationExpression_lfno_primary - | fieldAccess_lfno_primary - | arrayAccess_lfno_primary - | methodInvocation_lfno_primary - | methodReference_lfno_primary - ; - -primaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary - : - ; - -primaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary - : literal - | typeName ('[' ']')* '.' 'class' - | unannPrimitiveType ('[' ']')* '.' 'class' - | 'void' '.' 'class' - | 'this' - | typeName '.' 'this' - | '(' expression ')' - | classInstanceCreationExpression_lfno_primary - | fieldAccess_lfno_primary - | methodInvocation_lfno_primary - | methodReference_lfno_primary - ; - -classInstanceCreationExpression - : 'new' typeArguments? annotation* Identifier ('.' annotation* Identifier)* typeArgumentsOrDiamond? '(' argumentList? ')' classBody? - | expressionName '.' 'new' typeArguments? annotation* Identifier typeArgumentsOrDiamond? '(' argumentList? ')' classBody? - | primary '.' 'new' typeArguments? annotation* Identifier typeArgumentsOrDiamond? '(' argumentList? ')' classBody? - ; - -classInstanceCreationExpression_lf_primary - : '.' 'new' typeArguments? annotation* Identifier typeArgumentsOrDiamond? '(' argumentList? ')' classBody? - ; - -classInstanceCreationExpression_lfno_primary - : 'new' typeArguments? annotation* Identifier ('.' annotation* Identifier)* typeArgumentsOrDiamond? '(' argumentList? ')' classBody? - | expressionName '.' 'new' typeArguments? annotation* Identifier typeArgumentsOrDiamond? '(' argumentList? ')' classBody? - ; - -typeArgumentsOrDiamond - : typeArguments - | '<' '>' - ; - -fieldAccess - : primary '.' Identifier - | 'super' '.' Identifier - | typeName '.' 'super' '.' Identifier - ; - -fieldAccess_lf_primary - : '.' Identifier - ; - -fieldAccess_lfno_primary - : 'super' '.' Identifier - | typeName '.' 'super' '.' Identifier - ; - -arrayAccess - : (expressionName '[' expression ']' | primaryNoNewArray_lfno_arrayAccess '[' expression ']') ( - primaryNoNewArray_lf_arrayAccess '[' expression ']' - )* - ; - -arrayAccess_lf_primary - : primaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary '[' expression ']' ( - primaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary '[' expression ']' - )* - ; - -arrayAccess_lfno_primary - : ( - expressionName '[' expression ']' - | primaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary '[' expression ']' - ) (primaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary '[' expression ']')* - ; - -methodInvocation - : methodName '(' argumentList? ')' - | typeName '.' typeArguments? Identifier '(' argumentList? ')' - | expressionName '.' typeArguments? Identifier '(' argumentList? ')' - | primary '.' typeArguments? Identifier '(' argumentList? ')' - | 'super' '.' typeArguments? Identifier '(' argumentList? ')' - | typeName '.' 'super' '.' typeArguments? Identifier '(' argumentList? ')' - ; - -methodInvocation_lf_primary - : '.' typeArguments? Identifier '(' argumentList? ')' - ; - -methodInvocation_lfno_primary - : methodName '(' argumentList? ')' - | typeName '.' typeArguments? Identifier '(' argumentList? ')' - | expressionName '.' typeArguments? Identifier '(' argumentList? ')' - | 'super' '.' typeArguments? Identifier '(' argumentList? ')' - | typeName '.' 'super' '.' typeArguments? Identifier '(' argumentList? ')' - ; - -argumentList - : expression (',' expression)* - ; - -methodReference - : expressionName '::' typeArguments? Identifier - | referenceType '::' typeArguments? Identifier - | primary '::' typeArguments? Identifier - | 'super' '::' typeArguments? Identifier - | typeName '.' 'super' '::' typeArguments? Identifier - | classType '::' typeArguments? 'new' - | arrayType '::' 'new' - ; - -methodReference_lf_primary - : '::' typeArguments? Identifier - ; - -methodReference_lfno_primary - : expressionName '::' typeArguments? Identifier - | referenceType '::' typeArguments? Identifier - | 'super' '::' typeArguments? Identifier - | typeName '.' 'super' '::' typeArguments? Identifier - | classType '::' typeArguments? 'new' - | arrayType '::' 'new' - ; - -arrayCreationExpression - : 'new' primitiveType dimExprs dims? - | 'new' classOrInterfaceType dimExprs dims? - | 'new' primitiveType dims arrayInitializer - | 'new' classOrInterfaceType dims arrayInitializer - ; - -dimExprs - : dimExpr dimExpr* - ; - -dimExpr - : annotation* '[' expression ']' - ; - -constantExpression - : expression - ; - -expression - : lambdaExpression - | assignmentExpression - ; - -lambdaExpression - : lambdaParameters '->' lambdaBody - ; - -lambdaParameters - : Identifier - | '(' formalParameterList? ')' - | '(' inferredFormalParameterList ')' - ; - -inferredFormalParameterList - : Identifier (',' Identifier)* - ; - -lambdaBody - : expression - | block - ; - -assignmentExpression - : conditionalExpression - | assignment - ; - -assignment - : leftHandSide assignmentOperator expression - ; - -leftHandSide - : expressionName - | fieldAccess - | arrayAccess - ; - -assignmentOperator - : '=' - | '*=' - | '/=' - | '%=' - | '+=' - | '-=' - | '<<=' - | '>>=' - | '>>>=' - | '&=' - | '^=' - | '|=' - ; - -conditionalExpression - : conditionalOrExpression - | conditionalOrExpression '?' expression ':' conditionalExpression - ; - -conditionalOrExpression - : conditionalAndExpression - | conditionalOrExpression '||' conditionalAndExpression - ; - -conditionalAndExpression - : inclusiveOrExpression - | conditionalAndExpression '&&' inclusiveOrExpression - ; - -inclusiveOrExpression - : exclusiveOrExpression - | inclusiveOrExpression '|' exclusiveOrExpression - ; - -exclusiveOrExpression - : andExpression - | exclusiveOrExpression '^' andExpression - ; - -andExpression - : equalityExpression - | andExpression '&' equalityExpression - ; - -equalityExpression - : relationalExpression - | equalityExpression '==' relationalExpression - | equalityExpression '!=' relationalExpression - ; - -relationalExpression - : shiftExpression - | relationalExpression '<' shiftExpression - | relationalExpression '>' shiftExpression - | relationalExpression '<=' shiftExpression - | relationalExpression '>=' shiftExpression - | relationalExpression 'instanceof' referenceType - ; - -shiftExpression - : additiveExpression - | shiftExpression '<' '<' additiveExpression - | shiftExpression '>' '>' additiveExpression - | shiftExpression '>' '>' '>' additiveExpression - ; - -additiveExpression - : multiplicativeExpression - | additiveExpression '+' multiplicativeExpression - | additiveExpression '-' multiplicativeExpression - ; - -multiplicativeExpression - : unaryExpression - | multiplicativeExpression '*' unaryExpression - | multiplicativeExpression '/' unaryExpression - | multiplicativeExpression '%' unaryExpression - ; - -unaryExpression - : preIncrementExpression - | preDecrementExpression - | '+' unaryExpression - | '-' unaryExpression - | unaryExpressionNotPlusMinus - ; - -preIncrementExpression - : '++' unaryExpression - ; - -preDecrementExpression - : '--' unaryExpression - ; - -unaryExpressionNotPlusMinus - : postfixExpression - | '~' unaryExpression - | '!' unaryExpression - | castExpression - ; - -postfixExpression - : (primary | expressionName) ( - postIncrementExpression_lf_postfixExpression - | postDecrementExpression_lf_postfixExpression - )* - ; - -postIncrementExpression - : postfixExpression '++' - ; - -postIncrementExpression_lf_postfixExpression - : '++' - ; - -postDecrementExpression - : postfixExpression '--' - ; - -postDecrementExpression_lf_postfixExpression - : '--' - ; - -castExpression - : '(' primitiveType ')' unaryExpression - | '(' referenceType additionalBound* ')' unaryExpressionNotPlusMinus - | '(' referenceType additionalBound* ')' lambdaExpression - ; \ No newline at end of file diff --git a/benchmarks/src/main/java/org/antlr/fast/JavaLexer.g4 b/benchmarks/src/main/java/org/antlr/fast/JavaLexer.g4 deleted file mode 100644 index b3de61fea..000000000 --- a/benchmarks/src/main/java/org/antlr/fast/JavaLexer.g4 +++ /dev/null @@ -1,233 +0,0 @@ -/* - [The "BSD licence"] - Copyright (c) 2013 Terence Parr, Sam Harwell - Copyright (c) 2017 Ivan Kochurkin (upgrade to Java 8) - Copyright (c) 2021 Michał Lorek (upgrade to Java 11) - Copyright (c) 2022 Michał Lorek (upgrade to Java 17) - All rights reserved. - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions - are met: - 1. Redistributions of source code must retain the above copyright - notice, this list of conditions and the following disclaimer. - 2. Redistributions in binary form must reproduce the above copyright - notice, this list of conditions and the following disclaimer in the - documentation and/or other materials provided with the distribution. - 3. The name of the author may not be used to endorse or promote products - derived from this software without specific prior written permission. - - THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR - IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES - OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. - IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, - INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, - DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 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 OF - THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ - -// $antlr-format alignTrailingComments true, columnLimit 150, maxEmptyLinesToKeep 1, reflowComments false, useTab false -// $antlr-format allowShortRulesOnASingleLine true, allowShortBlocksOnASingleLine true, minEmptyLines 0, alignSemicolons ownLine -// $antlr-format alignColons trailing, singleLineOverrulesHangingColon true, alignLexerCommands true, alignLabels true, alignTrailers true - -lexer grammar JavaLexer; - -// Keywords - -ABSTRACT : 'abstract'; -ASSERT : 'assert'; -BOOLEAN : 'boolean'; -BREAK : 'break'; -BYTE : 'byte'; -CASE : 'case'; -CATCH : 'catch'; -CHAR : 'char'; -CLASS : 'class'; -CONST : 'const'; -CONTINUE : 'continue'; -DEFAULT : 'default'; -DO : 'do'; -DOUBLE : 'double'; -ELSE : 'else'; -ENUM : 'enum'; -EXTENDS : 'extends'; -FINAL : 'final'; -FINALLY : 'finally'; -FLOAT : 'float'; -FOR : 'for'; -IF : 'if'; -GOTO : 'goto'; -IMPLEMENTS : 'implements'; -IMPORT : 'import'; -INSTANCEOF : 'instanceof'; -INT : 'int'; -INTERFACE : 'interface'; -LONG : 'long'; -NATIVE : 'native'; -NEW : 'new'; -PACKAGE : 'package'; -PRIVATE : 'private'; -PROTECTED : 'protected'; -PUBLIC : 'public'; -RETURN : 'return'; -SHORT : 'short'; -STATIC : 'static'; -STRICTFP : 'strictfp'; -SUPER : 'super'; -SWITCH : 'switch'; -SYNCHRONIZED : 'synchronized'; -THIS : 'this'; -THROW : 'throw'; -THROWS : 'throws'; -TRANSIENT : 'transient'; -TRY : 'try'; -VOID : 'void'; -VOLATILE : 'volatile'; -WHILE : 'while'; - -// Module related keywords -MODULE : 'module'; -OPEN : 'open'; -REQUIRES : 'requires'; -EXPORTS : 'exports'; -OPENS : 'opens'; -TO : 'to'; -USES : 'uses'; -PROVIDES : 'provides'; -WITH : 'with'; -TRANSITIVE : 'transitive'; - -// Local Variable Type Inference -VAR: 'var'; // reserved type name - -// Switch Expressions -YIELD: 'yield'; // reserved type name from Java 14 - -// Records -RECORD: 'record'; - -// Sealed Classes -SEALED : 'sealed'; -PERMITS : 'permits'; -NON_SEALED : 'non-sealed'; - -// Literals - -DECIMAL_LITERAL : ('0' | [1-9] (Digits? | '_'+ Digits)) [lL]?; -HEX_LITERAL : '0' [xX] [0-9a-fA-F] ([0-9a-fA-F_]* [0-9a-fA-F])? [lL]?; -OCT_LITERAL : '0' '_'* [0-7] ([0-7_]* [0-7])? [lL]?; -BINARY_LITERAL : '0' [bB] [01] ([01_]* [01])? [lL]?; - -FLOAT_LITERAL: - (Digits '.' Digits? | '.' Digits) ExponentPart? [fFdD]? - | Digits (ExponentPart [fFdD]? | [fFdD]) -; - -HEX_FLOAT_LITERAL: '0' [xX] (HexDigits '.'? | HexDigits? '.' HexDigits) [pP] [+-]? Digits [fFdD]?; - -BOOL_LITERAL: 'true' | 'false'; - -CHAR_LITERAL: '\'' (~['\\\r\n] | EscapeSequence) '\''; - -STRING_LITERAL: '"' (~["\\\r\n] | EscapeSequence)* '"'; - -TEXT_BLOCK: '"""' [ \t]* [\r\n] (. | EscapeSequence)*? '"""'; - -NULL_LITERAL: 'null'; - -// Separators - -LPAREN : '('; -RPAREN : ')'; -LBRACE : '{'; -RBRACE : '}'; -LBRACK : '['; -RBRACK : ']'; -SEMI : ';'; -COMMA : ','; -DOT : '.'; - -// Operators - -ASSIGN : '='; -GT : '>'; -LT : '<'; -BANG : '!'; -TILDE : '~'; -QUESTION : '?'; -COLON : ':'; -EQUAL : '=='; -LE : '<='; -GE : '>='; -NOTEQUAL : '!='; -AND : '&&'; -OR : '||'; -INC : '++'; -DEC : '--'; -ADD : '+'; -SUB : '-'; -MUL : '*'; -DIV : '/'; -BITAND : '&'; -BITOR : '|'; -CARET : '^'; -MOD : '%'; - -ADD_ASSIGN : '+='; -SUB_ASSIGN : '-='; -MUL_ASSIGN : '*='; -DIV_ASSIGN : '/='; -AND_ASSIGN : '&='; -OR_ASSIGN : '|='; -XOR_ASSIGN : '^='; -MOD_ASSIGN : '%='; -LSHIFT_ASSIGN : '<<='; -RSHIFT_ASSIGN : '>>='; -URSHIFT_ASSIGN : '>>>='; - -// Java 8 tokens - -ARROW : '->'; -COLONCOLON : '::'; - -// Additional symbols not defined in the lexical specification - -AT : '@'; -ELLIPSIS : '...'; - -// Whitespace and comments - -WS : [ \t\r\n\u000C]+ -> channel(HIDDEN); -COMMENT : '/*' .*? '*/' -> channel(HIDDEN); -LINE_COMMENT : '//' ~[\r\n]* -> channel(HIDDEN); - -// Identifiers - -IDENTIFIER: Letter LetterOrDigit*; - -// Fragment rules - -fragment ExponentPart: [eE] [+-]? Digits; - -fragment EscapeSequence: - '\\' 'u005c'? [btnfr"'\\] - | '\\' 'u005c'? ([0-3]? [0-7])? [0-7] - | '\\' 'u'+ HexDigit HexDigit HexDigit HexDigit -; - -fragment HexDigits: HexDigit ((HexDigit | '_')* HexDigit)?; - -fragment HexDigit: [0-9a-fA-F]; - -fragment Digits: [0-9] ([0-9_]* [0-9])?; - -fragment LetterOrDigit: Letter | [0-9]; - -fragment Letter: - [a-zA-Z$_] // these are the "java letters" below 0x7F - | ~[\u0000-\u007F\uD800-\uDBFF] // covers all characters above 0x7F which are not a surrogate - | [\uD800-\uDBFF] [\uDC00-\uDFFF] // covers UTF-16 surrogate pairs encodings for U+10000 to U+10FFFF -; \ No newline at end of file diff --git a/benchmarks/src/main/java/org/antlr/fast/JavaParser.g4 b/benchmarks/src/main/java/org/antlr/fast/JavaParser.g4 deleted file mode 100644 index a240eb308..000000000 --- a/benchmarks/src/main/java/org/antlr/fast/JavaParser.g4 +++ /dev/null @@ -1,800 +0,0 @@ -/* - [The "BSD licence"] - Copyright (c) 2013 Terence Parr, Sam Harwell - Copyright (c) 2017 Ivan Kochurkin (upgrade to Java 8) - Copyright (c) 2021 Michał Lorek (upgrade to Java 11) - Copyright (c) 2022 Michał Lorek (upgrade to Java 17) - All rights reserved. - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions - are met: - 1. Redistributions of source code must retain the above copyright - notice, this list of conditions and the following disclaimer. - 2. Redistributions in binary form must reproduce the above copyright - notice, this list of conditions and the following disclaimer in the - documentation and/or other materials provided with the distribution. - 3. The name of the author may not be used to endorse or promote products - derived from this software without specific prior written permission. - - THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR - IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES - OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. - IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, - INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, - DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 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 OF - THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ - -// $antlr-format alignTrailingComments true, columnLimit 150, minEmptyLines 1, maxEmptyLinesToKeep 1, reflowComments false, useTab false -// $antlr-format allowShortRulesOnASingleLine false, allowShortBlocksOnASingleLine true, alignSemicolons hanging, alignColons hanging - -parser grammar JavaParser; - -options { - tokenVocab = JavaLexer; -} - -compilationUnit - : packageDeclaration? (importDeclaration | ';')* (typeDeclaration | ';')* - | moduleDeclaration EOF - ; - -packageDeclaration - : annotation* PACKAGE qualifiedName ';' - ; - -importDeclaration - : IMPORT STATIC? qualifiedName ('.' '*')? ';' - ; - -typeDeclaration - : classOrInterfaceModifier* ( - classDeclaration - | enumDeclaration - | interfaceDeclaration - | annotationTypeDeclaration - | recordDeclaration - ) - ; - -modifier - : classOrInterfaceModifier - | NATIVE - | SYNCHRONIZED - | TRANSIENT - | VOLATILE - ; - -classOrInterfaceModifier - : annotation - | PUBLIC - | PROTECTED - | PRIVATE - | STATIC - | ABSTRACT - | FINAL // FINAL for class only -- does not apply to interfaces - | STRICTFP - | SEALED // Java17 - | NON_SEALED // Java17 - ; - -variableModifier - : FINAL - | annotation - ; - -classDeclaration - : CLASS identifier typeParameters? (EXTENDS typeType)? (IMPLEMENTS typeList)? ( - PERMITS typeList - )? // Java17 - classBody - ; - -typeParameters - : '<' typeParameter (',' typeParameter)* '>' - ; - -typeParameter - : annotation* identifier (EXTENDS annotation* typeBound)? - ; - -typeBound - : typeType ('&' typeType)* - ; - -enumDeclaration - : ENUM identifier (IMPLEMENTS typeList)? '{' enumConstants? ','? enumBodyDeclarations? '}' - ; - -enumConstants - : enumConstant (',' enumConstant)* - ; - -enumConstant - : annotation* identifier arguments? classBody? - ; - -enumBodyDeclarations - : ';' classBodyDeclaration* - ; - -interfaceDeclaration - : INTERFACE identifier typeParameters? (EXTENDS typeList)? (PERMITS typeList)? interfaceBody - ; - -classBody - : '{' classBodyDeclaration* '}' - ; - -interfaceBody - : '{' interfaceBodyDeclaration* '}' - ; - -classBodyDeclaration - : ';' - | STATIC? block - | modifier* memberDeclaration - ; - -memberDeclaration - : recordDeclaration //Java17 - | methodDeclaration - | genericMethodDeclaration - | fieldDeclaration - | constructorDeclaration - | genericConstructorDeclaration - | interfaceDeclaration - | annotationTypeDeclaration - | classDeclaration - | enumDeclaration - ; - -/* We use rule this even for void methods which cannot have [] after parameters. - This simplifies grammar and we can consider void to be a type, which - renders the [] matching as a context-sensitive issue or a semantic check - for invalid return type after parsing. - */ -methodDeclaration - : typeTypeOrVoid identifier formalParameters ('[' ']')* (THROWS qualifiedNameList)? methodBody - ; - -methodBody - : block - | ';' - ; - -typeTypeOrVoid - : typeType - | VOID - ; - -genericMethodDeclaration - : typeParameters methodDeclaration - ; - -genericConstructorDeclaration - : typeParameters constructorDeclaration - ; - -constructorDeclaration - : identifier formalParameters (THROWS qualifiedNameList)? constructorBody = block - ; - -compactConstructorDeclaration - : modifier* identifier constructorBody = block - ; - -fieldDeclaration - : typeType variableDeclarators ';' - ; - -interfaceBodyDeclaration - : modifier* interfaceMemberDeclaration - | ';' - ; - -interfaceMemberDeclaration - : recordDeclaration // Java17 - | constDeclaration - | interfaceMethodDeclaration - | genericInterfaceMethodDeclaration - | interfaceDeclaration - | annotationTypeDeclaration - | classDeclaration - | enumDeclaration - ; - -constDeclaration - : typeType constantDeclarator (',' constantDeclarator)* ';' - ; - -constantDeclarator - : identifier ('[' ']')* '=' variableInitializer - ; - -// Early versions of Java allows brackets after the method name, eg. -// public int[] return2DArray() [] { ... } -// is the same as -// public int[][] return2DArray() { ... } -interfaceMethodDeclaration - : interfaceMethodModifier* interfaceCommonBodyDeclaration - ; - -// Java8 -interfaceMethodModifier - : annotation - | PUBLIC - | ABSTRACT - | DEFAULT - | STATIC - | STRICTFP - ; - -genericInterfaceMethodDeclaration - : interfaceMethodModifier* typeParameters interfaceCommonBodyDeclaration - ; - -interfaceCommonBodyDeclaration - : annotation* typeTypeOrVoid identifier formalParameters ('[' ']')* (THROWS qualifiedNameList)? methodBody - ; - -variableDeclarators - : variableDeclarator (',' variableDeclarator)* - ; - -variableDeclarator - : variableDeclaratorId ('=' variableInitializer)? - ; - -variableDeclaratorId - : identifier ('[' ']')* - ; - -variableInitializer - : arrayInitializer - | expression - ; - -arrayInitializer - : '{' (variableInitializer (',' variableInitializer)* ','?)? '}' - ; - -classOrInterfaceType - : (identifier typeArguments? '.')* typeIdentifier typeArguments? - ; - -typeArgument - : typeType - | annotation* '?' ((EXTENDS | SUPER) typeType)? - ; - -qualifiedNameList - : qualifiedName (',' qualifiedName)* - ; - -formalParameters - : '(' ( - receiverParameter? - | receiverParameter (',' formalParameterList)? - | formalParameterList? - ) ')' - ; - -receiverParameter - : typeType (identifier '.')* THIS - ; - -formalParameterList - : formalParameter (',' formalParameter)* (',' lastFormalParameter)? - | lastFormalParameter - ; - -formalParameter - : variableModifier* typeType variableDeclaratorId - ; - -lastFormalParameter - : variableModifier* typeType annotation* '...' variableDeclaratorId - ; - -// local variable type inference -lambdaLVTIList - : lambdaLVTIParameter (',' lambdaLVTIParameter)* - ; - -lambdaLVTIParameter - : variableModifier* VAR identifier - ; - -qualifiedName - : identifier ('.' identifier)* - ; - -literal - : integerLiteral - | floatLiteral - | CHAR_LITERAL - | STRING_LITERAL - | BOOL_LITERAL - | NULL_LITERAL - | TEXT_BLOCK // Java17 - ; - -integerLiteral - : DECIMAL_LITERAL - | HEX_LITERAL - | OCT_LITERAL - | BINARY_LITERAL - ; - -floatLiteral - : FLOAT_LITERAL - | HEX_FLOAT_LITERAL - ; - -// ANNOTATIONS -altAnnotationQualifiedName - : (identifier DOT)* '@' identifier - ; - -annotation - : ('@' qualifiedName | altAnnotationQualifiedName) ( - '(' ( elementValuePairs | elementValue)? ')' - )? - ; - -elementValuePairs - : elementValuePair (',' elementValuePair)* - ; - -elementValuePair - : identifier '=' elementValue - ; - -elementValue - : expression - | annotation - | elementValueArrayInitializer - ; - -elementValueArrayInitializer - : '{' (elementValue (',' elementValue)*)? ','? '}' - ; - -annotationTypeDeclaration - : '@' INTERFACE identifier annotationTypeBody - ; - -annotationTypeBody - : '{' annotationTypeElementDeclaration* '}' - ; - -annotationTypeElementDeclaration - : modifier* annotationTypeElementRest - | ';' // this is not allowed by the grammar, but apparently allowed by the actual compiler - ; - -annotationTypeElementRest - : typeType annotationMethodOrConstantRest ';' - | classDeclaration ';'? - | interfaceDeclaration ';'? - | enumDeclaration ';'? - | annotationTypeDeclaration ';'? - | recordDeclaration ';'? // Java17 - ; - -annotationMethodOrConstantRest - : annotationMethodRest - | annotationConstantRest - ; - -annotationMethodRest - : identifier '(' ')' defaultValue? - ; - -annotationConstantRest - : variableDeclarators - ; - -defaultValue - : DEFAULT elementValue - ; - -// MODULES - Java9 - -moduleDeclaration - : OPEN? MODULE qualifiedName moduleBody - ; - -moduleBody - : '{' moduleDirective* '}' - ; - -moduleDirective - : REQUIRES requiresModifier* qualifiedName ';' - | EXPORTS qualifiedName (TO qualifiedName)? ';' - | OPENS qualifiedName (TO qualifiedName)? ';' - | USES qualifiedName ';' - | PROVIDES qualifiedName WITH qualifiedName ';' - ; - -requiresModifier - : TRANSITIVE - | STATIC - ; - -// RECORDS - Java 17 - -recordDeclaration - : RECORD identifier typeParameters? recordHeader (IMPLEMENTS typeList)? recordBody - ; - -recordHeader - : '(' recordComponentList? ')' - ; - -recordComponentList - : recordComponent (',' recordComponent)* - ; - -recordComponent - : typeType identifier - ; - -recordBody - : '{' (classBodyDeclaration | compactConstructorDeclaration)* '}' - ; - -// STATEMENTS / BLOCKS - -block - : '{' blockStatement* '}' - ; - -blockStatement - : localVariableDeclaration ';' - | localTypeDeclaration - | statement - ; - -localVariableDeclaration - : variableModifier* (VAR identifier '=' expression | typeType variableDeclarators) - ; - -identifier - : IDENTIFIER - | MODULE - | OPEN - | REQUIRES - | EXPORTS - | OPENS - | TO - | USES - | PROVIDES - | WITH - | TRANSITIVE - | YIELD - | SEALED - | PERMITS - | RECORD - | VAR - ; - -typeIdentifier // Identifiers that are not restricted for type declarations - : IDENTIFIER - | MODULE - | OPEN - | REQUIRES - | EXPORTS - | OPENS - | TO - | USES - | PROVIDES - | WITH - | TRANSITIVE - | SEALED - | PERMITS - | RECORD - ; - -localTypeDeclaration - : classOrInterfaceModifier* (classDeclaration | interfaceDeclaration | recordDeclaration) - ; - -statement - : blockLabel = block - | ASSERT expression (':' expression)? ';' - | IF parExpression statement (ELSE statement)? - | FOR '(' forControl ')' statement - | WHILE parExpression statement - | DO statement WHILE parExpression ';' - | TRY block (catchClause+ finallyBlock? | finallyBlock) - | TRY resourceSpecification block catchClause* finallyBlock? - | SWITCH parExpression '{' switchBlockStatementGroup* switchLabel* '}' - | SYNCHRONIZED parExpression block - | RETURN expression? ';' - | THROW expression ';' - | BREAK identifier? ';' - | CONTINUE identifier? ';' - | YIELD expression ';' // Java17 - | SEMI - | statementExpression = expression ';' - | switchExpression ';'? // Java17 - | identifierLabel = identifier ':' statement - ; - -catchClause - : CATCH '(' variableModifier* catchType identifier ')' block - ; - -catchType - : qualifiedName ('|' qualifiedName)* - ; - -finallyBlock - : FINALLY block - ; - -resourceSpecification - : '(' resources ';'? ')' - ; - -resources - : resource (';' resource)* - ; - -resource - : variableModifier* (classOrInterfaceType variableDeclaratorId | VAR identifier) '=' expression - | qualifiedName - ; - -/** Matches cases then statements, both of which are mandatory. - * To handle empty cases at the end, we add switchLabel* to statement. - */ -switchBlockStatementGroup - : switchLabel+ blockStatement+ - ; - -switchLabel - : CASE ( - constantExpression = expression - | enumConstantName = IDENTIFIER - | typeType varName = identifier - ) ':' - | DEFAULT ':' - ; - -forControl - : enhancedForControl - | forInit? ';' expression? ';' forUpdate = expressionList? - ; - -forInit - : localVariableDeclaration - | expressionList - ; - -enhancedForControl - : variableModifier* (typeType | VAR) variableDeclaratorId ':' expression - ; - -// EXPRESSIONS - -parExpression - : '(' expression ')' - ; - -expressionList - : expression (',' expression)* - ; - -methodCall - : (identifier | THIS | SUPER) arguments - ; - -expression - // Expression order in accordance with https://introcs.cs.princeton.edu/java/11precedence/ - // Level 16, Primary, array and member access - : primary - | expression '[' expression ']' - | expression bop = '.' ( - identifier - | methodCall - | THIS - | NEW nonWildcardTypeArguments? innerCreator - | SUPER superSuffix - | explicitGenericInvocation - ) - // Method calls and method references are part of primary, and hence level 16 precedence - | methodCall - | expression '::' typeArguments? identifier - | typeType '::' (typeArguments? identifier | NEW) - | classType '::' typeArguments? NEW - | switchExpression // Java17 - - // Level 15 Post-increment/decrement operators - | expression postfix = ('++' | '--') - - // Level 14, Unary operators - | prefix = ('+' | '-' | '++' | '--' | '~' | '!') expression - - // Level 13 Cast and object creation - | '(' annotation* typeType ('&' typeType)* ')' expression - | NEW creator - - // Level 12 to 1, Remaining operators - | expression bop = ('*' | '/' | '%') expression // Level 12, Multiplicative operators - | expression bop = ('+' | '-') expression // Level 11, Additive operators - | expression ('<' '<' | '>' '>' '>' | '>' '>') expression // Level 10, Shift operators - | expression bop = ('<=' | '>=' | '>' | '<') expression // Level 9, Relational operators - | expression bop = INSTANCEOF (typeType | pattern) - | expression bop = ('==' | '!=') expression // Level 8, Equality Operators - | expression bop = '&' expression // Level 7, Bitwise AND - | expression bop = '^' expression // Level 6, Bitwise XOR - | expression bop = '|' expression // Level 5, Bitwise OR - | expression bop = '&&' expression // Level 4, Logic AND - | expression bop = '||' expression // Level 3, Logic OR - | expression bop = '?' expression ':' expression // Level 2, Ternary - // Level 1, Assignment - | expression bop = ( - '=' - | '+=' - | '-=' - | '*=' - | '/=' - | '&=' - | '|=' - | '^=' - | '>>=' - | '>>>=' - | '<<=' - | '%=' - ) expression - - // Level 0, Lambda Expression - | lambdaExpression // Java8 - ; - -// Java17 -pattern - : variableModifier* typeType annotation* identifier - ; - -// Java8 -lambdaExpression - : lambdaParameters '->' lambdaBody - ; - -// Java8 -lambdaParameters - : identifier - | '(' formalParameterList? ')' - | '(' identifier (',' identifier)* ')' - | '(' lambdaLVTIList? ')' - ; - -// Java8 -lambdaBody - : expression - | block - ; - -primary - : '(' expression ')' - | THIS - | SUPER - | literal - | identifier - | typeTypeOrVoid '.' CLASS - | nonWildcardTypeArguments (explicitGenericInvocationSuffix | THIS arguments) - ; - -// Java17 -switchExpression - : SWITCH parExpression '{' switchLabeledRule* '}' - ; - -// Java17 -switchLabeledRule - : CASE (expressionList | NULL_LITERAL | guardedPattern) (ARROW | COLON) switchRuleOutcome - | DEFAULT (ARROW | COLON) switchRuleOutcome - ; - -// Java17 -guardedPattern - : '(' guardedPattern ')' - | variableModifier* typeType annotation* identifier ('&&' expression)* - | guardedPattern '&&' expression - ; - -// Java17 -switchRuleOutcome - : block - | blockStatement* - ; - -classType - : (classOrInterfaceType '.')? annotation* identifier typeArguments? - ; - -creator - : nonWildcardTypeArguments? createdName classCreatorRest - | createdName arrayCreatorRest - ; - -createdName - : identifier typeArgumentsOrDiamond? ('.' identifier typeArgumentsOrDiamond?)* - | primitiveType - ; - -innerCreator - : identifier nonWildcardTypeArgumentsOrDiamond? classCreatorRest - ; - -arrayCreatorRest - : ('[' ']')+ arrayInitializer - | ('[' expression ']')+ ('[' ']')* - ; - -classCreatorRest - : arguments classBody? - ; - -explicitGenericInvocation - : nonWildcardTypeArguments explicitGenericInvocationSuffix - ; - -typeArgumentsOrDiamond - : '<' '>' - | typeArguments - ; - -nonWildcardTypeArgumentsOrDiamond - : '<' '>' - | nonWildcardTypeArguments - ; - -nonWildcardTypeArguments - : '<' typeList '>' - ; - -typeList - : typeType (',' typeType)* - ; - -typeType - : annotation* (classOrInterfaceType | primitiveType) (annotation* '[' ']')* - ; - -primitiveType - : BOOLEAN - | CHAR - | BYTE - | SHORT - | INT - | LONG - | FLOAT - | DOUBLE - ; - -typeArguments - : '<' typeArgument (',' typeArgument)* '>' - ; - -superSuffix - : arguments - | '.' typeArguments? identifier arguments? - ; - -explicitGenericInvocationSuffix - : SUPER superSuffix - | identifier arguments - ; - -arguments - : '(' expressionList? ')' - ; \ No newline at end of file diff --git a/benchmarks/src/main/java/org/ucfs/scanner/java.flex b/benchmarks/src/main/java/org/ucfs/scanner/java.flex deleted file mode 100644 index 4d958c0dc..000000000 --- a/benchmarks/src/main/java/org/ucfs/scanner/java.flex +++ /dev/null @@ -1,281 +0,0 @@ -package org.ucfs; -/* - * Copyright (C) 1998-2018 Gerwin Klein - * SPDX-License-Identifier: GPL-2.0-only - */ - -/* Java 1.2 language lexer specification */ - -/* Use together with unicode.flex for Unicode preprocesssing */ -/* and java12.cup for a Java 1.2 parser */ - -/* Note that this lexer specification is not tuned for speed. - It is in fact quite slow on integer and floating point literals, - because the input is read twice and the methods used to parse - the numbers are not very fast. - For a production quality application (e.g. a Java compiler) - this could be optimized */ - - -%% - -%public -%class Scanner - -%unicode - -%line -%column -%type JavaToken - - -%{ - - /** - * assumes correct representation of a long value for - * specified radix in scanner buffer from start - * to end - */ - -%} - -/* main character classes */ -LineTerminator = \r|\n|\r\n -InputCharacter = [^\r\n] - -WhiteSpace = {LineTerminator} | [ \t\f] - -/* comments */ -Comment = {TraditionalComment} | {EndOfLineComment} | - {DocumentationComment} - -TraditionalComment = "/*" [^*] ~"*/" | "/*" "*"+ "/" -EndOfLineComment = "//" {InputCharacter}* {LineTerminator}? -DocumentationComment = "/*" "*"+ [^/*] ~"*/" - -/* identifiers */ -Identifier = [:jletter:][:jletterdigit:]* - -/* integer literals */ -DecIntegerLiteral = 0 | [1-9][0-9]* -DecLongLiteral = {DecIntegerLiteral} [lL] - -HexIntegerLiteral = 0 [xX] 0* {HexDigit} {1,8} -HexLongLiteral = 0 [xX] 0* {HexDigit} {1,16} [lL] -HexDigit = [0-9a-fA-F] - -OctIntegerLiteral = 0+ [1-3]? {OctDigit} {1,15} -OctLongLiteral = 0+ 1? {OctDigit} {1,21} [lL] -OctDigit = [0-7] - -/* floating point literals */ -FloatLiteral = ({FLit1}|{FLit2}|{FLit3}) {Exponent}? [fF] -DoubleLiteral = ({FLit1}|{FLit2}|{FLit3}) {Exponent}? - -FLit1 = [0-9]+ \. [0-9]* -FLit2 = \. [0-9]+ -FLit3 = [0-9]+ -Exponent = [eE] [+-]? [0-9]+ - -/* string and character literals */ -StringCharacter = [^\r\n\"\\] -SingleCharacter = [^\r\n\'\\] - -%state STRING, CHARLITERAL - -%% - - { - - /* keywords */ - "abstract" { return JavaToken.ABSTRACT; } - "boolean" { return JavaToken.BOOLEAN; } - "break" { return JavaToken.BREAK; } - "byte" { return JavaToken.BYTE; } - "case" { return JavaToken.CASE; } - "catch" { return JavaToken.CATCH; } - "char" { return JavaToken.CHAR; } - "class" { return JavaToken.CLASS; } - "const" { return JavaToken.CONST; } - "continue" { return JavaToken.CONTINUE; } - "do" { return JavaToken.DO; } - "double" { return JavaToken.DOUBLE; } - "else" { return JavaToken.ELSE; } - "extends" { return JavaToken.EXTENDS; } - "final" { return JavaToken.FINAL; } - "finally" { return JavaToken.FINALLY; } - "float" { return JavaToken.FLOAT; } - "for" { return JavaToken.FOR; } - "default" { return JavaToken.DEFAULT; } - "implements" { return JavaToken.IMPLEMENTS; } - "import" { return JavaToken.IMPORT; } - "instanceof" { return JavaToken.INSTANCEOF; } - "int" { return JavaToken.INT; } - "interface" { return JavaToken.INTERFACE; } - "long" { return JavaToken.LONG; } - "native" { return JavaToken.NATIVE; } - "new" { return JavaToken.NEW; } - "goto" { return JavaToken.GOTO; } - "if" { return JavaToken.IF; } - "public" { return JavaToken.PUBLIC; } - "short" { return JavaToken.SHORT; } - "super" { return JavaToken.SUPER; } - "switch" { return JavaToken.SWITCH; } - "synchronized" { return JavaToken.SYNCHRONIZED; } - "package" { return JavaToken.PACKAGE; } - "private" { return JavaToken.PRIVATE; } - "protected" { return JavaToken.PROTECTED; } - "transient" { return JavaToken.TRANSIENT; } - "return" { return JavaToken.RETURN; } - "void" { return JavaToken.VOID; } - "static" { return JavaToken.STATIC; } - "while" { return JavaToken.WHILE; } - "this" { return JavaToken.THIS; } - "throw" { return JavaToken.THROW; } - "throws" { return JavaToken.THROWS; } - "try" { return JavaToken.TRY; } - "volatile" { return JavaToken.VOLATILE; } - "strictfp" { return JavaToken.STRICTFP; } - "enum" { return JavaToken.ENUM; } - "@" { return JavaToken.AT; } - - /* boolean literals */ - "true" { return JavaToken.BOOLEAN_LITERAL; } - "false" { return JavaToken.BOOLEAN_LITERAL; } - - /* null literal */ - "null" { return JavaToken.NULL_LITERAL; } - - "..." { return JavaToken.ELLIPSIS; } - - - /* separators */ - "(" { return JavaToken.LPAREN; } - ")" { return JavaToken.RPAREN; } - "{" { return JavaToken.LBRACE; } - "}" { return JavaToken.RBRACE; } - "[" { return JavaToken.LBRACK; } - "]" { return JavaToken.RBRACK; } - ";" { return JavaToken.SEMICOLON; } - "," { return JavaToken.COMMA; } - "." { return JavaToken.DOT; } - - /* operators */ - "=" { return JavaToken.EQ; } - ">" { return JavaToken.GT; } - "<" { return JavaToken.LT; } - "!" { return JavaToken.NOT; } - "~" { return JavaToken.COMP; } - "?" { return JavaToken.QUESTION; } - "::" { return JavaToken.COLONCOLON; } - ":" { return JavaToken.COLON; } - "==" { return JavaToken.EQEQ; } - "<=" { return JavaToken.LTEQ; } - ">=" { return JavaToken.GTEQ; } - "!=" { return JavaToken.NOTEQ; } - "&&" { return JavaToken.ANDAND; } - "||" { return JavaToken.OROR; } - "++" { return JavaToken.PLUSPLUS; } - "--" { return JavaToken.MINUSMINUS; } - "+" { return JavaToken.PLUS; } - "-" { return JavaToken.MINUS; } - "*" { return JavaToken.MULT; } - "/" { return JavaToken.DIV; } - "&" { return JavaToken.AND; } - "|" { return JavaToken.OR; } - "^" { return JavaToken.XOR; } - "%" { return JavaToken.MOD; } - "+=" { return JavaToken.PLUSEQ; } - "-=" { return JavaToken.MINUSEQ; } - "*=" { return JavaToken.MULTEQ; } - "/=" { return JavaToken.DIVEQ; } - "&=" { return JavaToken.ANDEQ; } - "|=" { return JavaToken.OREQ; } - "^=" { return JavaToken.XOREQ; } - "%=" { return JavaToken.MODEQ; } - "<<=" { return JavaToken.LSHIFTEQ; } - ">>=" { return JavaToken.RSHIFTEQ; } - ">>>=" { return JavaToken.URSHIFTEQ; } - - /* string literal */ - \" { yybegin(STRING); } - - /* character literal */ - \' { yybegin(CHARLITERAL); } - - /* numeric literals */ - - /* This is matched together with the minus, because the number is too big to - be represented by a positive integer. */ - "-2147483648" { return JavaToken.INTEGER_LITERAL; } - - {DecIntegerLiteral} { return JavaToken.INTEGER_LITERAL ; } - {DecLongLiteral} { return JavaToken.INTEGER_LITERAL ; } - - {HexIntegerLiteral} { return JavaToken.INTEGER_LITERAL ; } - {HexLongLiteral} { return JavaToken.INTEGER_LITERAL; } - - {OctIntegerLiteral} { return JavaToken.INTEGER_LITERAL; } - {OctLongLiteral} { return JavaToken.INTEGER_LITERAL; } - - {FloatLiteral} { return JavaToken.FLOATING_POINT_LITERAL; } - {DoubleLiteral} { return JavaToken.FLOATING_POINT_LITERAL; } - {DoubleLiteral}[dD] { return JavaToken.FLOATING_POINT_LITERAL; } - - /* comments */ - {Comment} { /* ignore */ } - - /* whitespace */ - {WhiteSpace} { /* ignore */ } - - /* identifiers */ - {Identifier} { return JavaToken.IDENTIFIER; } -} - - { - \" { yybegin(YYINITIAL); return JavaToken.STRING_LITERAL; } - - {StringCharacter}+ { } - - /* escape sequences */ - "\\b" { } - "\\t" { } - "\\n" { } - "\\f" { } - "\\r" { } - "\\u" { } - "\\u000C" { } - "\\\"" { } - "\\'" { } - "\\\\" { } - \\[0-3]?{OctDigit}?{OctDigit} { } - - /* error cases */ - \\. { throw new RuntimeException("Illegal escape sequence \""+yytext()+"\""); } - {LineTerminator} { throw new RuntimeException("Unterminated string at end of line"); } -} - - { - {SingleCharacter}\' { yybegin(YYINITIAL); return JavaToken.CHARACTER_LITERAL; } - - /* escape sequences */ - "\\b"\' { yybegin(YYINITIAL); return JavaToken.CHARACTER_LITERAL;} - "\\t"\' { yybegin(YYINITIAL); return JavaToken.CHARACTER_LITERAL;} - "\\n"\' { yybegin(YYINITIAL); return JavaToken.CHARACTER_LITERAL;} - "\\f"\' { yybegin(YYINITIAL); return JavaToken.CHARACTER_LITERAL;} - "\\r"\' { yybegin(YYINITIAL); return JavaToken.CHARACTER_LITERAL;} - "\\\""\' { yybegin(YYINITIAL); return JavaToken.CHARACTER_LITERAL;} - "\\'"\' { yybegin(YYINITIAL); return JavaToken.CHARACTER_LITERAL;} - "\\\\"\' { yybegin(YYINITIAL); return JavaToken.CHARACTER_LITERAL; } - \\[0-3]?{OctDigit}?{OctDigit}\' { yybegin(YYINITIAL); - return JavaToken.CHARACTER_LITERAL; } - - /* error cases */ - \\. { throw new RuntimeException("Illegal escape sequence \""+yytext()+"\""); } - {LineTerminator} { throw new RuntimeException("Unterminated character literal at end of line"); } -} - -/* error fallback */ -[^] { throw new RuntimeException("Illegal character \""+yytext()+ - "\" at line "+yyline+", column "+yycolumn); } -<> { return JavaToken.EOF; } \ No newline at end of file diff --git a/benchmarks/src/main/kotlin/Benchmarks.kt b/benchmarks/src/main/kotlin/Benchmarks.kt deleted file mode 100644 index bf567873d..000000000 --- a/benchmarks/src/main/kotlin/Benchmarks.kt +++ /dev/null @@ -1,56 +0,0 @@ -import org.ucfs.JavaToken -import org.ucfs.Scanner -import org.ucfs.input.* -import org.ucfs.rsm.symbol.Term -import java.io.StringReader - -fun getResultPath( - pathToOutput: String, - inputName: String, - grammarMode: String, - grammarName: String, - sppfMode: String, -): String { - return pathToOutput + (if (pathToOutput.endsWith("/")) "" else "/") + "${inputName}_${grammarMode}_${grammarName}_${sppfMode}.csv" -} - - -fun getTokenStream(input: String): LinearInput { - val graph = LinearInput() - getTokenStream(input, graph) - return graph -} - - - -fun > getTokenStream(input: String, inputGraph: G): G { - val lexer = Scanner(StringReader(input)) - var token: JavaToken - var vertexId = 1 - - inputGraph.addVertex(vertexId) - inputGraph.addStartVertex(vertexId) - - while (true) { - token = lexer.yylex() as JavaToken - if (token == JavaToken.EOF) break - inputGraph.addEdge(vertexId, TerminalInputLabel(token), ++vertexId) - } - - return inputGraph -} - -fun getCharStream(input: String): LinearInput { - val inputGraph = LinearInput() - var vertexId = 1 - - inputGraph.addVertex(vertexId) - inputGraph.addStartVertex(vertexId) - - for (ch in input) { - inputGraph.addEdge(vertexId, TerminalInputLabel(Term(ch.toString())), ++vertexId) - inputGraph.addVertex(vertexId) - } - - return inputGraph -} diff --git a/benchmarks/src/main/kotlin/UcfsRunExample.kt b/benchmarks/src/main/kotlin/UcfsRunExample.kt deleted file mode 100644 index a9f17c943..000000000 --- a/benchmarks/src/main/kotlin/UcfsRunExample.kt +++ /dev/null @@ -1,14 +0,0 @@ -import org.ucfs.Java8 -import org.ucfs.parser.Gll - -fun main(){ - // get RSM start state - val startState = Java8().rsm - // get linear graph from source code - val text = "package a; class X {}" - val tokens = getTokenStream(text) - // parse (intersect graph and rsm) - val gll = Gll.gll(startState, tokens) - // make sure that sppf isn't empty - assert(gll.parse().first != null) { "can't build sppf" } -} \ No newline at end of file diff --git a/benchmarks/src/main/kotlin/org/ucfs/Generator.kt b/benchmarks/src/main/kotlin/org/ucfs/Generator.kt deleted file mode 100644 index 01dce4c42..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/Generator.kt +++ /dev/null @@ -1,35 +0,0 @@ -package org.ucfs -import org.ucfs.ast.NodeClassesGenerator -import org.ucfs.parser.ParserGenerator -import org.ucfs.parser.RecoveryParserGenerator -import java.nio.file.Path - -val grammarClass = Java8::class.java -val tokenClass = JavaToken::class.java -val pkg = "org.ucfs" - -fun main(args: Array){ - val path: Path = if(args.isEmpty()){ - Path.of("benchmarks/src/main/kotlin") - } - else{ - Path.of(args[0]) - } - println("Generate ${Java8::class} UCFS parsers at ${path.toAbsolutePath()}") - generateJavaParser(path) - generateJavaRecoveryParser(path) - generateNodes(path) -} - -fun generateJavaParser(path: Path) { - ParserGenerator(grammarClass, tokenClass).generate(path, pkg) -} -fun generateJavaRecoveryParser(path: Path) { - RecoveryParserGenerator(grammarClass, tokenClass).generate(path, pkg) -} - -fun generateNodes(path: Path){ - var nodeGenerator = NodeClassesGenerator(grammarClass) - nodeGenerator.generate(path, "$pkg.nodes") -} - diff --git a/benchmarks/src/main/kotlin/org/ucfs/Java8.kt b/benchmarks/src/main/kotlin/org/ucfs/Java8.kt deleted file mode 100644 index 8068df8e5..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/Java8.kt +++ /dev/null @@ -1,933 +0,0 @@ -package org.ucfs -import org.ucfs.JavaToken.* -import org.ucfs.grammar.combinator.Grammar -import org.ucfs.grammar.combinator.regexp.* - -class Java8 : Grammar() { - val compilationUnit by Nt().asStart() - val identifier by Nt() - val literal by Nt() - val type by Nt() - val primitiveType by Nt() - val referenceType by Nt() - val annotation by Nt() - val numericType by Nt() - val integralType by Nt() - val floatingPointType by Nt() - val classOrInterfaceType by Nt() - val typeVariable by Nt() - val arrayType by Nt() - val classType by Nt() - val interfaceType by Nt() - val typeArguments by Nt() - val dims by Nt() - val typeParameter by Nt() - val typeParameterModifier by Nt() - val typeBound by Nt() - val additionalBound by Nt() - val typeArgumentList by Nt() - val typeArgument by Nt() - val wildcard by Nt() - val wildcardBounds by Nt() - val typeName by Nt() - val packageOrTypeName by Nt() - val expressionName by Nt() - val ambiguousName by Nt() - val methodName by Nt() - val packageName by Nt() - val result by Nt() - val packageDeclaration by Nt() - val importDeclaration by Nt() - val typeDeclaration by Nt() - val packageModifier by Nt() - val singleTypeImportDeclaration by Nt() - val typeImportOnDemandDeclaration by Nt() - val singleStaticImportDeclaration by Nt() - val staticImportOnDemandDeclaration by Nt() - val classDeclaration by Nt() - val interfaceDeclaration by Nt() - val throws by Nt() - val normalClassDeclaration by Nt() - val enumDeclaration by Nt() - val classModifier by Nt() - val typeParameters by Nt() - val superclass by Nt() - val superinterfaces by Nt() - val classBody by Nt() - val typeParameterList by Nt() - val interfaceTypeList by Nt() - val classBodyDeclaration by Nt() - val classMemberDeclaration by Nt() - val instanceInitializer by Nt() - val staticInitializer by Nt() - val constructorDeclaration by Nt() - val fieldDeclaration by Nt() - val methodDeclaration by Nt() - val fieldModifier by Nt() - val unannType by Nt() - val variableDeclaratorList by Nt() - val variableDeclarator - by Nt() - val variableDeclaratorId by Nt() - val variableInitializer by Nt() - val expression by Nt() - val arrayInitializer by Nt() - val unannPrimitiveType by Nt() - val unannReferenceType by Nt() - val unannClassOrInterfaceType by Nt() - val unannTypeVariable by Nt() - val unannArrayType by Nt() - val unannClassType by Nt() - val unannInterfaceType by Nt() - val methodModifier by Nt() - val methodHeader by Nt() - val methodBody by Nt() - val methodDeclarator - by Nt() - val formalParameterList by Nt() - val receiverParameter by Nt() - val formalParameters by Nt() - val lastFormalParameter by Nt() - val formalParameter by Nt() - val variableModifier by Nt() - val exceptionTypeList by Nt() - val exceptionType by Nt() - val block by Nt() - val constructorModifier by Nt() - val constructorDeclarator - by Nt() - val constructorBody by Nt() - val simpleTypeName by Nt() - val explicitConstructorInvocation by Nt() - val enumBody by Nt() - val enumConstantList by Nt() - val enumConstant by Nt() - val enumConstantModifier by Nt() - val enumBodyDeclarations by Nt() - val blockStatements by Nt() - val argumentList by Nt() - val primary by Nt() - val normalInterfaceDeclaration by Nt() - val interfaceModifier by Nt() - val extendsInterfaces by Nt() - val interfaceBody by Nt() - val interfaceMemberDeclaration by Nt() - val constantDeclaration by Nt() - val constantModifier by Nt() - val annotationTypeDeclaration by Nt() - val annotationTypeBody by Nt() - val annotationTypeMemberDeclaration by Nt() - val annotationTypeElementDeclaration by Nt() - val defaultValue by Nt() - val normalAnnotation by Nt() - val elementValuePairList by Nt() - val elementValuePair by Nt() - val elementValue by Nt() - val elementValueArrayInitializer by Nt() - val elementValueList by Nt() - val markerAnnotation by Nt() - val singleElementAnnotation by Nt() - val interfaceMethodDeclaration by Nt() - val annotationTypeElementModifier by Nt() - val conditionalExpression by Nt() - val variableInitializerList by Nt() - val blockStatement by Nt() - val localVariableDeclarationStatement by Nt() - val localVariableDeclaration by Nt() - val statement by Nt() - val statementNoShortIf by Nt() - val statementWithoutTrailingSubstatement by Nt() - val emptyStatement by Nt() - val labeledStatement by Nt() - val labeledStatementNoShortIf by Nt() - val expressionStatement by Nt() - val statementExpression by Nt() - val ifThenStatement by Nt() - val ifThenElseStatement by Nt() - val ifThenElseStatementNoShortIf by Nt() - val assertStatement by Nt() - val switchStatement by Nt() - val switchBlock by Nt() - val switchBlockStatementGroup by Nt() - val switchLabels by Nt() - val switchLabel by Nt() - val enumConstantName by Nt() - val whileStatement by Nt() - val whileStatementNoShortIf by Nt() - val doStatement by Nt() - val interfaceMethodModifier by Nt() - val forStatement by Nt() - val forStatementNoShortIf by Nt() - val basicForStatement by Nt() - val basicForStatementNoShortIf by Nt() - val forInit by Nt() - val forUpdate by Nt() - val statementExpressionList by Nt() - val enhancedForStatement by Nt() - val enhancedForStatementNoShortIf by Nt() - val breakStatement by Nt() - val continueStatement by Nt() - val returnStatement by Nt() - val throwStatement by Nt() - val synchronizedStatement by Nt() - val tryStatement by Nt() - val catches by Nt() - val catchClause by Nt() - val catchFormalParameter by Nt() - val catchType by Nt() - val finally by Nt() - val tryWithResourcesStatement by Nt() - val resourceSpecification by Nt() - val resourceList by Nt() - val resource by Nt() - val primaryNoNewArray by Nt() - val classLiteral by Nt() - val classOrInterfaceTypeToInstantiate by Nt() - val unqualifiedClassInstanceCreationExpression by Nt() - val classInstanceCreationExpression by Nt() - val fieldAccess by Nt() - val typeArgumentsOrDiamond by Nt() - val arrayAccess by Nt() - val methodInvocation by Nt() - val methodReference by Nt() - val arrayCreationExpression by Nt() - val dimExprs by Nt() - val dimExpr by Nt() - val lambdaExpression by Nt() - val lambdaParameters by Nt() - val inferredFormalParameterList by Nt() - val lambdaBody by Nt() - val assignmentExpression by Nt() - val assignment by Nt() - val leftHandSide by Nt() - val assignmentOperator - by Nt() - val conditionalOrExpression by Nt() - val conditionalAndExpression by Nt() - val inclusiveOrExpression by Nt() - val exclusiveOrExpression by Nt() - val andExpression by Nt() - val equalityExpression by Nt() - val relationalExpression by Nt() - val shiftExpression by Nt() - val additiveExpression by Nt() - val multiplicativeExpression by Nt() - val preIncrementExpression by Nt() - val preDecrementExpression by Nt() - val unaryExpressionNotPlusMinus by Nt() - val unaryExpression by Nt() - val postfixExpression by Nt() - val postIncrementExpression by Nt() - val postDecrementExpression by Nt() - val castExpression by Nt() - val constantExpression by Nt() - - init { - identifier /= IDENTIFIER - - /** - * productions from §4 (Lexical structure) - */ - literal /= INTEGER_LITERAL or - FLOATING_POINT_LITERAL or - BOOLEAN_LITERAL or - CHARACTER_LITERAL or - STRING_LITERAL or - NULL_LITERAL - - /** - * productions from §4 (types, values, and variables) - */ - type /= primitiveType or - referenceType - - primitiveType /= Many(annotation) * numericType or - Many(annotation) * BOOLEAN - - numericType /= integralType or - floatingPointType - - integralType /= BYTE or - SHORT or - INT or - LONG or - CHAR - - floatingPointType /= FLOAT or - DOUBLE - - referenceType /= classOrInterfaceType or - typeVariable or - arrayType - - classOrInterfaceType /= classType or - interfaceType - - classType /= Many(annotation) * identifier * Option(typeArguments) or - classOrInterfaceType * DOT * Many(annotation) * identifier * Option(typeArguments) - - interfaceType /= classType - - typeVariable /= Many(annotation) * identifier - - arrayType /= primitiveType * dims or - classOrInterfaceType * dims or - typeVariable * dims - - dims /= some(Many(annotation) * LBRACK * RBRACK) - - typeParameter /= Many(typeParameterModifier) * identifier * Option(typeBound) - - typeParameterModifier /= annotation - - typeBound /= EXTENDS * typeVariable or - EXTENDS * classOrInterfaceType * Many(additionalBound) - - additionalBound /= AND * interfaceType - - typeArguments /= LT * typeArgumentList * GT - - typeArgumentList /= typeArgument * Many(COMMA * typeArgument) - - typeArgument /= referenceType or - wildcard - - wildcard /= Many(annotation) * QUESTION * Option(wildcardBounds) - - wildcardBounds /= EXTENDS * referenceType or - SUPER * referenceType - - /** - * productions from §6 (Names) - */ - packageName /= identifier or - packageName * DOT * identifier - - typeName /= identifier or - packageOrTypeName * DOT * identifier - - packageOrTypeName /= identifier or - packageOrTypeName * DOT * identifier - - expressionName /= identifier or - ambiguousName * DOT * identifier - - methodName /= identifier - - ambiguousName /= identifier or - ambiguousName * DOT * identifier - - /** - * productions from §7 (packages) - */ - - compilationUnit /= Option(packageDeclaration) * Many(importDeclaration) * Many(typeDeclaration) - - packageDeclaration /= Many(packageModifier) * PACKAGE * identifier * Many(DOT * identifier ) * SEMICOLON - - packageModifier /= annotation - - importDeclaration /= singleTypeImportDeclaration or - typeImportOnDemandDeclaration or - singleStaticImportDeclaration or - staticImportOnDemandDeclaration - - singleTypeImportDeclaration /= IMPORT * typeName * SEMICOLON - - typeImportOnDemandDeclaration /= IMPORT * packageOrTypeName * DOT * MULT * SEMICOLON - - singleStaticImportDeclaration /= IMPORT * STATIC * typeName * DOT * identifier * SEMICOLON - - staticImportOnDemandDeclaration /= IMPORT * STATIC * typeName * DOT * MULT * SEMICOLON - - typeDeclaration /= classDeclaration or - interfaceDeclaration or - SEMICOLON - - /** - * productions from §8 (classes) - */ - - classDeclaration /= normalClassDeclaration or - enumDeclaration - - normalClassDeclaration /= Many(classModifier) * CLASS * identifier * - Option(typeParameters) * Option(superclass) * Option(superinterfaces) * classBody - - classModifier /= annotation or - PUBLIC or - PROTECTED or - PRIVATE or - ABSTRACT or - STATIC or - FINAL or - STRICTFP - - typeParameters /= LT * typeParameterList * GT - - typeParameterList /= typeParameter * Many(COMMA * typeParameter) - - superclass /= EXTENDS * classType - - superinterfaces /= IMPLEMENTS * interfaceTypeList - - interfaceTypeList /= interfaceType * Many(COMMA * interfaceType) - - classBody /= LBRACE * Many(classBodyDeclaration) * RBRACE - - classBodyDeclaration /= classMemberDeclaration or - instanceInitializer or - staticInitializer or - constructorDeclaration - - classMemberDeclaration /= fieldDeclaration or - methodDeclaration or - classDeclaration or - interfaceDeclaration or - SEMICOLON - - fieldDeclaration /= Many(fieldModifier) * unannType * variableDeclaratorList * SEMICOLON - - fieldModifier /= annotation or - PUBLIC or - PROTECTED or - PRIVATE or - STATIC or - FINAL or - TRANSIENT or - VOLATILE - - variableDeclaratorList /= variableDeclarator * Many(COMMA * variableDeclarator) - - variableDeclarator /= variableDeclaratorId * Option(EQ * variableInitializer) - - variableDeclaratorId /= identifier * Option(dims) - - variableInitializer /= expression or - arrayInitializer - - unannType /= unannPrimitiveType or - unannReferenceType - - unannPrimitiveType /= numericType or - BOOLEAN - - unannReferenceType /= unannClassOrInterfaceType or - unannTypeVariable or - unannArrayType - - unannClassOrInterfaceType /= unannClassType or - unannInterfaceType - - unannClassType /= identifier * Option(typeArguments) or - unannClassOrInterfaceType * DOT * Many(annotation) * identifier * Option(typeArguments) - - unannInterfaceType /= unannClassType - - unannTypeVariable /= identifier - - unannArrayType /= unannPrimitiveType * dims or - unannClassOrInterfaceType * dims or - unannTypeVariable * dims - - methodDeclaration /= Many(methodModifier) * methodHeader * methodBody - - methodModifier /= annotation or - PUBLIC or - PROTECTED or - PRIVATE or - ABSTRACT or - STATIC or - FINAL or - SYNCHRONIZED or - NATIVE or - STRICTFP - - methodHeader /= result * methodDeclarator * Option(throws) or - typeParameters * Many(annotation) * result * methodDeclarator * Option(throws) - - result /= unannType or - VOID - - methodDeclarator /= identifier * LPAREN * Option(formalParameterList) * RPAREN * Option(dims) - - formalParameterList /= receiverParameter or - formalParameters * COMMA * lastFormalParameter or - lastFormalParameter - - formalParameters /= formalParameter * Many(COMMA * formalParameter) or - receiverParameter * Many(COMMA * formalParameter) - - formalParameter /= Many(variableModifier) * unannType * variableDeclaratorId - - variableModifier /= annotation or - FINAL - - lastFormalParameter /= Many(variableModifier) * unannType * Many(annotation) * ELLIPSIS * variableDeclaratorId or - formalParameter - - receiverParameter /= Many(annotation) * unannType * Option(identifier * DOT) * THIS - - throws /= THROWS * exceptionTypeList - - exceptionTypeList /= exceptionType * Many(COMMA * exceptionType) - - exceptionType /= classType or - typeVariable - - methodBody /= block or - SEMICOLON - - instanceInitializer /= block - - staticInitializer /= STATIC * block - - constructorDeclaration /= Many(constructorModifier) * constructorDeclarator * Option(throws) * constructorBody - - constructorModifier /= annotation or - PUBLIC or - PROTECTED or - PRIVATE - - constructorDeclarator /= Option(typeParameters) * simpleTypeName * LPAREN * Option(formalParameterList) * RPAREN - - simpleTypeName /= identifier - - constructorBody /= LBRACE * Option(explicitConstructorInvocation) * Option(blockStatements) * RBRACE - - explicitConstructorInvocation /= Option(typeArguments) * THIS * LPAREN * Option(argumentList) * RPAREN * SEMICOLON or - Option(typeArguments) * SUPER * LPAREN * Option(argumentList) * RPAREN * SEMICOLON or - expressionName * DOT * Option(typeArguments) * SUPER * LPAREN * Option(argumentList) * RPAREN * SEMICOLON or - primary * DOT * Option(typeArguments) * SUPER * LPAREN * Option(argumentList) * RPAREN * SEMICOLON - - enumDeclaration /= Many(classModifier) * ENUM * identifier * Option(superinterfaces) * enumBody - - enumBody /= LBRACE * Option(enumConstantList) * Option(COMMA) * Option(enumBodyDeclarations) * RBRACE - - enumConstantList /= enumConstant * Many(COMMA * enumConstant) - - enumConstant /= Many(enumConstantModifier) * identifier * Option(LPAREN * Option(argumentList) * RPAREN * Option(classBody)) - - enumConstantModifier /= annotation - - enumBodyDeclarations /= SEMICOLON * Many(classBodyDeclaration) - - /** - * productions from §9 (interfaces) - */ - - interfaceDeclaration /= normalInterfaceDeclaration or - annotationTypeDeclaration - - normalInterfaceDeclaration /= - Many(interfaceModifier) * INTERFACE * identifier * Option(typeParameters) * - Option(extendsInterfaces) * interfaceBody - - interfaceModifier /= annotation or - PUBLIC or - PROTECTED or - PRIVATE or - ABSTRACT or - STATIC or - STRICTFP - - extendsInterfaces /= EXTENDS * interfaceTypeList - - interfaceBody /= LBRACE * Many(interfaceMemberDeclaration) * RBRACE - - interfaceMemberDeclaration /= constantDeclaration or - interfaceMethodDeclaration or - classDeclaration or - interfaceDeclaration or - SEMICOLON - - constantDeclaration /= Many(constantModifier) * unannType * variableDeclaratorList * SEMICOLON - - constantModifier /= annotation or - PUBLIC or - STATIC or - FINAL - - interfaceMethodDeclaration /= Many(interfaceMethodModifier) * methodHeader * methodBody - - interfaceMethodModifier /= annotation or - PUBLIC or - ABSTRACT or - DEFAULT or - STATIC or - STRICTFP - - annotationTypeDeclaration /= Many(interfaceModifier) * AT * INTERFACE * identifier * annotationTypeBody - - annotationTypeBody /= LBRACE * Many(annotationTypeMemberDeclaration) * RBRACE - - annotationTypeMemberDeclaration /= annotationTypeElementDeclaration or - constantDeclaration or - classDeclaration or - interfaceDeclaration or - SEMICOLON - - annotationTypeElementDeclaration /= - Many(annotationTypeElementModifier) * unannType * identifier * LPAREN * RPAREN * - Option(dims) * Option(defaultValue) * SEMICOLON - - annotationTypeElementModifier /= annotation or - PUBLIC or - ABSTRACT - - defaultValue /= DEFAULT * elementValue - - annotation /= normalAnnotation or - markerAnnotation or - singleElementAnnotation - - normalAnnotation /= AT * typeName * LPAREN * Option(elementValuePairList) * RPAREN - - elementValuePairList /= elementValuePair * Many(COMMA * elementValuePair) - - elementValuePair /= identifier * EQ * elementValue - - elementValue /= conditionalExpression or - elementValueArrayInitializer or - annotation - - elementValueArrayInitializer /= LBRACE * Option(elementValueList) * Option(COMMA) * RBRACE - - elementValueList /= elementValue * Many(COMMA * elementValue) - - markerAnnotation /= AT * typeName - - singleElementAnnotation /= AT * typeName * LPAREN * elementValue * RPAREN - - /** - * productions from §10 (arrays) - */ - - arrayInitializer /= LBRACE * Option(variableInitializerList) * Option(COMMA) * RBRACE - - variableInitializerList /= variableInitializer * Many(COMMA * variableInitializer) - - /** - * productions from §14 (Blocks and statements) - */ - - block /= LBRACE * Option(blockStatements) * RBRACE - - blockStatements /= blockStatement * Many(blockStatement) - - blockStatement /= localVariableDeclarationStatement or - classDeclaration or - statement - - localVariableDeclarationStatement /= localVariableDeclaration * SEMICOLON - - localVariableDeclaration /= Many(variableModifier) * unannType * variableDeclaratorList - - statement /= statementWithoutTrailingSubstatement or - labeledStatement or - ifThenStatement or - ifThenElseStatement or - whileStatement or - forStatement - - statementNoShortIf /= statementWithoutTrailingSubstatement or - labeledStatementNoShortIf or - ifThenElseStatementNoShortIf or - whileStatementNoShortIf or - forStatementNoShortIf - - statementWithoutTrailingSubstatement /= block or - emptyStatement or - expressionStatement or - assertStatement or - switchStatement or - doStatement or - breakStatement or - continueStatement or - returnStatement or - synchronizedStatement or - throwStatement or - tryStatement - - emptyStatement /= SEMICOLON - - labeledStatement /= identifier * COLON * statement - - labeledStatementNoShortIf /= identifier * COLON * statementNoShortIf - - expressionStatement /= statementExpression * SEMICOLON - - statementExpression /= assignment or - preIncrementExpression or - preDecrementExpression or - postIncrementExpression or - postDecrementExpression or - methodInvocation or - classInstanceCreationExpression - - ifThenStatement /= IF * LPAREN * expression * RPAREN * statement - - ifThenElseStatement /= IF * LPAREN * expression * RPAREN * statementNoShortIf * ELSE * statement - - ifThenElseStatementNoShortIf /= - IF * LPAREN * expression * RPAREN * statementNoShortIf * ELSE * statementNoShortIf - - assertStatement /= ASSERT * expression * SEMICOLON or - ASSERT * expression * COLON * expression * SEMICOLON - - switchStatement /= SWITCH * LPAREN * expression * RPAREN * switchBlock - - switchBlock /= LBRACE * Many(switchBlockStatementGroup) * Many(switchLabel) * RBRACE - - switchBlockStatementGroup /= switchLabels * blockStatements - - switchLabels /= some(switchLabel) - - switchLabel /= CASE * constantExpression * COLON or - CASE * enumConstantName * COLON or - DEFAULT * COLON - - enumConstantName /= identifier - - whileStatement /= WHILE * LPAREN * expression * RPAREN * statement - - whileStatementNoShortIf /= WHILE * LPAREN * expression * RPAREN * statementNoShortIf - - doStatement /= DO * statement * WHILE * LPAREN * expression * RPAREN * SEMICOLON - - forStatement /= basicForStatement or - enhancedForStatement - - forStatementNoShortIf /= basicForStatementNoShortIf or - enhancedForStatementNoShortIf - - basicForStatement /= FOR * LPAREN * Option(forInit) * SEMICOLON * Option(expression) * SEMICOLON * - Option(forUpdate) * RPAREN * statement - - basicForStatementNoShortIf /= FOR * LPAREN * Option(forInit) * SEMICOLON * Option(expression) * SEMICOLON * - Option(forUpdate) * RPAREN * statementNoShortIf - - forInit /= statementExpressionList or - localVariableDeclaration - - forUpdate /= statementExpressionList - - statementExpressionList /= statementExpression * Many(COMMA * statementExpression) - - enhancedForStatement /= FOR * LPAREN * Many(variableModifier) * unannType * variableDeclaratorId * COLON * - expression * RPAREN * statement - enhancedForStatementNoShortIf /= FOR * LPAREN * Many(variableModifier) * unannType * variableDeclaratorId * - COLON * expression * RPAREN * statementNoShortIf - - breakStatement /= BREAK * Option(identifier) * SEMICOLON - - continueStatement /= CONTINUE * Option(identifier) * SEMICOLON - - returnStatement /= RETURN * Option(expression) * SEMICOLON - - throwStatement /= THROW * expression * SEMICOLON - - synchronizedStatement /= SYNCHRONIZED * LPAREN * expression * RPAREN * block - - tryStatement /= TRY * block * catches or - TRY * block * Option(catches) * finally or - tryWithResourcesStatement - - catches /= some(catchClause) - - catchClause /= CATCH * LPAREN * catchFormalParameter * RPAREN * block - - catchFormalParameter /= Many(variableModifier) * catchType * variableDeclaratorId - - catchType /= unannClassType * Many(OR * classType) - - finally /= FINALLY * block - - tryWithResourcesStatement /= TRY * resourceSpecification * block * Option(catches) * Option(finally) - - resourceSpecification /= LPAREN * resourceList * Option(SEMICOLON) * RPAREN - - resourceList /= resource * Many(COMMA * resource) - - resource /= Many(variableModifier) * unannType * variableDeclaratorId * EQ * expression - - /** - * productions from §15 (expressions) - */ - - primary /= primaryNoNewArray or - arrayCreationExpression - - primaryNoNewArray /= literal or - classLiteral or - THIS or - typeName * DOT * THIS or - LPAREN * expression * RPAREN or - classInstanceCreationExpression or - fieldAccess or - arrayAccess or - methodInvocation or - methodReference - - classLiteral /= typeName * Many(LBRACK * RBRACK) * DOT * CLASS or - numericType * Many(LBRACK * RBRACK) * DOT * CLASS or - BOOLEAN * Many(LBRACK * RBRACK) * DOT * CLASS or - VOID * DOT * CLASS - - classInstanceCreationExpression /= unqualifiedClassInstanceCreationExpression or - expressionName * DOT * unqualifiedClassInstanceCreationExpression or - primary * DOT * unqualifiedClassInstanceCreationExpression - - unqualifiedClassInstanceCreationExpression /= NEW * Option(typeArguments) * classOrInterfaceTypeToInstantiate * - LPAREN * Option(argumentList) * RPAREN * Option(classBody) - - classOrInterfaceTypeToInstantiate /= Many(annotation) * - identifier * Many(DOT * Many(annotation) * identifier ) * Option(typeArgumentsOrDiamond) - - typeArgumentsOrDiamond /= typeArguments or - LT * GT - - fieldAccess /= primary * DOT * identifier or - SUPER * DOT * identifier or - typeName * DOT * SUPER * DOT * identifier - - arrayAccess /= expressionName * LBRACK * expression * RBRACK or - primaryNoNewArray * LBRACK * expression * RBRACK - - methodInvocation /= methodName * LPAREN * Option(argumentList) * RPAREN or - typeName * DOT * Option(typeArguments) * identifier * LPAREN * Option(argumentList) * RPAREN or - expressionName * DOT * Option(typeArguments) * identifier * LPAREN * Option(argumentList) * RPAREN or - primary * DOT * Option(typeArguments) * identifier * LPAREN * Option(argumentList) * RPAREN or - SUPER * DOT * Option(typeArguments) * identifier * LPAREN * Option(argumentList) * RPAREN or - typeName * DOT * SUPER * DOT * Option(typeArguments) * identifier * LPAREN * Option(argumentList) * RPAREN - - argumentList /= expression * Many(COMMA * expression) - - methodReference /= expressionName * COLONCOLON * Option(typeArguments) * identifier or - referenceType * COLONCOLON * Option(typeArguments) * identifier or - primary * COLONCOLON * Option(typeArguments) * identifier or - SUPER * COLONCOLON * Option(typeArguments) * identifier or - typeName * DOT * SUPER * COLONCOLON * Option(typeArguments) * identifier or - classType * COLONCOLON * Option(typeArguments) * NEW or - arrayType * COLONCOLON * NEW - - arrayCreationExpression /= NEW * primitiveType * dimExprs * Option(dims) or - NEW * classOrInterfaceType * dimExprs * Option(dims) or - NEW * primitiveType * dims * arrayInitializer or - NEW * classOrInterfaceType * dims * arrayInitializer - - dimExprs /= some(dimExpr) - - dimExpr /= Many(annotation) * LBRACK * expression * RBRACK - - expression /= lambdaExpression or - assignmentExpression - - lambdaExpression /= lambdaParameters * ARROW * lambdaBody - - lambdaParameters /= identifier or - LPAREN * Option(formalParameterList) * RPAREN or - LPAREN * inferredFormalParameterList * RPAREN - - inferredFormalParameterList /= identifier * Many(COMMA * identifier ) - - lambdaBody /= expression or - block - - assignmentExpression /= conditionalExpression or - assignment - - assignment /= leftHandSide * assignmentOperator * expression - - leftHandSide /= expressionName or - fieldAccess or - arrayAccess - - assignmentOperator /= EQ or - MULTEQ or - DIVEQ or - MODEQ or - PLUSEQ or - MINUSEQ or - LSHIFTEQ or - RSHIFTEQ or - URSHIFTEQ or - ANDEQ or - XOREQ or - OREQ - - conditionalExpression /= conditionalOrExpression or - conditionalOrExpression * QUESTION * expression * COLON * conditionalExpression or - conditionalOrExpression * QUESTION * expression * COLON * lambdaExpression - - conditionalOrExpression /= conditionalAndExpression or - conditionalOrExpression * OROR * conditionalAndExpression - - conditionalAndExpression /= inclusiveOrExpression or - conditionalAndExpression * ANDAND * inclusiveOrExpression - - inclusiveOrExpression /= exclusiveOrExpression or - inclusiveOrExpression * OR * exclusiveOrExpression - - exclusiveOrExpression /= andExpression or - exclusiveOrExpression * XOR * andExpression - - andExpression /= equalityExpression or - andExpression * AND * equalityExpression - - equalityExpression /= relationalExpression or - equalityExpression * EQEQ * relationalExpression or - equalityExpression * NOTEQ * relationalExpression - - relationalExpression /= shiftExpression or - relationalExpression * LT * shiftExpression or - relationalExpression * GT * shiftExpression or - relationalExpression * LTEQ * shiftExpression or - relationalExpression * GTEQ * shiftExpression or - relationalExpression * INSTANCEOF * referenceType - - shiftExpression /= additiveExpression or - shiftExpression * LT * LT * additiveExpression or - shiftExpression * GT * GT * additiveExpression or - shiftExpression * GT * GT * GT * additiveExpression - - additiveExpression /= multiplicativeExpression or - additiveExpression * PLUS * multiplicativeExpression or - additiveExpression * MINUS * multiplicativeExpression - - multiplicativeExpression /= unaryExpression or - multiplicativeExpression * MULT * unaryExpression or - multiplicativeExpression * DIV * unaryExpression or - multiplicativeExpression * MOD * unaryExpression - - unaryExpression /= preIncrementExpression or - preDecrementExpression or - PLUS * unaryExpression or - MINUS * unaryExpression or - unaryExpressionNotPlusMinus - - preIncrementExpression /= PLUSPLUS * unaryExpression - - preDecrementExpression /= MINUSMINUS * unaryExpression - - unaryExpressionNotPlusMinus /= postfixExpression or - COMP * unaryExpression or - NOT * unaryExpression or - castExpression - - postfixExpression /= primary or - expressionName or - postIncrementExpression or - postDecrementExpression - - postIncrementExpression /= postfixExpression * PLUSPLUS - - postDecrementExpression /= postfixExpression * MINUSMINUS - - castExpression /= LPAREN * primitiveType * RPAREN * unaryExpression or - LPAREN * referenceType * Many(additionalBound) * RPAREN * unaryExpressionNotPlusMinus or - LPAREN * referenceType * Many(additionalBound) * RPAREN * lambdaExpression - - constantExpression /= expression - } -} \ No newline at end of file diff --git a/benchmarks/src/main/kotlin/org/ucfs/Java8Parser.kt b/benchmarks/src/main/kotlin/org/ucfs/Java8Parser.kt deleted file mode 100644 index adef2a51d..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/Java8Parser.kt +++ /dev/null @@ -1,8655 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs - -import org.ucfs.JavaToken -import org.ucfs.descriptors.Descriptor -import org.ucfs.input.IInputGraph -import org.ucfs.input.ILabel -import org.ucfs.parser.GeneratedParser -import org.ucfs.rsm.symbol.Nonterminal -import org.ucfs.sppf.node.SppfNode - -public class Java8Parser : GeneratedParser() - { - public val grammar: Java8 = Java8() - - private val compilationUnit: Nonterminal = grammar.compilationUnit.nonterm - - private val identifier: Nonterminal = grammar.identifier.nonterm - - private val literal: Nonterminal = grammar.literal.nonterm - - private val type: Nonterminal = grammar.type.nonterm - - private val primitiveType: Nonterminal = grammar.primitiveType.nonterm - - private val referenceType: Nonterminal = grammar.referenceType.nonterm - - private val `annotation`: Nonterminal = grammar.annotation.nonterm - - private val numericType: Nonterminal = grammar.numericType.nonterm - - private val integralType: Nonterminal = grammar.integralType.nonterm - - private val floatingPointType: Nonterminal = grammar.floatingPointType.nonterm - - private val classOrInterfaceType: Nonterminal = grammar.classOrInterfaceType.nonterm - - private val typeVariable: Nonterminal = grammar.typeVariable.nonterm - - private val arrayType: Nonterminal = grammar.arrayType.nonterm - - private val classType: Nonterminal = grammar.classType.nonterm - - private val interfaceType: Nonterminal = grammar.interfaceType.nonterm - - private val typeArguments: Nonterminal = grammar.typeArguments.nonterm - - private val dims: Nonterminal = grammar.dims.nonterm - - private val typeParameter: Nonterminal = grammar.typeParameter.nonterm - - private val typeParameterModifier: Nonterminal = grammar.typeParameterModifier.nonterm - - private val typeBound: Nonterminal = grammar.typeBound.nonterm - - private val additionalBound: Nonterminal = grammar.additionalBound.nonterm - - private val typeArgumentList: Nonterminal = grammar.typeArgumentList.nonterm - - private val typeArgument: Nonterminal = grammar.typeArgument.nonterm - - private val wildcard: Nonterminal = grammar.wildcard.nonterm - - private val wildcardBounds: Nonterminal = grammar.wildcardBounds.nonterm - - private val typeName: Nonterminal = grammar.typeName.nonterm - - private val packageOrTypeName: Nonterminal = grammar.packageOrTypeName.nonterm - - private val expressionName: Nonterminal = grammar.expressionName.nonterm - - private val ambiguousName: Nonterminal = grammar.ambiguousName.nonterm - - private val methodName: Nonterminal = grammar.methodName.nonterm - - private val packageName: Nonterminal = grammar.packageName.nonterm - - private val result: Nonterminal = grammar.result.nonterm - - private val packageDeclaration: Nonterminal = grammar.packageDeclaration.nonterm - - private val importDeclaration: Nonterminal = grammar.importDeclaration.nonterm - - private val typeDeclaration: Nonterminal = grammar.typeDeclaration.nonterm - - private val packageModifier: Nonterminal = grammar.packageModifier.nonterm - - private val singleTypeImportDeclaration: Nonterminal = grammar.singleTypeImportDeclaration.nonterm - - private val typeImportOnDemandDeclaration: Nonterminal = - grammar.typeImportOnDemandDeclaration.nonterm - - private val singleStaticImportDeclaration: Nonterminal = - grammar.singleStaticImportDeclaration.nonterm - - private val staticImportOnDemandDeclaration: Nonterminal = - grammar.staticImportOnDemandDeclaration.nonterm - - private val classDeclaration: Nonterminal = grammar.classDeclaration.nonterm - - private val interfaceDeclaration: Nonterminal = grammar.interfaceDeclaration.nonterm - - private val throws: Nonterminal = grammar.throws.nonterm - - private val normalClassDeclaration: Nonterminal = grammar.normalClassDeclaration.nonterm - - private val enumDeclaration: Nonterminal = grammar.enumDeclaration.nonterm - - private val classModifier: Nonterminal = grammar.classModifier.nonterm - - private val typeParameters: Nonterminal = grammar.typeParameters.nonterm - - private val superclass: Nonterminal = grammar.superclass.nonterm - - private val superinterfaces: Nonterminal = grammar.superinterfaces.nonterm - - private val classBody: Nonterminal = grammar.classBody.nonterm - - private val typeParameterList: Nonterminal = grammar.typeParameterList.nonterm - - private val interfaceTypeList: Nonterminal = grammar.interfaceTypeList.nonterm - - private val classBodyDeclaration: Nonterminal = grammar.classBodyDeclaration.nonterm - - private val classMemberDeclaration: Nonterminal = grammar.classMemberDeclaration.nonterm - - private val instanceInitializer: Nonterminal = grammar.instanceInitializer.nonterm - - private val staticInitializer: Nonterminal = grammar.staticInitializer.nonterm - - private val constructorDeclaration: Nonterminal = grammar.constructorDeclaration.nonterm - - private val fieldDeclaration: Nonterminal = grammar.fieldDeclaration.nonterm - - private val methodDeclaration: Nonterminal = grammar.methodDeclaration.nonterm - - private val fieldModifier: Nonterminal = grammar.fieldModifier.nonterm - - private val unannType: Nonterminal = grammar.unannType.nonterm - - private val variableDeclaratorList: Nonterminal = grammar.variableDeclaratorList.nonterm - - private val variableDeclarator: Nonterminal = grammar.variableDeclarator.nonterm - - private val variableDeclaratorId: Nonterminal = grammar.variableDeclaratorId.nonterm - - private val variableInitializer: Nonterminal = grammar.variableInitializer.nonterm - - private val expression: Nonterminal = grammar.expression.nonterm - - private val arrayInitializer: Nonterminal = grammar.arrayInitializer.nonterm - - private val unannPrimitiveType: Nonterminal = grammar.unannPrimitiveType.nonterm - - private val unannReferenceType: Nonterminal = grammar.unannReferenceType.nonterm - - private val unannClassOrInterfaceType: Nonterminal = grammar.unannClassOrInterfaceType.nonterm - - private val unannTypeVariable: Nonterminal = grammar.unannTypeVariable.nonterm - - private val unannArrayType: Nonterminal = grammar.unannArrayType.nonterm - - private val unannClassType: Nonterminal = grammar.unannClassType.nonterm - - private val unannInterfaceType: Nonterminal = grammar.unannInterfaceType.nonterm - - private val methodModifier: Nonterminal = grammar.methodModifier.nonterm - - private val methodHeader: Nonterminal = grammar.methodHeader.nonterm - - private val methodBody: Nonterminal = grammar.methodBody.nonterm - - private val methodDeclarator: Nonterminal = grammar.methodDeclarator.nonterm - - private val formalParameterList: Nonterminal = grammar.formalParameterList.nonterm - - private val receiverParameter: Nonterminal = grammar.receiverParameter.nonterm - - private val formalParameters: Nonterminal = grammar.formalParameters.nonterm - - private val lastFormalParameter: Nonterminal = grammar.lastFormalParameter.nonterm - - private val formalParameter: Nonterminal = grammar.formalParameter.nonterm - - private val variableModifier: Nonterminal = grammar.variableModifier.nonterm - - private val exceptionTypeList: Nonterminal = grammar.exceptionTypeList.nonterm - - private val exceptionType: Nonterminal = grammar.exceptionType.nonterm - - private val block: Nonterminal = grammar.block.nonterm - - private val constructorModifier: Nonterminal = grammar.constructorModifier.nonterm - - private val constructorDeclarator: Nonterminal = grammar.constructorDeclarator.nonterm - - private val constructorBody: Nonterminal = grammar.constructorBody.nonterm - - private val simpleTypeName: Nonterminal = grammar.simpleTypeName.nonterm - - private val explicitConstructorInvocation: Nonterminal = - grammar.explicitConstructorInvocation.nonterm - - private val enumBody: Nonterminal = grammar.enumBody.nonterm - - private val enumConstantList: Nonterminal = grammar.enumConstantList.nonterm - - private val enumConstant: Nonterminal = grammar.enumConstant.nonterm - - private val enumConstantModifier: Nonterminal = grammar.enumConstantModifier.nonterm - - private val enumBodyDeclarations: Nonterminal = grammar.enumBodyDeclarations.nonterm - - private val blockStatements: Nonterminal = grammar.blockStatements.nonterm - - private val argumentList: Nonterminal = grammar.argumentList.nonterm - - private val primary: Nonterminal = grammar.primary.nonterm - - private val normalInterfaceDeclaration: Nonterminal = grammar.normalInterfaceDeclaration.nonterm - - private val interfaceModifier: Nonterminal = grammar.interfaceModifier.nonterm - - private val extendsInterfaces: Nonterminal = grammar.extendsInterfaces.nonterm - - private val interfaceBody: Nonterminal = grammar.interfaceBody.nonterm - - private val interfaceMemberDeclaration: Nonterminal = grammar.interfaceMemberDeclaration.nonterm - - private val constantDeclaration: Nonterminal = grammar.constantDeclaration.nonterm - - private val constantModifier: Nonterminal = grammar.constantModifier.nonterm - - private val annotationTypeDeclaration: Nonterminal = grammar.annotationTypeDeclaration.nonterm - - private val annotationTypeBody: Nonterminal = grammar.annotationTypeBody.nonterm - - private val annotationTypeMemberDeclaration: Nonterminal = - grammar.annotationTypeMemberDeclaration.nonterm - - private val annotationTypeElementDeclaration: Nonterminal = - grammar.annotationTypeElementDeclaration.nonterm - - private val defaultValue: Nonterminal = grammar.defaultValue.nonterm - - private val normalAnnotation: Nonterminal = grammar.normalAnnotation.nonterm - - private val elementValuePairList: Nonterminal = grammar.elementValuePairList.nonterm - - private val elementValuePair: Nonterminal = grammar.elementValuePair.nonterm - - private val elementValue: Nonterminal = grammar.elementValue.nonterm - - private val elementValueArrayInitializer: Nonterminal = - grammar.elementValueArrayInitializer.nonterm - - private val elementValueList: Nonterminal = grammar.elementValueList.nonterm - - private val markerAnnotation: Nonterminal = grammar.markerAnnotation.nonterm - - private val singleElementAnnotation: Nonterminal = grammar.singleElementAnnotation.nonterm - - private val interfaceMethodDeclaration: Nonterminal = grammar.interfaceMethodDeclaration.nonterm - - private val annotationTypeElementModifier: Nonterminal = - grammar.annotationTypeElementModifier.nonterm - - private val conditionalExpression: Nonterminal = grammar.conditionalExpression.nonterm - - private val variableInitializerList: Nonterminal = grammar.variableInitializerList.nonterm - - private val blockStatement: Nonterminal = grammar.blockStatement.nonterm - - private val localVariableDeclarationStatement: Nonterminal = - grammar.localVariableDeclarationStatement.nonterm - - private val localVariableDeclaration: Nonterminal = grammar.localVariableDeclaration.nonterm - - private val statement: Nonterminal = grammar.statement.nonterm - - private val statementNoShortIf: Nonterminal = grammar.statementNoShortIf.nonterm - - private val statementWithoutTrailingSubstatement: Nonterminal = - grammar.statementWithoutTrailingSubstatement.nonterm - - private val emptyStatement: Nonterminal = grammar.emptyStatement.nonterm - - private val labeledStatement: Nonterminal = grammar.labeledStatement.nonterm - - private val labeledStatementNoShortIf: Nonterminal = grammar.labeledStatementNoShortIf.nonterm - - private val expressionStatement: Nonterminal = grammar.expressionStatement.nonterm - - private val statementExpression: Nonterminal = grammar.statementExpression.nonterm - - private val ifThenStatement: Nonterminal = grammar.ifThenStatement.nonterm - - private val ifThenElseStatement: Nonterminal = grammar.ifThenElseStatement.nonterm - - private val ifThenElseStatementNoShortIf: Nonterminal = - grammar.ifThenElseStatementNoShortIf.nonterm - - private val assertStatement: Nonterminal = grammar.assertStatement.nonterm - - private val switchStatement: Nonterminal = grammar.switchStatement.nonterm - - private val switchBlock: Nonterminal = grammar.switchBlock.nonterm - - private val switchBlockStatementGroup: Nonterminal = grammar.switchBlockStatementGroup.nonterm - - private val switchLabels: Nonterminal = grammar.switchLabels.nonterm - - private val switchLabel: Nonterminal = grammar.switchLabel.nonterm - - private val enumConstantName: Nonterminal = grammar.enumConstantName.nonterm - - private val whileStatement: Nonterminal = grammar.whileStatement.nonterm - - private val whileStatementNoShortIf: Nonterminal = grammar.whileStatementNoShortIf.nonterm - - private val doStatement: Nonterminal = grammar.doStatement.nonterm - - private val interfaceMethodModifier: Nonterminal = grammar.interfaceMethodModifier.nonterm - - private val forStatement: Nonterminal = grammar.forStatement.nonterm - - private val forStatementNoShortIf: Nonterminal = grammar.forStatementNoShortIf.nonterm - - private val basicForStatement: Nonterminal = grammar.basicForStatement.nonterm - - private val basicForStatementNoShortIf: Nonterminal = grammar.basicForStatementNoShortIf.nonterm - - private val forInit: Nonterminal = grammar.forInit.nonterm - - private val forUpdate: Nonterminal = grammar.forUpdate.nonterm - - private val statementExpressionList: Nonterminal = grammar.statementExpressionList.nonterm - - private val enhancedForStatement: Nonterminal = grammar.enhancedForStatement.nonterm - - private val enhancedForStatementNoShortIf: Nonterminal = - grammar.enhancedForStatementNoShortIf.nonterm - - private val breakStatement: Nonterminal = grammar.breakStatement.nonterm - - private val continueStatement: Nonterminal = grammar.continueStatement.nonterm - - private val returnStatement: Nonterminal = grammar.returnStatement.nonterm - - private val throwStatement: Nonterminal = grammar.throwStatement.nonterm - - private val synchronizedStatement: Nonterminal = grammar.synchronizedStatement.nonterm - - private val tryStatement: Nonterminal = grammar.tryStatement.nonterm - - private val catches: Nonterminal = grammar.catches.nonterm - - private val catchClause: Nonterminal = grammar.catchClause.nonterm - - private val catchFormalParameter: Nonterminal = grammar.catchFormalParameter.nonterm - - private val catchType: Nonterminal = grammar.catchType.nonterm - - private val `finally`: Nonterminal = grammar.finally.nonterm - - private val tryWithResourcesStatement: Nonterminal = grammar.tryWithResourcesStatement.nonterm - - private val resourceSpecification: Nonterminal = grammar.resourceSpecification.nonterm - - private val resourceList: Nonterminal = grammar.resourceList.nonterm - - private val resource: Nonterminal = grammar.resource.nonterm - - private val primaryNoNewArray: Nonterminal = grammar.primaryNoNewArray.nonterm - - private val classLiteral: Nonterminal = grammar.classLiteral.nonterm - - private val classOrInterfaceTypeToInstantiate: Nonterminal = - grammar.classOrInterfaceTypeToInstantiate.nonterm - - private val unqualifiedClassInstanceCreationExpression: Nonterminal = - grammar.unqualifiedClassInstanceCreationExpression.nonterm - - private val classInstanceCreationExpression: Nonterminal = - grammar.classInstanceCreationExpression.nonterm - - private val fieldAccess: Nonterminal = grammar.fieldAccess.nonterm - - private val typeArgumentsOrDiamond: Nonterminal = grammar.typeArgumentsOrDiamond.nonterm - - private val arrayAccess: Nonterminal = grammar.arrayAccess.nonterm - - private val methodInvocation: Nonterminal = grammar.methodInvocation.nonterm - - private val methodReference: Nonterminal = grammar.methodReference.nonterm - - private val arrayCreationExpression: Nonterminal = grammar.arrayCreationExpression.nonterm - - private val dimExprs: Nonterminal = grammar.dimExprs.nonterm - - private val dimExpr: Nonterminal = grammar.dimExpr.nonterm - - private val lambdaExpression: Nonterminal = grammar.lambdaExpression.nonterm - - private val lambdaParameters: Nonterminal = grammar.lambdaParameters.nonterm - - private val inferredFormalParameterList: Nonterminal = grammar.inferredFormalParameterList.nonterm - - private val lambdaBody: Nonterminal = grammar.lambdaBody.nonterm - - private val assignmentExpression: Nonterminal = grammar.assignmentExpression.nonterm - - private val assignment: Nonterminal = grammar.assignment.nonterm - - private val leftHandSide: Nonterminal = grammar.leftHandSide.nonterm - - private val assignmentOperator: Nonterminal = grammar.assignmentOperator.nonterm - - private val conditionalOrExpression: Nonterminal = grammar.conditionalOrExpression.nonterm - - private val conditionalAndExpression: Nonterminal = grammar.conditionalAndExpression.nonterm - - private val inclusiveOrExpression: Nonterminal = grammar.inclusiveOrExpression.nonterm - - private val exclusiveOrExpression: Nonterminal = grammar.exclusiveOrExpression.nonterm - - private val andExpression: Nonterminal = grammar.andExpression.nonterm - - private val equalityExpression: Nonterminal = grammar.equalityExpression.nonterm - - private val relationalExpression: Nonterminal = grammar.relationalExpression.nonterm - - private val shiftExpression: Nonterminal = grammar.shiftExpression.nonterm - - private val additiveExpression: Nonterminal = grammar.additiveExpression.nonterm - - private val multiplicativeExpression: Nonterminal = grammar.multiplicativeExpression.nonterm - - private val preIncrementExpression: Nonterminal = grammar.preIncrementExpression.nonterm - - private val preDecrementExpression: Nonterminal = grammar.preDecrementExpression.nonterm - - private val unaryExpressionNotPlusMinus: Nonterminal = grammar.unaryExpressionNotPlusMinus.nonterm - - private val unaryExpression: Nonterminal = grammar.unaryExpression.nonterm - - private val postfixExpression: Nonterminal = grammar.postfixExpression.nonterm - - private val postIncrementExpression: Nonterminal = grammar.postIncrementExpression.nonterm - - private val postDecrementExpression: Nonterminal = grammar.postDecrementExpression.nonterm - - private val castExpression: Nonterminal = grammar.castExpression.nonterm - - private val constantExpression: Nonterminal = grammar.constantExpression.nonterm - - override fun callNtFuncs( - nt: Nonterminal, - descriptor: Descriptor, - curSppfNode: SppfNode?, - ) { - when(nt.name) { - "compilationUnit" -> parsecompilationUnit(descriptor, curSppfNode) - "identifier" -> parseidentifier(descriptor, curSppfNode) - "literal" -> parseliteral(descriptor, curSppfNode) - "type" -> parsetype(descriptor, curSppfNode) - "primitiveType" -> parseprimitiveType(descriptor, curSppfNode) - "referenceType" -> parsereferenceType(descriptor, curSppfNode) - "annotation" -> parseannotation(descriptor, curSppfNode) - "numericType" -> parsenumericType(descriptor, curSppfNode) - "integralType" -> parseintegralType(descriptor, curSppfNode) - "floatingPointType" -> parsefloatingPointType(descriptor, curSppfNode) - "classOrInterfaceType" -> parseclassOrInterfaceType(descriptor, curSppfNode) - "typeVariable" -> parsetypeVariable(descriptor, curSppfNode) - "arrayType" -> parsearrayType(descriptor, curSppfNode) - "classType" -> parseclassType(descriptor, curSppfNode) - "interfaceType" -> parseinterfaceType(descriptor, curSppfNode) - "typeArguments" -> parsetypeArguments(descriptor, curSppfNode) - "dims" -> parsedims(descriptor, curSppfNode) - "typeParameter" -> parsetypeParameter(descriptor, curSppfNode) - "typeParameterModifier" -> parsetypeParameterModifier(descriptor, curSppfNode) - "typeBound" -> parsetypeBound(descriptor, curSppfNode) - "additionalBound" -> parseadditionalBound(descriptor, curSppfNode) - "typeArgumentList" -> parsetypeArgumentList(descriptor, curSppfNode) - "typeArgument" -> parsetypeArgument(descriptor, curSppfNode) - "wildcard" -> parsewildcard(descriptor, curSppfNode) - "wildcardBounds" -> parsewildcardBounds(descriptor, curSppfNode) - "typeName" -> parsetypeName(descriptor, curSppfNode) - "packageOrTypeName" -> parsepackageOrTypeName(descriptor, curSppfNode) - "expressionName" -> parseexpressionName(descriptor, curSppfNode) - "ambiguousName" -> parseambiguousName(descriptor, curSppfNode) - "methodName" -> parsemethodName(descriptor, curSppfNode) - "packageName" -> parsepackageName(descriptor, curSppfNode) - "result" -> parseresult(descriptor, curSppfNode) - "packageDeclaration" -> parsepackageDeclaration(descriptor, curSppfNode) - "importDeclaration" -> parseimportDeclaration(descriptor, curSppfNode) - "typeDeclaration" -> parsetypeDeclaration(descriptor, curSppfNode) - "packageModifier" -> parsepackageModifier(descriptor, curSppfNode) - "singleTypeImportDeclaration" -> parsesingleTypeImportDeclaration(descriptor, curSppfNode) - "typeImportOnDemandDeclaration" -> parsetypeImportOnDemandDeclaration(descriptor, curSppfNode) - "singleStaticImportDeclaration" -> parsesingleStaticImportDeclaration(descriptor, curSppfNode) - "staticImportOnDemandDeclaration" -> parsestaticImportOnDemandDeclaration(descriptor, - curSppfNode) - "classDeclaration" -> parseclassDeclaration(descriptor, curSppfNode) - "interfaceDeclaration" -> parseinterfaceDeclaration(descriptor, curSppfNode) - "throws" -> parsethrows(descriptor, curSppfNode) - "normalClassDeclaration" -> parsenormalClassDeclaration(descriptor, curSppfNode) - "enumDeclaration" -> parseenumDeclaration(descriptor, curSppfNode) - "classModifier" -> parseclassModifier(descriptor, curSppfNode) - "typeParameters" -> parsetypeParameters(descriptor, curSppfNode) - "superclass" -> parsesuperclass(descriptor, curSppfNode) - "superinterfaces" -> parsesuperinterfaces(descriptor, curSppfNode) - "classBody" -> parseclassBody(descriptor, curSppfNode) - "typeParameterList" -> parsetypeParameterList(descriptor, curSppfNode) - "interfaceTypeList" -> parseinterfaceTypeList(descriptor, curSppfNode) - "classBodyDeclaration" -> parseclassBodyDeclaration(descriptor, curSppfNode) - "classMemberDeclaration" -> parseclassMemberDeclaration(descriptor, curSppfNode) - "instanceInitializer" -> parseinstanceInitializer(descriptor, curSppfNode) - "staticInitializer" -> parsestaticInitializer(descriptor, curSppfNode) - "constructorDeclaration" -> parseconstructorDeclaration(descriptor, curSppfNode) - "fieldDeclaration" -> parsefieldDeclaration(descriptor, curSppfNode) - "methodDeclaration" -> parsemethodDeclaration(descriptor, curSppfNode) - "fieldModifier" -> parsefieldModifier(descriptor, curSppfNode) - "unannType" -> parseunannType(descriptor, curSppfNode) - "variableDeclaratorList" -> parsevariableDeclaratorList(descriptor, curSppfNode) - "variableDeclarator" -> parsevariableDeclarator(descriptor, curSppfNode) - "variableDeclaratorId" -> parsevariableDeclaratorId(descriptor, curSppfNode) - "variableInitializer" -> parsevariableInitializer(descriptor, curSppfNode) - "expression" -> parseexpression(descriptor, curSppfNode) - "arrayInitializer" -> parsearrayInitializer(descriptor, curSppfNode) - "unannPrimitiveType" -> parseunannPrimitiveType(descriptor, curSppfNode) - "unannReferenceType" -> parseunannReferenceType(descriptor, curSppfNode) - "unannClassOrInterfaceType" -> parseunannClassOrInterfaceType(descriptor, curSppfNode) - "unannTypeVariable" -> parseunannTypeVariable(descriptor, curSppfNode) - "unannArrayType" -> parseunannArrayType(descriptor, curSppfNode) - "unannClassType" -> parseunannClassType(descriptor, curSppfNode) - "unannInterfaceType" -> parseunannInterfaceType(descriptor, curSppfNode) - "methodModifier" -> parsemethodModifier(descriptor, curSppfNode) - "methodHeader" -> parsemethodHeader(descriptor, curSppfNode) - "methodBody" -> parsemethodBody(descriptor, curSppfNode) - "methodDeclarator" -> parsemethodDeclarator(descriptor, curSppfNode) - "formalParameterList" -> parseformalParameterList(descriptor, curSppfNode) - "receiverParameter" -> parsereceiverParameter(descriptor, curSppfNode) - "formalParameters" -> parseformalParameters(descriptor, curSppfNode) - "lastFormalParameter" -> parselastFormalParameter(descriptor, curSppfNode) - "formalParameter" -> parseformalParameter(descriptor, curSppfNode) - "variableModifier" -> parsevariableModifier(descriptor, curSppfNode) - "exceptionTypeList" -> parseexceptionTypeList(descriptor, curSppfNode) - "exceptionType" -> parseexceptionType(descriptor, curSppfNode) - "block" -> parseblock(descriptor, curSppfNode) - "constructorModifier" -> parseconstructorModifier(descriptor, curSppfNode) - "constructorDeclarator" -> parseconstructorDeclarator(descriptor, curSppfNode) - "constructorBody" -> parseconstructorBody(descriptor, curSppfNode) - "simpleTypeName" -> parsesimpleTypeName(descriptor, curSppfNode) - "explicitConstructorInvocation" -> parseexplicitConstructorInvocation(descriptor, curSppfNode) - "enumBody" -> parseenumBody(descriptor, curSppfNode) - "enumConstantList" -> parseenumConstantList(descriptor, curSppfNode) - "enumConstant" -> parseenumConstant(descriptor, curSppfNode) - "enumConstantModifier" -> parseenumConstantModifier(descriptor, curSppfNode) - "enumBodyDeclarations" -> parseenumBodyDeclarations(descriptor, curSppfNode) - "blockStatements" -> parseblockStatements(descriptor, curSppfNode) - "argumentList" -> parseargumentList(descriptor, curSppfNode) - "primary" -> parseprimary(descriptor, curSppfNode) - "normalInterfaceDeclaration" -> parsenormalInterfaceDeclaration(descriptor, curSppfNode) - "interfaceModifier" -> parseinterfaceModifier(descriptor, curSppfNode) - "extendsInterfaces" -> parseextendsInterfaces(descriptor, curSppfNode) - "interfaceBody" -> parseinterfaceBody(descriptor, curSppfNode) - "interfaceMemberDeclaration" -> parseinterfaceMemberDeclaration(descriptor, curSppfNode) - "constantDeclaration" -> parseconstantDeclaration(descriptor, curSppfNode) - "constantModifier" -> parseconstantModifier(descriptor, curSppfNode) - "annotationTypeDeclaration" -> parseannotationTypeDeclaration(descriptor, curSppfNode) - "annotationTypeBody" -> parseannotationTypeBody(descriptor, curSppfNode) - "annotationTypeMemberDeclaration" -> parseannotationTypeMemberDeclaration(descriptor, - curSppfNode) - "annotationTypeElementDeclaration" -> parseannotationTypeElementDeclaration(descriptor, - curSppfNode) - "defaultValue" -> parsedefaultValue(descriptor, curSppfNode) - "normalAnnotation" -> parsenormalAnnotation(descriptor, curSppfNode) - "elementValuePairList" -> parseelementValuePairList(descriptor, curSppfNode) - "elementValuePair" -> parseelementValuePair(descriptor, curSppfNode) - "elementValue" -> parseelementValue(descriptor, curSppfNode) - "elementValueArrayInitializer" -> parseelementValueArrayInitializer(descriptor, curSppfNode) - "elementValueList" -> parseelementValueList(descriptor, curSppfNode) - "markerAnnotation" -> parsemarkerAnnotation(descriptor, curSppfNode) - "singleElementAnnotation" -> parsesingleElementAnnotation(descriptor, curSppfNode) - "interfaceMethodDeclaration" -> parseinterfaceMethodDeclaration(descriptor, curSppfNode) - "annotationTypeElementModifier" -> parseannotationTypeElementModifier(descriptor, curSppfNode) - "conditionalExpression" -> parseconditionalExpression(descriptor, curSppfNode) - "variableInitializerList" -> parsevariableInitializerList(descriptor, curSppfNode) - "blockStatement" -> parseblockStatement(descriptor, curSppfNode) - "localVariableDeclarationStatement" -> parselocalVariableDeclarationStatement(descriptor, - curSppfNode) - "localVariableDeclaration" -> parselocalVariableDeclaration(descriptor, curSppfNode) - "statement" -> parsestatement(descriptor, curSppfNode) - "statementNoShortIf" -> parsestatementNoShortIf(descriptor, curSppfNode) - "statementWithoutTrailingSubstatement" -> - parsestatementWithoutTrailingSubstatement(descriptor, curSppfNode) - "emptyStatement" -> parseemptyStatement(descriptor, curSppfNode) - "labeledStatement" -> parselabeledStatement(descriptor, curSppfNode) - "labeledStatementNoShortIf" -> parselabeledStatementNoShortIf(descriptor, curSppfNode) - "expressionStatement" -> parseexpressionStatement(descriptor, curSppfNode) - "statementExpression" -> parsestatementExpression(descriptor, curSppfNode) - "ifThenStatement" -> parseifThenStatement(descriptor, curSppfNode) - "ifThenElseStatement" -> parseifThenElseStatement(descriptor, curSppfNode) - "ifThenElseStatementNoShortIf" -> parseifThenElseStatementNoShortIf(descriptor, curSppfNode) - "assertStatement" -> parseassertStatement(descriptor, curSppfNode) - "switchStatement" -> parseswitchStatement(descriptor, curSppfNode) - "switchBlock" -> parseswitchBlock(descriptor, curSppfNode) - "switchBlockStatementGroup" -> parseswitchBlockStatementGroup(descriptor, curSppfNode) - "switchLabels" -> parseswitchLabels(descriptor, curSppfNode) - "switchLabel" -> parseswitchLabel(descriptor, curSppfNode) - "enumConstantName" -> parseenumConstantName(descriptor, curSppfNode) - "whileStatement" -> parsewhileStatement(descriptor, curSppfNode) - "whileStatementNoShortIf" -> parsewhileStatementNoShortIf(descriptor, curSppfNode) - "doStatement" -> parsedoStatement(descriptor, curSppfNode) - "interfaceMethodModifier" -> parseinterfaceMethodModifier(descriptor, curSppfNode) - "forStatement" -> parseforStatement(descriptor, curSppfNode) - "forStatementNoShortIf" -> parseforStatementNoShortIf(descriptor, curSppfNode) - "basicForStatement" -> parsebasicForStatement(descriptor, curSppfNode) - "basicForStatementNoShortIf" -> parsebasicForStatementNoShortIf(descriptor, curSppfNode) - "forInit" -> parseforInit(descriptor, curSppfNode) - "forUpdate" -> parseforUpdate(descriptor, curSppfNode) - "statementExpressionList" -> parsestatementExpressionList(descriptor, curSppfNode) - "enhancedForStatement" -> parseenhancedForStatement(descriptor, curSppfNode) - "enhancedForStatementNoShortIf" -> parseenhancedForStatementNoShortIf(descriptor, curSppfNode) - "breakStatement" -> parsebreakStatement(descriptor, curSppfNode) - "continueStatement" -> parsecontinueStatement(descriptor, curSppfNode) - "returnStatement" -> parsereturnStatement(descriptor, curSppfNode) - "throwStatement" -> parsethrowStatement(descriptor, curSppfNode) - "synchronizedStatement" -> parsesynchronizedStatement(descriptor, curSppfNode) - "tryStatement" -> parsetryStatement(descriptor, curSppfNode) - "catches" -> parsecatches(descriptor, curSppfNode) - "catchClause" -> parsecatchClause(descriptor, curSppfNode) - "catchFormalParameter" -> parsecatchFormalParameter(descriptor, curSppfNode) - "catchType" -> parsecatchType(descriptor, curSppfNode) - "finally" -> parsefinally(descriptor, curSppfNode) - "tryWithResourcesStatement" -> parsetryWithResourcesStatement(descriptor, curSppfNode) - "resourceSpecification" -> parseresourceSpecification(descriptor, curSppfNode) - "resourceList" -> parseresourceList(descriptor, curSppfNode) - "resource" -> parseresource(descriptor, curSppfNode) - "primaryNoNewArray" -> parseprimaryNoNewArray(descriptor, curSppfNode) - "classLiteral" -> parseclassLiteral(descriptor, curSppfNode) - "classOrInterfaceTypeToInstantiate" -> parseclassOrInterfaceTypeToInstantiate(descriptor, - curSppfNode) - "unqualifiedClassInstanceCreationExpression" -> - parseunqualifiedClassInstanceCreationExpression(descriptor, curSppfNode) - "classInstanceCreationExpression" -> parseclassInstanceCreationExpression(descriptor, - curSppfNode) - "fieldAccess" -> parsefieldAccess(descriptor, curSppfNode) - "typeArgumentsOrDiamond" -> parsetypeArgumentsOrDiamond(descriptor, curSppfNode) - "arrayAccess" -> parsearrayAccess(descriptor, curSppfNode) - "methodInvocation" -> parsemethodInvocation(descriptor, curSppfNode) - "methodReference" -> parsemethodReference(descriptor, curSppfNode) - "arrayCreationExpression" -> parsearrayCreationExpression(descriptor, curSppfNode) - "dimExprs" -> parsedimExprs(descriptor, curSppfNode) - "dimExpr" -> parsedimExpr(descriptor, curSppfNode) - "lambdaExpression" -> parselambdaExpression(descriptor, curSppfNode) - "lambdaParameters" -> parselambdaParameters(descriptor, curSppfNode) - "inferredFormalParameterList" -> parseinferredFormalParameterList(descriptor, curSppfNode) - "lambdaBody" -> parselambdaBody(descriptor, curSppfNode) - "assignmentExpression" -> parseassignmentExpression(descriptor, curSppfNode) - "assignment" -> parseassignment(descriptor, curSppfNode) - "leftHandSide" -> parseleftHandSide(descriptor, curSppfNode) - "assignmentOperator" -> parseassignmentOperator(descriptor, curSppfNode) - "conditionalOrExpression" -> parseconditionalOrExpression(descriptor, curSppfNode) - "conditionalAndExpression" -> parseconditionalAndExpression(descriptor, curSppfNode) - "inclusiveOrExpression" -> parseinclusiveOrExpression(descriptor, curSppfNode) - "exclusiveOrExpression" -> parseexclusiveOrExpression(descriptor, curSppfNode) - "andExpression" -> parseandExpression(descriptor, curSppfNode) - "equalityExpression" -> parseequalityExpression(descriptor, curSppfNode) - "relationalExpression" -> parserelationalExpression(descriptor, curSppfNode) - "shiftExpression" -> parseshiftExpression(descriptor, curSppfNode) - "additiveExpression" -> parseadditiveExpression(descriptor, curSppfNode) - "multiplicativeExpression" -> parsemultiplicativeExpression(descriptor, curSppfNode) - "preIncrementExpression" -> parsepreIncrementExpression(descriptor, curSppfNode) - "preDecrementExpression" -> parsepreDecrementExpression(descriptor, curSppfNode) - "unaryExpressionNotPlusMinus" -> parseunaryExpressionNotPlusMinus(descriptor, curSppfNode) - "unaryExpression" -> parseunaryExpression(descriptor, curSppfNode) - "postfixExpression" -> parsepostfixExpression(descriptor, curSppfNode) - "postIncrementExpression" -> parsepostIncrementExpression(descriptor, curSppfNode) - "postDecrementExpression" -> parsepostDecrementExpression(descriptor, curSppfNode) - "castExpression" -> parsecastExpression(descriptor, curSppfNode) - "constantExpression" -> parseconstantExpression(descriptor, curSppfNode) - } - } - - private fun parsecompilationUnit(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, packageDeclaration, - state.nonterminalEdges[packageDeclaration]!!, curSppfNode) - handleNonterminalEdge(descriptor, typeDeclaration, - state.nonterminalEdges[typeDeclaration]!!, curSppfNode) - handleNonterminalEdge(descriptor, importDeclaration, - state.nonterminalEdges[importDeclaration]!!, curSppfNode) - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, typeDeclaration, - state.nonterminalEdges[typeDeclaration]!!, curSppfNode) - handleNonterminalEdge(descriptor, importDeclaration, - state.nonterminalEdges[importDeclaration]!!, curSppfNode) - } - 2 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, typeDeclaration, - state.nonterminalEdges[typeDeclaration]!!, curSppfNode) - } - } - } - - private fun parseidentifier(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.IDENTIFIER -> - handleTerminal(JavaToken.IDENTIFIER, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - } - } - } - - private fun parseliteral(descriptor: Descriptor, curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.FLOATING_POINT_LITERAL -> - handleTerminal(JavaToken.FLOATING_POINT_LITERAL, state, inputEdge, descriptor, - curSppfNode) - JavaToken.BOOLEAN_LITERAL -> - handleTerminal(JavaToken.BOOLEAN_LITERAL, state, inputEdge, descriptor, curSppfNode) - JavaToken.CHARACTER_LITERAL -> - handleTerminal(JavaToken.CHARACTER_LITERAL, state, inputEdge, descriptor, curSppfNode) - JavaToken.INTEGER_LITERAL -> - handleTerminal(JavaToken.INTEGER_LITERAL, state, inputEdge, descriptor, curSppfNode) - JavaToken.STRING_LITERAL -> - handleTerminal(JavaToken.STRING_LITERAL, state, inputEdge, descriptor, curSppfNode) - JavaToken.NULL_LITERAL -> - handleTerminal(JavaToken.NULL_LITERAL, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - } - } - } - - private fun parsetype(descriptor: Descriptor, curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, referenceType, state.nonterminalEdges[referenceType]!!, - curSppfNode) - handleNonterminalEdge(descriptor, primitiveType, state.nonterminalEdges[primitiveType]!!, - curSppfNode) - } - 1 -> - { - } - } - } - - private fun parseprimitiveType(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.BOOLEAN -> - handleTerminal(JavaToken.BOOLEAN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, annotation, state.nonterminalEdges[annotation]!!, - curSppfNode) - handleNonterminalEdge(descriptor, numericType, state.nonterminalEdges[numericType]!!, - curSppfNode) - } - 1 -> - { - } - } - } - - private fun parsereferenceType(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, typeVariable, state.nonterminalEdges[typeVariable]!!, - curSppfNode) - handleNonterminalEdge(descriptor, arrayType, state.nonterminalEdges[arrayType]!!, - curSppfNode) - handleNonterminalEdge(descriptor, classOrInterfaceType, - state.nonterminalEdges[classOrInterfaceType]!!, curSppfNode) - } - 1 -> - { - } - } - } - - private fun parseannotation(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, singleElementAnnotation, - state.nonterminalEdges[singleElementAnnotation]!!, curSppfNode) - handleNonterminalEdge(descriptor, normalAnnotation, - state.nonterminalEdges[normalAnnotation]!!, curSppfNode) - handleNonterminalEdge(descriptor, markerAnnotation, - state.nonterminalEdges[markerAnnotation]!!, curSppfNode) - } - 1 -> - { - } - } - } - - private fun parsenumericType(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, floatingPointType, - state.nonterminalEdges[floatingPointType]!!, curSppfNode) - handleNonterminalEdge(descriptor, integralType, state.nonterminalEdges[integralType]!!, - curSppfNode) - } - 1 -> - { - } - } - } - - private fun parseintegralType(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.CHAR -> - handleTerminal(JavaToken.CHAR, state, inputEdge, descriptor, curSppfNode) - JavaToken.BYTE -> - handleTerminal(JavaToken.BYTE, state, inputEdge, descriptor, curSppfNode) - JavaToken.INT -> - handleTerminal(JavaToken.INT, state, inputEdge, descriptor, curSppfNode) - JavaToken.LONG -> - handleTerminal(JavaToken.LONG, state, inputEdge, descriptor, curSppfNode) - JavaToken.SHORT -> - handleTerminal(JavaToken.SHORT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - } - } - } - - private fun parsefloatingPointType(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.DOUBLE -> - handleTerminal(JavaToken.DOUBLE, state, inputEdge, descriptor, curSppfNode) - JavaToken.FLOAT -> - handleTerminal(JavaToken.FLOAT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - } - } - } - - private fun parseclassOrInterfaceType(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, interfaceType, state.nonterminalEdges[interfaceType]!!, - curSppfNode) - handleNonterminalEdge(descriptor, classType, state.nonterminalEdges[classType]!!, - curSppfNode) - } - 1 -> - { - } - } - } - - private fun parsetypeVariable(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, annotation, state.nonterminalEdges[annotation]!!, - curSppfNode) - handleNonterminalEdge(descriptor, identifier, state.nonterminalEdges[identifier]!!, - curSppfNode) - } - 1 -> - { - } - } - } - - private fun parsearrayType(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, typeVariable, state.nonterminalEdges[typeVariable]!!, - curSppfNode) - handleNonterminalEdge(descriptor, classOrInterfaceType, - state.nonterminalEdges[classOrInterfaceType]!!, curSppfNode) - handleNonterminalEdge(descriptor, primitiveType, state.nonterminalEdges[primitiveType]!!, - curSppfNode) - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, dims, state.nonterminalEdges[dims]!!, curSppfNode) - } - 2 -> - { - } - } - } - - private fun parseclassType(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, annotation, state.nonterminalEdges[annotation]!!, - curSppfNode) - handleNonterminalEdge(descriptor, identifier, state.nonterminalEdges[identifier]!!, - curSppfNode) - handleNonterminalEdge(descriptor, classOrInterfaceType, - state.nonterminalEdges[classOrInterfaceType]!!, curSppfNode) - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, annotation, state.nonterminalEdges[annotation]!!, - curSppfNode) - handleNonterminalEdge(descriptor, identifier, state.nonterminalEdges[identifier]!!, - curSppfNode) - } - 2 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, typeArguments, state.nonterminalEdges[typeArguments]!!, - curSppfNode) - } - 3 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.DOT -> - handleTerminal(JavaToken.DOT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 4 -> - { - } - } - } - - private fun parseinterfaceType(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, classType, state.nonterminalEdges[classType]!!, - curSppfNode) - } - 1 -> - { - } - } - } - - private fun parsetypeArguments(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.LT -> - handleTerminal(JavaToken.LT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, typeArgumentList, - state.nonterminalEdges[typeArgumentList]!!, curSppfNode) - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.GT -> - handleTerminal(JavaToken.GT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - } - } - } - - private fun parsedims(descriptor: Descriptor, curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.LBRACK -> - handleTerminal(JavaToken.LBRACK, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, annotation, state.nonterminalEdges[annotation]!!, - curSppfNode) - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RBRACK -> - handleTerminal(JavaToken.RBRACK, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.LBRACK -> - handleTerminal(JavaToken.LBRACK, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, annotation, state.nonterminalEdges[annotation]!!, - curSppfNode) - } - } - } - - private fun parsetypeParameter(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, identifier, state.nonterminalEdges[identifier]!!, - curSppfNode) - handleNonterminalEdge(descriptor, typeParameterModifier, - state.nonterminalEdges[typeParameterModifier]!!, curSppfNode) - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, typeBound, state.nonterminalEdges[typeBound]!!, - curSppfNode) - } - 2 -> - { - } - } - } - - private fun parsetypeParameterModifier(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, annotation, state.nonterminalEdges[annotation]!!, - curSppfNode) - } - 1 -> - { - } - } - } - - private fun parsetypeBound(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.EXTENDS -> - handleTerminal(JavaToken.EXTENDS, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, typeVariable, state.nonterminalEdges[typeVariable]!!, - curSppfNode) - handleNonterminalEdge(descriptor, classOrInterfaceType, - state.nonterminalEdges[classOrInterfaceType]!!, curSppfNode) - } - 2 -> - { - } - 3 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, additionalBound, - state.nonterminalEdges[additionalBound]!!, curSppfNode) - } - } - } - - private fun parseadditionalBound(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.AND -> - handleTerminal(JavaToken.AND, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, interfaceType, state.nonterminalEdges[interfaceType]!!, - curSppfNode) - } - 2 -> - { - } - } - } - - private fun parsetypeArgumentList(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, typeArgument, state.nonterminalEdges[typeArgument]!!, - curSppfNode) - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.COMMA -> - handleTerminal(JavaToken.COMMA, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - } - } - - private fun parsetypeArgument(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, referenceType, state.nonterminalEdges[referenceType]!!, - curSppfNode) - handleNonterminalEdge(descriptor, wildcard, state.nonterminalEdges[wildcard]!!, curSppfNode) - } - 1 -> - { - } - } - } - - private fun parsewildcard(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.QUESTION -> - handleTerminal(JavaToken.QUESTION, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, annotation, state.nonterminalEdges[annotation]!!, - curSppfNode) - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, wildcardBounds, state.nonterminalEdges[wildcardBounds]!!, - curSppfNode) - } - 2 -> - { - } - } - } - - private fun parsewildcardBounds(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SUPER -> - handleTerminal(JavaToken.SUPER, state, inputEdge, descriptor, curSppfNode) - JavaToken.EXTENDS -> - handleTerminal(JavaToken.EXTENDS, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, referenceType, state.nonterminalEdges[referenceType]!!, - curSppfNode) - } - 2 -> - { - } - } - } - - private fun parsetypeName(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, identifier, state.nonterminalEdges[identifier]!!, - curSppfNode) - handleNonterminalEdge(descriptor, packageOrTypeName, - state.nonterminalEdges[packageOrTypeName]!!, curSppfNode) - } - 1 -> - { - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.DOT -> - handleTerminal(JavaToken.DOT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, identifier, state.nonterminalEdges[identifier]!!, - curSppfNode) - } - } - } - - private fun parsepackageOrTypeName(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, identifier, state.nonterminalEdges[identifier]!!, - curSppfNode) - handleNonterminalEdge(descriptor, packageOrTypeName, - state.nonterminalEdges[packageOrTypeName]!!, curSppfNode) - } - 1 -> - { - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.DOT -> - handleTerminal(JavaToken.DOT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, identifier, state.nonterminalEdges[identifier]!!, - curSppfNode) - } - } - } - - private fun parseexpressionName(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, identifier, state.nonterminalEdges[identifier]!!, - curSppfNode) - handleNonterminalEdge(descriptor, ambiguousName, state.nonterminalEdges[ambiguousName]!!, - curSppfNode) - } - 1 -> - { - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.DOT -> - handleTerminal(JavaToken.DOT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, identifier, state.nonterminalEdges[identifier]!!, - curSppfNode) - } - } - } - - private fun parseambiguousName(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, identifier, state.nonterminalEdges[identifier]!!, - curSppfNode) - handleNonterminalEdge(descriptor, ambiguousName, state.nonterminalEdges[ambiguousName]!!, - curSppfNode) - } - 1 -> - { - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.DOT -> - handleTerminal(JavaToken.DOT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, identifier, state.nonterminalEdges[identifier]!!, - curSppfNode) - } - } - } - - private fun parsemethodName(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, identifier, state.nonterminalEdges[identifier]!!, - curSppfNode) - } - 1 -> - { - } - } - } - - private fun parsepackageName(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, identifier, state.nonterminalEdges[identifier]!!, - curSppfNode) - handleNonterminalEdge(descriptor, packageName, state.nonterminalEdges[packageName]!!, - curSppfNode) - } - 1 -> - { - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.DOT -> - handleTerminal(JavaToken.DOT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, identifier, state.nonterminalEdges[identifier]!!, - curSppfNode) - } - } - } - - private fun parseresult(descriptor: Descriptor, curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.VOID -> - handleTerminal(JavaToken.VOID, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, unannType, state.nonterminalEdges[unannType]!!, - curSppfNode) - } - 1 -> - { - } - } - } - - private fun parsepackageDeclaration(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.PACKAGE -> - handleTerminal(JavaToken.PACKAGE, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, packageModifier, - state.nonterminalEdges[packageModifier]!!, curSppfNode) - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, identifier, state.nonterminalEdges[identifier]!!, - curSppfNode) - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SEMICOLON -> - handleTerminal(JavaToken.SEMICOLON, state, inputEdge, descriptor, curSppfNode) - JavaToken.DOT -> - handleTerminal(JavaToken.DOT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - } - } - } - - private fun parseimportDeclaration(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, singleTypeImportDeclaration, - state.nonterminalEdges[singleTypeImportDeclaration]!!, curSppfNode) - handleNonterminalEdge(descriptor, staticImportOnDemandDeclaration, - state.nonterminalEdges[staticImportOnDemandDeclaration]!!, curSppfNode) - handleNonterminalEdge(descriptor, singleStaticImportDeclaration, - state.nonterminalEdges[singleStaticImportDeclaration]!!, curSppfNode) - handleNonterminalEdge(descriptor, typeImportOnDemandDeclaration, - state.nonterminalEdges[typeImportOnDemandDeclaration]!!, curSppfNode) - } - 1 -> - { - } - } - } - - private fun parsetypeDeclaration(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SEMICOLON -> - handleTerminal(JavaToken.SEMICOLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, interfaceDeclaration, - state.nonterminalEdges[interfaceDeclaration]!!, curSppfNode) - handleNonterminalEdge(descriptor, classDeclaration, - state.nonterminalEdges[classDeclaration]!!, curSppfNode) - } - 1 -> - { - } - } - } - - private fun parsepackageModifier(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, annotation, state.nonterminalEdges[annotation]!!, - curSppfNode) - } - 1 -> - { - } - } - } - - private fun parsesingleTypeImportDeclaration(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.IMPORT -> - handleTerminal(JavaToken.IMPORT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, typeName, state.nonterminalEdges[typeName]!!, curSppfNode) - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SEMICOLON -> - handleTerminal(JavaToken.SEMICOLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - } - } - } - - private fun parsetypeImportOnDemandDeclaration(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.IMPORT -> - handleTerminal(JavaToken.IMPORT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, packageOrTypeName, - state.nonterminalEdges[packageOrTypeName]!!, curSppfNode) - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.DOT -> - handleTerminal(JavaToken.DOT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.MULT -> - handleTerminal(JavaToken.MULT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 4 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SEMICOLON -> - handleTerminal(JavaToken.SEMICOLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 5 -> - { - } - } - } - - private fun parsesingleStaticImportDeclaration(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.IMPORT -> - handleTerminal(JavaToken.IMPORT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.STATIC -> - handleTerminal(JavaToken.STATIC, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 2 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, typeName, state.nonterminalEdges[typeName]!!, curSppfNode) - } - 3 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.DOT -> - handleTerminal(JavaToken.DOT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 4 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, identifier, state.nonterminalEdges[identifier]!!, - curSppfNode) - } - 5 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SEMICOLON -> - handleTerminal(JavaToken.SEMICOLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 6 -> - { - } - } - } - - private fun parsestaticImportOnDemandDeclaration(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.IMPORT -> - handleTerminal(JavaToken.IMPORT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.STATIC -> - handleTerminal(JavaToken.STATIC, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 2 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, typeName, state.nonterminalEdges[typeName]!!, curSppfNode) - } - 3 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.DOT -> - handleTerminal(JavaToken.DOT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 4 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.MULT -> - handleTerminal(JavaToken.MULT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 5 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SEMICOLON -> - handleTerminal(JavaToken.SEMICOLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 6 -> - { - } - } - } - - private fun parseclassDeclaration(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, enumDeclaration, - state.nonterminalEdges[enumDeclaration]!!, curSppfNode) - handleNonterminalEdge(descriptor, normalClassDeclaration, - state.nonterminalEdges[normalClassDeclaration]!!, curSppfNode) - } - 1 -> - { - } - } - } - - private fun parseinterfaceDeclaration(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, annotationTypeDeclaration, - state.nonterminalEdges[annotationTypeDeclaration]!!, curSppfNode) - handleNonterminalEdge(descriptor, normalInterfaceDeclaration, - state.nonterminalEdges[normalInterfaceDeclaration]!!, curSppfNode) - } - 1 -> - { - } - } - } - - private fun parsethrows(descriptor: Descriptor, curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.THROWS -> - handleTerminal(JavaToken.THROWS, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, exceptionTypeList, - state.nonterminalEdges[exceptionTypeList]!!, curSppfNode) - } - 2 -> - { - } - } - } - - private fun parsenormalClassDeclaration(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.CLASS -> - handleTerminal(JavaToken.CLASS, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, classModifier, state.nonterminalEdges[classModifier]!!, - curSppfNode) - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, identifier, state.nonterminalEdges[identifier]!!, - curSppfNode) - } - 2 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, superinterfaces, - state.nonterminalEdges[superinterfaces]!!, curSppfNode) - handleNonterminalEdge(descriptor, superclass, state.nonterminalEdges[superclass]!!, - curSppfNode) - handleNonterminalEdge(descriptor, classBody, state.nonterminalEdges[classBody]!!, - curSppfNode) - handleNonterminalEdge(descriptor, typeParameters, state.nonterminalEdges[typeParameters]!!, - curSppfNode) - } - 3 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, superinterfaces, - state.nonterminalEdges[superinterfaces]!!, curSppfNode) - handleNonterminalEdge(descriptor, superclass, state.nonterminalEdges[superclass]!!, - curSppfNode) - handleNonterminalEdge(descriptor, classBody, state.nonterminalEdges[classBody]!!, - curSppfNode) - } - 4 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, superinterfaces, - state.nonterminalEdges[superinterfaces]!!, curSppfNode) - handleNonterminalEdge(descriptor, classBody, state.nonterminalEdges[classBody]!!, - curSppfNode) - } - 5 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, classBody, state.nonterminalEdges[classBody]!!, - curSppfNode) - } - 6 -> - { - } - } - } - - private fun parseenumDeclaration(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.ENUM -> - handleTerminal(JavaToken.ENUM, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, classModifier, state.nonterminalEdges[classModifier]!!, - curSppfNode) - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, identifier, state.nonterminalEdges[identifier]!!, - curSppfNode) - } - 2 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, superinterfaces, - state.nonterminalEdges[superinterfaces]!!, curSppfNode) - handleNonterminalEdge(descriptor, enumBody, state.nonterminalEdges[enumBody]!!, curSppfNode) - } - 3 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, enumBody, state.nonterminalEdges[enumBody]!!, curSppfNode) - } - 4 -> - { - } - } - } - - private fun parseclassModifier(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.STATIC -> - handleTerminal(JavaToken.STATIC, state, inputEdge, descriptor, curSppfNode) - JavaToken.PUBLIC -> - handleTerminal(JavaToken.PUBLIC, state, inputEdge, descriptor, curSppfNode) - JavaToken.ABSTRACT -> - handleTerminal(JavaToken.ABSTRACT, state, inputEdge, descriptor, curSppfNode) - JavaToken.FINAL -> - handleTerminal(JavaToken.FINAL, state, inputEdge, descriptor, curSppfNode) - JavaToken.STRICTFP -> - handleTerminal(JavaToken.STRICTFP, state, inputEdge, descriptor, curSppfNode) - JavaToken.PROTECTED -> - handleTerminal(JavaToken.PROTECTED, state, inputEdge, descriptor, curSppfNode) - JavaToken.PRIVATE -> - handleTerminal(JavaToken.PRIVATE, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, annotation, state.nonterminalEdges[annotation]!!, - curSppfNode) - } - 1 -> - { - } - } - } - - private fun parsetypeParameters(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.LT -> - handleTerminal(JavaToken.LT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, typeParameterList, - state.nonterminalEdges[typeParameterList]!!, curSppfNode) - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.GT -> - handleTerminal(JavaToken.GT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - } - } - } - - private fun parsesuperclass(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.EXTENDS -> - handleTerminal(JavaToken.EXTENDS, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, classType, state.nonterminalEdges[classType]!!, - curSppfNode) - } - 2 -> - { - } - } - } - - private fun parsesuperinterfaces(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.IMPLEMENTS -> - handleTerminal(JavaToken.IMPLEMENTS, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, interfaceTypeList, - state.nonterminalEdges[interfaceTypeList]!!, curSppfNode) - } - 2 -> - { - } - } - } - - private fun parseclassBody(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.LBRACE -> - handleTerminal(JavaToken.LBRACE, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RBRACE -> - handleTerminal(JavaToken.RBRACE, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, classBodyDeclaration, - state.nonterminalEdges[classBodyDeclaration]!!, curSppfNode) - } - 2 -> - { - } - } - } - - private fun parsetypeParameterList(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, typeParameter, state.nonterminalEdges[typeParameter]!!, - curSppfNode) - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.COMMA -> - handleTerminal(JavaToken.COMMA, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - } - } - - private fun parseinterfaceTypeList(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, interfaceType, state.nonterminalEdges[interfaceType]!!, - curSppfNode) - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.COMMA -> - handleTerminal(JavaToken.COMMA, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - } - } - - private fun parseclassBodyDeclaration(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, classMemberDeclaration, - state.nonterminalEdges[classMemberDeclaration]!!, curSppfNode) - handleNonterminalEdge(descriptor, staticInitializer, - state.nonterminalEdges[staticInitializer]!!, curSppfNode) - handleNonterminalEdge(descriptor, instanceInitializer, - state.nonterminalEdges[instanceInitializer]!!, curSppfNode) - handleNonterminalEdge(descriptor, constructorDeclaration, - state.nonterminalEdges[constructorDeclaration]!!, curSppfNode) - } - 1 -> - { - } - } - } - - private fun parseclassMemberDeclaration(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SEMICOLON -> - handleTerminal(JavaToken.SEMICOLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, methodDeclaration, - state.nonterminalEdges[methodDeclaration]!!, curSppfNode) - handleNonterminalEdge(descriptor, interfaceDeclaration, - state.nonterminalEdges[interfaceDeclaration]!!, curSppfNode) - handleNonterminalEdge(descriptor, fieldDeclaration, - state.nonterminalEdges[fieldDeclaration]!!, curSppfNode) - handleNonterminalEdge(descriptor, classDeclaration, - state.nonterminalEdges[classDeclaration]!!, curSppfNode) - } - 1 -> - { - } - } - } - - private fun parseinstanceInitializer(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, block, state.nonterminalEdges[block]!!, curSppfNode) - } - 1 -> - { - } - } - } - - private fun parsestaticInitializer(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.STATIC -> - handleTerminal(JavaToken.STATIC, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, block, state.nonterminalEdges[block]!!, curSppfNode) - } - 2 -> - { - } - } - } - - private fun parseconstructorDeclaration(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, constructorDeclarator, - state.nonterminalEdges[constructorDeclarator]!!, curSppfNode) - handleNonterminalEdge(descriptor, constructorModifier, - state.nonterminalEdges[constructorModifier]!!, curSppfNode) - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, throws, state.nonterminalEdges[throws]!!, curSppfNode) - handleNonterminalEdge(descriptor, constructorBody, - state.nonterminalEdges[constructorBody]!!, curSppfNode) - } - 2 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, constructorBody, - state.nonterminalEdges[constructorBody]!!, curSppfNode) - } - 3 -> - { - } - } - } - - private fun parsefieldDeclaration(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, fieldModifier, state.nonterminalEdges[fieldModifier]!!, - curSppfNode) - handleNonterminalEdge(descriptor, unannType, state.nonterminalEdges[unannType]!!, - curSppfNode) - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, variableDeclaratorList, - state.nonterminalEdges[variableDeclaratorList]!!, curSppfNode) - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SEMICOLON -> - handleTerminal(JavaToken.SEMICOLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - } - } - } - - private fun parsemethodDeclaration(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, methodHeader, state.nonterminalEdges[methodHeader]!!, - curSppfNode) - handleNonterminalEdge(descriptor, methodModifier, state.nonterminalEdges[methodModifier]!!, - curSppfNode) - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, methodBody, state.nonterminalEdges[methodBody]!!, - curSppfNode) - } - 2 -> - { - } - } - } - - private fun parsefieldModifier(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.TRANSIENT -> - handleTerminal(JavaToken.TRANSIENT, state, inputEdge, descriptor, curSppfNode) - JavaToken.VOLATILE -> - handleTerminal(JavaToken.VOLATILE, state, inputEdge, descriptor, curSppfNode) - JavaToken.STATIC -> - handleTerminal(JavaToken.STATIC, state, inputEdge, descriptor, curSppfNode) - JavaToken.PUBLIC -> - handleTerminal(JavaToken.PUBLIC, state, inputEdge, descriptor, curSppfNode) - JavaToken.FINAL -> - handleTerminal(JavaToken.FINAL, state, inputEdge, descriptor, curSppfNode) - JavaToken.PROTECTED -> - handleTerminal(JavaToken.PROTECTED, state, inputEdge, descriptor, curSppfNode) - JavaToken.PRIVATE -> - handleTerminal(JavaToken.PRIVATE, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, annotation, state.nonterminalEdges[annotation]!!, - curSppfNode) - } - 1 -> - { - } - } - } - - private fun parseunannType(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, unannReferenceType, - state.nonterminalEdges[unannReferenceType]!!, curSppfNode) - handleNonterminalEdge(descriptor, unannPrimitiveType, - state.nonterminalEdges[unannPrimitiveType]!!, curSppfNode) - } - 1 -> - { - } - } - } - - private fun parsevariableDeclaratorList(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, variableDeclarator, - state.nonterminalEdges[variableDeclarator]!!, curSppfNode) - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.COMMA -> - handleTerminal(JavaToken.COMMA, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - } - } - - private fun parsevariableDeclarator(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, variableDeclaratorId, - state.nonterminalEdges[variableDeclaratorId]!!, curSppfNode) - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.EQ -> - handleTerminal(JavaToken.EQ, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 2 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, variableInitializer, - state.nonterminalEdges[variableInitializer]!!, curSppfNode) - } - 3 -> - { - } - } - } - - private fun parsevariableDeclaratorId(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, identifier, state.nonterminalEdges[identifier]!!, - curSppfNode) - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, dims, state.nonterminalEdges[dims]!!, curSppfNode) - } - 2 -> - { - } - } - } - - private fun parsevariableInitializer(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, expression, state.nonterminalEdges[expression]!!, - curSppfNode) - handleNonterminalEdge(descriptor, arrayInitializer, - state.nonterminalEdges[arrayInitializer]!!, curSppfNode) - } - 1 -> - { - } - } - } - - private fun parseexpression(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, lambdaExpression, - state.nonterminalEdges[lambdaExpression]!!, curSppfNode) - handleNonterminalEdge(descriptor, assignmentExpression, - state.nonterminalEdges[assignmentExpression]!!, curSppfNode) - } - 1 -> - { - } - } - } - - private fun parsearrayInitializer(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.LBRACE -> - handleTerminal(JavaToken.LBRACE, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.COMMA -> - handleTerminal(JavaToken.COMMA, state, inputEdge, descriptor, curSppfNode) - JavaToken.RBRACE -> - handleTerminal(JavaToken.RBRACE, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, variableInitializerList, - state.nonterminalEdges[variableInitializerList]!!, curSppfNode) - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.COMMA -> - handleTerminal(JavaToken.COMMA, state, inputEdge, descriptor, curSppfNode) - JavaToken.RBRACE -> - handleTerminal(JavaToken.RBRACE, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RBRACE -> - handleTerminal(JavaToken.RBRACE, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 4 -> - { - } - } - } - - private fun parseunannPrimitiveType(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.BOOLEAN -> - handleTerminal(JavaToken.BOOLEAN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, numericType, state.nonterminalEdges[numericType]!!, - curSppfNode) - } - 1 -> - { - } - } - } - - private fun parseunannReferenceType(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, unannTypeVariable, - state.nonterminalEdges[unannTypeVariable]!!, curSppfNode) - handleNonterminalEdge(descriptor, unannArrayType, state.nonterminalEdges[unannArrayType]!!, - curSppfNode) - handleNonterminalEdge(descriptor, unannClassOrInterfaceType, - state.nonterminalEdges[unannClassOrInterfaceType]!!, curSppfNode) - } - 1 -> - { - } - } - } - - private fun parseunannClassOrInterfaceType(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, unannClassType, state.nonterminalEdges[unannClassType]!!, - curSppfNode) - handleNonterminalEdge(descriptor, unannInterfaceType, - state.nonterminalEdges[unannInterfaceType]!!, curSppfNode) - } - 1 -> - { - } - } - } - - private fun parseunannTypeVariable(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, identifier, state.nonterminalEdges[identifier]!!, - curSppfNode) - } - 1 -> - { - } - } - } - - private fun parseunannArrayType(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, unannTypeVariable, - state.nonterminalEdges[unannTypeVariable]!!, curSppfNode) - handleNonterminalEdge(descriptor, unannPrimitiveType, - state.nonterminalEdges[unannPrimitiveType]!!, curSppfNode) - handleNonterminalEdge(descriptor, unannClassOrInterfaceType, - state.nonterminalEdges[unannClassOrInterfaceType]!!, curSppfNode) - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, dims, state.nonterminalEdges[dims]!!, curSppfNode) - } - 2 -> - { - } - } - } - - private fun parseunannClassType(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, identifier, state.nonterminalEdges[identifier]!!, - curSppfNode) - handleNonterminalEdge(descriptor, unannClassOrInterfaceType, - state.nonterminalEdges[unannClassOrInterfaceType]!!, curSppfNode) - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, typeArguments, state.nonterminalEdges[typeArguments]!!, - curSppfNode) - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.DOT -> - handleTerminal(JavaToken.DOT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, annotation, state.nonterminalEdges[annotation]!!, - curSppfNode) - handleNonterminalEdge(descriptor, identifier, state.nonterminalEdges[identifier]!!, - curSppfNode) - } - 4 -> - { - } - } - } - - private fun parseunannInterfaceType(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, unannClassType, state.nonterminalEdges[unannClassType]!!, - curSppfNode) - } - 1 -> - { - } - } - } - - private fun parsemethodModifier(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.NATIVE -> - handleTerminal(JavaToken.NATIVE, state, inputEdge, descriptor, curSppfNode) - JavaToken.STATIC -> - handleTerminal(JavaToken.STATIC, state, inputEdge, descriptor, curSppfNode) - JavaToken.PUBLIC -> - handleTerminal(JavaToken.PUBLIC, state, inputEdge, descriptor, curSppfNode) - JavaToken.ABSTRACT -> - handleTerminal(JavaToken.ABSTRACT, state, inputEdge, descriptor, curSppfNode) - JavaToken.FINAL -> - handleTerminal(JavaToken.FINAL, state, inputEdge, descriptor, curSppfNode) - JavaToken.SYNCHRONIZED -> - handleTerminal(JavaToken.SYNCHRONIZED, state, inputEdge, descriptor, curSppfNode) - JavaToken.STRICTFP -> - handleTerminal(JavaToken.STRICTFP, state, inputEdge, descriptor, curSppfNode) - JavaToken.PROTECTED -> - handleTerminal(JavaToken.PROTECTED, state, inputEdge, descriptor, curSppfNode) - JavaToken.PRIVATE -> - handleTerminal(JavaToken.PRIVATE, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, annotation, state.nonterminalEdges[annotation]!!, - curSppfNode) - } - 1 -> - { - } - } - } - - private fun parsemethodHeader(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, result, state.nonterminalEdges[result]!!, curSppfNode) - handleNonterminalEdge(descriptor, typeParameters, state.nonterminalEdges[typeParameters]!!, - curSppfNode) - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, methodDeclarator, - state.nonterminalEdges[methodDeclarator]!!, curSppfNode) - } - 2 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, result, state.nonterminalEdges[result]!!, curSppfNode) - handleNonterminalEdge(descriptor, annotation, state.nonterminalEdges[annotation]!!, - curSppfNode) - } - 3 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, throws, state.nonterminalEdges[throws]!!, curSppfNode) - } - 4 -> - { - } - } - } - - private fun parsemethodBody(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SEMICOLON -> - handleTerminal(JavaToken.SEMICOLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, block, state.nonterminalEdges[block]!!, curSppfNode) - } - 1 -> - { - } - } - } - - private fun parsemethodDeclarator(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, identifier, state.nonterminalEdges[identifier]!!, - curSppfNode) - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.LPAREN -> - handleTerminal(JavaToken.LPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RPAREN -> - handleTerminal(JavaToken.RPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, formalParameterList, - state.nonterminalEdges[formalParameterList]!!, curSppfNode) - } - 3 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RPAREN -> - handleTerminal(JavaToken.RPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 4 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, dims, state.nonterminalEdges[dims]!!, curSppfNode) - } - 5 -> - { - } - } - } - - private fun parseformalParameterList(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, receiverParameter, - state.nonterminalEdges[receiverParameter]!!, curSppfNode) - handleNonterminalEdge(descriptor, formalParameters, - state.nonterminalEdges[formalParameters]!!, curSppfNode) - handleNonterminalEdge(descriptor, lastFormalParameter, - state.nonterminalEdges[lastFormalParameter]!!, curSppfNode) - } - 1 -> - { - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.COMMA -> - handleTerminal(JavaToken.COMMA, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, lastFormalParameter, - state.nonterminalEdges[lastFormalParameter]!!, curSppfNode) - } - } - } - - private fun parsereceiverParameter(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, annotation, state.nonterminalEdges[annotation]!!, - curSppfNode) - handleNonterminalEdge(descriptor, unannType, state.nonterminalEdges[unannType]!!, - curSppfNode) - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.THIS -> - handleTerminal(JavaToken.THIS, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, identifier, state.nonterminalEdges[identifier]!!, - curSppfNode) - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.DOT -> - handleTerminal(JavaToken.DOT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - } - 4 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.THIS -> - handleTerminal(JavaToken.THIS, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - } - } - - private fun parseformalParameters(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, receiverParameter, - state.nonterminalEdges[receiverParameter]!!, curSppfNode) - handleNonterminalEdge(descriptor, formalParameter, - state.nonterminalEdges[formalParameter]!!, curSppfNode) - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.COMMA -> - handleTerminal(JavaToken.COMMA, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 2 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, formalParameter, - state.nonterminalEdges[formalParameter]!!, curSppfNode) - } - } - } - - private fun parselastFormalParameter(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, variableModifier, - state.nonterminalEdges[variableModifier]!!, curSppfNode) - handleNonterminalEdge(descriptor, unannType, state.nonterminalEdges[unannType]!!, - curSppfNode) - handleNonterminalEdge(descriptor, formalParameter, - state.nonterminalEdges[formalParameter]!!, curSppfNode) - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, variableModifier, - state.nonterminalEdges[variableModifier]!!, curSppfNode) - handleNonterminalEdge(descriptor, unannType, state.nonterminalEdges[unannType]!!, - curSppfNode) - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.ELLIPSIS -> - handleTerminal(JavaToken.ELLIPSIS, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, annotation, state.nonterminalEdges[annotation]!!, - curSppfNode) - } - 3 -> - { - } - 4 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, variableDeclaratorId, - state.nonterminalEdges[variableDeclaratorId]!!, curSppfNode) - } - } - } - - private fun parseformalParameter(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, variableModifier, - state.nonterminalEdges[variableModifier]!!, curSppfNode) - handleNonterminalEdge(descriptor, unannType, state.nonterminalEdges[unannType]!!, - curSppfNode) - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, variableDeclaratorId, - state.nonterminalEdges[variableDeclaratorId]!!, curSppfNode) - } - 2 -> - { - } - } - } - - private fun parsevariableModifier(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.FINAL -> - handleTerminal(JavaToken.FINAL, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, annotation, state.nonterminalEdges[annotation]!!, - curSppfNode) - } - 1 -> - { - } - } - } - - private fun parseexceptionTypeList(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, exceptionType, state.nonterminalEdges[exceptionType]!!, - curSppfNode) - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.COMMA -> - handleTerminal(JavaToken.COMMA, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - } - } - - private fun parseexceptionType(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, typeVariable, state.nonterminalEdges[typeVariable]!!, - curSppfNode) - handleNonterminalEdge(descriptor, classType, state.nonterminalEdges[classType]!!, - curSppfNode) - } - 1 -> - { - } - } - } - - private fun parseblock(descriptor: Descriptor, curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.LBRACE -> - handleTerminal(JavaToken.LBRACE, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RBRACE -> - handleTerminal(JavaToken.RBRACE, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, blockStatements, - state.nonterminalEdges[blockStatements]!!, curSppfNode) - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RBRACE -> - handleTerminal(JavaToken.RBRACE, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - } - } - } - - private fun parseconstructorModifier(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.PUBLIC -> - handleTerminal(JavaToken.PUBLIC, state, inputEdge, descriptor, curSppfNode) - JavaToken.PROTECTED -> - handleTerminal(JavaToken.PROTECTED, state, inputEdge, descriptor, curSppfNode) - JavaToken.PRIVATE -> - handleTerminal(JavaToken.PRIVATE, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, annotation, state.nonterminalEdges[annotation]!!, - curSppfNode) - } - 1 -> - { - } - } - } - - private fun parseconstructorDeclarator(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, simpleTypeName, state.nonterminalEdges[simpleTypeName]!!, - curSppfNode) - handleNonterminalEdge(descriptor, typeParameters, state.nonterminalEdges[typeParameters]!!, - curSppfNode) - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, simpleTypeName, state.nonterminalEdges[simpleTypeName]!!, - curSppfNode) - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.LPAREN -> - handleTerminal(JavaToken.LPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RPAREN -> - handleTerminal(JavaToken.RPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, formalParameterList, - state.nonterminalEdges[formalParameterList]!!, curSppfNode) - } - 4 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RPAREN -> - handleTerminal(JavaToken.RPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 5 -> - { - } - } - } - - private fun parseconstructorBody(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.LBRACE -> - handleTerminal(JavaToken.LBRACE, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RBRACE -> - handleTerminal(JavaToken.RBRACE, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, blockStatements, - state.nonterminalEdges[blockStatements]!!, curSppfNode) - handleNonterminalEdge(descriptor, explicitConstructorInvocation, - state.nonterminalEdges[explicitConstructorInvocation]!!, curSppfNode) - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RBRACE -> - handleTerminal(JavaToken.RBRACE, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, blockStatements, - state.nonterminalEdges[blockStatements]!!, curSppfNode) - } - 3 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RBRACE -> - handleTerminal(JavaToken.RBRACE, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 4 -> - { - } - } - } - - private fun parsesimpleTypeName(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, identifier, state.nonterminalEdges[identifier]!!, - curSppfNode) - } - 1 -> - { - } - } - } - - private fun parseexplicitConstructorInvocation(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.THIS -> - handleTerminal(JavaToken.THIS, state, inputEdge, descriptor, curSppfNode) - JavaToken.SUPER -> - handleTerminal(JavaToken.SUPER, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, typeArguments, state.nonterminalEdges[typeArguments]!!, - curSppfNode) - handleNonterminalEdge(descriptor, expressionName, state.nonterminalEdges[expressionName]!!, - curSppfNode) - handleNonterminalEdge(descriptor, primary, state.nonterminalEdges[primary]!!, curSppfNode) - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.THIS -> - handleTerminal(JavaToken.THIS, state, inputEdge, descriptor, curSppfNode) - JavaToken.SUPER -> - handleTerminal(JavaToken.SUPER, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.LPAREN -> - handleTerminal(JavaToken.LPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.DOT -> - handleTerminal(JavaToken.DOT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 4 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SUPER -> - handleTerminal(JavaToken.SUPER, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, typeArguments, state.nonterminalEdges[typeArguments]!!, - curSppfNode) - } - 5 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SUPER -> - handleTerminal(JavaToken.SUPER, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 6 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RPAREN -> - handleTerminal(JavaToken.RPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, argumentList, state.nonterminalEdges[argumentList]!!, - curSppfNode) - } - 7 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RPAREN -> - handleTerminal(JavaToken.RPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 8 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SEMICOLON -> - handleTerminal(JavaToken.SEMICOLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 9 -> - { - } - } - } - - private fun parseenumBody(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.LBRACE -> - handleTerminal(JavaToken.LBRACE, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.COMMA -> - handleTerminal(JavaToken.COMMA, state, inputEdge, descriptor, curSppfNode) - JavaToken.RBRACE -> - handleTerminal(JavaToken.RBRACE, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, enumConstantList, - state.nonterminalEdges[enumConstantList]!!, curSppfNode) - handleNonterminalEdge(descriptor, enumBodyDeclarations, - state.nonterminalEdges[enumBodyDeclarations]!!, curSppfNode) - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.COMMA -> - handleTerminal(JavaToken.COMMA, state, inputEdge, descriptor, curSppfNode) - JavaToken.RBRACE -> - handleTerminal(JavaToken.RBRACE, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, enumBodyDeclarations, - state.nonterminalEdges[enumBodyDeclarations]!!, curSppfNode) - } - 3 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RBRACE -> - handleTerminal(JavaToken.RBRACE, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, enumBodyDeclarations, - state.nonterminalEdges[enumBodyDeclarations]!!, curSppfNode) - } - 4 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RBRACE -> - handleTerminal(JavaToken.RBRACE, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 5 -> - { - } - } - } - - private fun parseenumConstantList(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, enumConstant, state.nonterminalEdges[enumConstant]!!, - curSppfNode) - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.COMMA -> - handleTerminal(JavaToken.COMMA, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - } - } - - private fun parseenumConstant(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, identifier, state.nonterminalEdges[identifier]!!, - curSppfNode) - handleNonterminalEdge(descriptor, enumConstantModifier, - state.nonterminalEdges[enumConstantModifier]!!, curSppfNode) - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.LPAREN -> - handleTerminal(JavaToken.LPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RPAREN -> - handleTerminal(JavaToken.RPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, argumentList, state.nonterminalEdges[argumentList]!!, - curSppfNode) - } - 3 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RPAREN -> - handleTerminal(JavaToken.RPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 4 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, classBody, state.nonterminalEdges[classBody]!!, - curSppfNode) - } - 5 -> - { - } - } - } - - private fun parseenumConstantModifier(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, annotation, state.nonterminalEdges[annotation]!!, - curSppfNode) - } - 1 -> - { - } - } - } - - private fun parseenumBodyDeclarations(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SEMICOLON -> - handleTerminal(JavaToken.SEMICOLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, classBodyDeclaration, - state.nonterminalEdges[classBodyDeclaration]!!, curSppfNode) - } - } - } - - private fun parseblockStatements(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, blockStatement, state.nonterminalEdges[blockStatement]!!, - curSppfNode) - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, blockStatement, state.nonterminalEdges[blockStatement]!!, - curSppfNode) - } - } - } - - private fun parseargumentList(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, expression, state.nonterminalEdges[expression]!!, - curSppfNode) - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.COMMA -> - handleTerminal(JavaToken.COMMA, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - } - } - - private fun parseprimary(descriptor: Descriptor, curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, primaryNoNewArray, - state.nonterminalEdges[primaryNoNewArray]!!, curSppfNode) - handleNonterminalEdge(descriptor, arrayCreationExpression, - state.nonterminalEdges[arrayCreationExpression]!!, curSppfNode) - } - 1 -> - { - } - } - } - - private fun parsenormalInterfaceDeclaration(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.INTERFACE -> - handleTerminal(JavaToken.INTERFACE, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, interfaceModifier, - state.nonterminalEdges[interfaceModifier]!!, curSppfNode) - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, identifier, state.nonterminalEdges[identifier]!!, - curSppfNode) - } - 2 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, interfaceBody, state.nonterminalEdges[interfaceBody]!!, - curSppfNode) - handleNonterminalEdge(descriptor, extendsInterfaces, - state.nonterminalEdges[extendsInterfaces]!!, curSppfNode) - handleNonterminalEdge(descriptor, typeParameters, state.nonterminalEdges[typeParameters]!!, - curSppfNode) - } - 3 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, interfaceBody, state.nonterminalEdges[interfaceBody]!!, - curSppfNode) - handleNonterminalEdge(descriptor, extendsInterfaces, - state.nonterminalEdges[extendsInterfaces]!!, curSppfNode) - } - 4 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, interfaceBody, state.nonterminalEdges[interfaceBody]!!, - curSppfNode) - } - 5 -> - { - } - } - } - - private fun parseinterfaceModifier(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.STATIC -> - handleTerminal(JavaToken.STATIC, state, inputEdge, descriptor, curSppfNode) - JavaToken.PUBLIC -> - handleTerminal(JavaToken.PUBLIC, state, inputEdge, descriptor, curSppfNode) - JavaToken.ABSTRACT -> - handleTerminal(JavaToken.ABSTRACT, state, inputEdge, descriptor, curSppfNode) - JavaToken.STRICTFP -> - handleTerminal(JavaToken.STRICTFP, state, inputEdge, descriptor, curSppfNode) - JavaToken.PROTECTED -> - handleTerminal(JavaToken.PROTECTED, state, inputEdge, descriptor, curSppfNode) - JavaToken.PRIVATE -> - handleTerminal(JavaToken.PRIVATE, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, annotation, state.nonterminalEdges[annotation]!!, - curSppfNode) - } - 1 -> - { - } - } - } - - private fun parseextendsInterfaces(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.EXTENDS -> - handleTerminal(JavaToken.EXTENDS, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, interfaceTypeList, - state.nonterminalEdges[interfaceTypeList]!!, curSppfNode) - } - 2 -> - { - } - } - } - - private fun parseinterfaceBody(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.LBRACE -> - handleTerminal(JavaToken.LBRACE, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RBRACE -> - handleTerminal(JavaToken.RBRACE, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, interfaceMemberDeclaration, - state.nonterminalEdges[interfaceMemberDeclaration]!!, curSppfNode) - } - 2 -> - { - } - } - } - - private fun parseinterfaceMemberDeclaration(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SEMICOLON -> - handleTerminal(JavaToken.SEMICOLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, interfaceDeclaration, - state.nonterminalEdges[interfaceDeclaration]!!, curSppfNode) - handleNonterminalEdge(descriptor, constantDeclaration, - state.nonterminalEdges[constantDeclaration]!!, curSppfNode) - handleNonterminalEdge(descriptor, interfaceMethodDeclaration, - state.nonterminalEdges[interfaceMethodDeclaration]!!, curSppfNode) - handleNonterminalEdge(descriptor, classDeclaration, - state.nonterminalEdges[classDeclaration]!!, curSppfNode) - } - 1 -> - { - } - } - } - - private fun parseconstantDeclaration(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, constantModifier, - state.nonterminalEdges[constantModifier]!!, curSppfNode) - handleNonterminalEdge(descriptor, unannType, state.nonterminalEdges[unannType]!!, - curSppfNode) - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, variableDeclaratorList, - state.nonterminalEdges[variableDeclaratorList]!!, curSppfNode) - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SEMICOLON -> - handleTerminal(JavaToken.SEMICOLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - } - } - } - - private fun parseconstantModifier(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.STATIC -> - handleTerminal(JavaToken.STATIC, state, inputEdge, descriptor, curSppfNode) - JavaToken.PUBLIC -> - handleTerminal(JavaToken.PUBLIC, state, inputEdge, descriptor, curSppfNode) - JavaToken.FINAL -> - handleTerminal(JavaToken.FINAL, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, annotation, state.nonterminalEdges[annotation]!!, - curSppfNode) - } - 1 -> - { - } - } - } - - private fun parseannotationTypeDeclaration(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.AT -> - handleTerminal(JavaToken.AT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, interfaceModifier, - state.nonterminalEdges[interfaceModifier]!!, curSppfNode) - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.INTERFACE -> - handleTerminal(JavaToken.INTERFACE, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 2 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, identifier, state.nonterminalEdges[identifier]!!, - curSppfNode) - } - 3 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, annotationTypeBody, - state.nonterminalEdges[annotationTypeBody]!!, curSppfNode) - } - 4 -> - { - } - } - } - - private fun parseannotationTypeBody(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.LBRACE -> - handleTerminal(JavaToken.LBRACE, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RBRACE -> - handleTerminal(JavaToken.RBRACE, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, annotationTypeMemberDeclaration, - state.nonterminalEdges[annotationTypeMemberDeclaration]!!, curSppfNode) - } - 2 -> - { - } - } - } - - private fun parseannotationTypeMemberDeclaration(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SEMICOLON -> - handleTerminal(JavaToken.SEMICOLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, interfaceDeclaration, - state.nonterminalEdges[interfaceDeclaration]!!, curSppfNode) - handleNonterminalEdge(descriptor, annotationTypeElementDeclaration, - state.nonterminalEdges[annotationTypeElementDeclaration]!!, curSppfNode) - handleNonterminalEdge(descriptor, constantDeclaration, - state.nonterminalEdges[constantDeclaration]!!, curSppfNode) - handleNonterminalEdge(descriptor, classDeclaration, - state.nonterminalEdges[classDeclaration]!!, curSppfNode) - } - 1 -> - { - } - } - } - - private fun parseannotationTypeElementDeclaration(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, annotationTypeElementModifier, - state.nonterminalEdges[annotationTypeElementModifier]!!, curSppfNode) - handleNonterminalEdge(descriptor, unannType, state.nonterminalEdges[unannType]!!, - curSppfNode) - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, identifier, state.nonterminalEdges[identifier]!!, - curSppfNode) - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.LPAREN -> - handleTerminal(JavaToken.LPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RPAREN -> - handleTerminal(JavaToken.RPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 4 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SEMICOLON -> - handleTerminal(JavaToken.SEMICOLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, dims, state.nonterminalEdges[dims]!!, curSppfNode) - handleNonterminalEdge(descriptor, defaultValue, state.nonterminalEdges[defaultValue]!!, - curSppfNode) - } - 5 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SEMICOLON -> - handleTerminal(JavaToken.SEMICOLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, defaultValue, state.nonterminalEdges[defaultValue]!!, - curSppfNode) - } - 6 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SEMICOLON -> - handleTerminal(JavaToken.SEMICOLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 7 -> - { - } - } - } - - private fun parsedefaultValue(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.DEFAULT -> - handleTerminal(JavaToken.DEFAULT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, elementValue, state.nonterminalEdges[elementValue]!!, - curSppfNode) - } - 2 -> - { - } - } - } - - private fun parsenormalAnnotation(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.AT -> - handleTerminal(JavaToken.AT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, typeName, state.nonterminalEdges[typeName]!!, curSppfNode) - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.LPAREN -> - handleTerminal(JavaToken.LPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RPAREN -> - handleTerminal(JavaToken.RPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, elementValuePairList, - state.nonterminalEdges[elementValuePairList]!!, curSppfNode) - } - 4 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RPAREN -> - handleTerminal(JavaToken.RPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 5 -> - { - } - } - } - - private fun parseelementValuePairList(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, elementValuePair, - state.nonterminalEdges[elementValuePair]!!, curSppfNode) - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.COMMA -> - handleTerminal(JavaToken.COMMA, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - } - } - - private fun parseelementValuePair(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, identifier, state.nonterminalEdges[identifier]!!, - curSppfNode) - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.EQ -> - handleTerminal(JavaToken.EQ, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 2 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, elementValue, state.nonterminalEdges[elementValue]!!, - curSppfNode) - } - 3 -> - { - } - } - } - - private fun parseelementValue(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, annotation, state.nonterminalEdges[annotation]!!, - curSppfNode) - handleNonterminalEdge(descriptor, elementValueArrayInitializer, - state.nonterminalEdges[elementValueArrayInitializer]!!, curSppfNode) - handleNonterminalEdge(descriptor, conditionalExpression, - state.nonterminalEdges[conditionalExpression]!!, curSppfNode) - } - 1 -> - { - } - } - } - - private fun parseelementValueArrayInitializer(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.LBRACE -> - handleTerminal(JavaToken.LBRACE, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.COMMA -> - handleTerminal(JavaToken.COMMA, state, inputEdge, descriptor, curSppfNode) - JavaToken.RBRACE -> - handleTerminal(JavaToken.RBRACE, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, elementValueList, - state.nonterminalEdges[elementValueList]!!, curSppfNode) - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.COMMA -> - handleTerminal(JavaToken.COMMA, state, inputEdge, descriptor, curSppfNode) - JavaToken.RBRACE -> - handleTerminal(JavaToken.RBRACE, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RBRACE -> - handleTerminal(JavaToken.RBRACE, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 4 -> - { - } - } - } - - private fun parseelementValueList(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, elementValue, state.nonterminalEdges[elementValue]!!, - curSppfNode) - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.COMMA -> - handleTerminal(JavaToken.COMMA, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - } - } - - private fun parsemarkerAnnotation(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.AT -> - handleTerminal(JavaToken.AT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, typeName, state.nonterminalEdges[typeName]!!, curSppfNode) - } - 2 -> - { - } - } - } - - private fun parsesingleElementAnnotation(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.AT -> - handleTerminal(JavaToken.AT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, typeName, state.nonterminalEdges[typeName]!!, curSppfNode) - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.LPAREN -> - handleTerminal(JavaToken.LPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, elementValue, state.nonterminalEdges[elementValue]!!, - curSppfNode) - } - 4 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RPAREN -> - handleTerminal(JavaToken.RPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 5 -> - { - } - } - } - - private fun parseinterfaceMethodDeclaration(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, methodHeader, state.nonterminalEdges[methodHeader]!!, - curSppfNode) - handleNonterminalEdge(descriptor, interfaceMethodModifier, - state.nonterminalEdges[interfaceMethodModifier]!!, curSppfNode) - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, methodBody, state.nonterminalEdges[methodBody]!!, - curSppfNode) - } - 2 -> - { - } - } - } - - private fun parseannotationTypeElementModifier(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.PUBLIC -> - handleTerminal(JavaToken.PUBLIC, state, inputEdge, descriptor, curSppfNode) - JavaToken.ABSTRACT -> - handleTerminal(JavaToken.ABSTRACT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, annotation, state.nonterminalEdges[annotation]!!, - curSppfNode) - } - 1 -> - { - } - } - } - - private fun parseconditionalExpression(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, conditionalOrExpression, - state.nonterminalEdges[conditionalOrExpression]!!, curSppfNode) - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.QUESTION -> - handleTerminal(JavaToken.QUESTION, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 2 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, expression, state.nonterminalEdges[expression]!!, - curSppfNode) - } - 3 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.COLON -> - handleTerminal(JavaToken.COLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 4 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, lambdaExpression, - state.nonterminalEdges[lambdaExpression]!!, curSppfNode) - handleNonterminalEdge(descriptor, conditionalExpression, - state.nonterminalEdges[conditionalExpression]!!, curSppfNode) - } - 5 -> - { - } - } - } - - private fun parsevariableInitializerList(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, variableInitializer, - state.nonterminalEdges[variableInitializer]!!, curSppfNode) - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.COMMA -> - handleTerminal(JavaToken.COMMA, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - } - } - - private fun parseblockStatement(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, localVariableDeclarationStatement, - state.nonterminalEdges[localVariableDeclarationStatement]!!, curSppfNode) - handleNonterminalEdge(descriptor, statement, state.nonterminalEdges[statement]!!, - curSppfNode) - handleNonterminalEdge(descriptor, classDeclaration, - state.nonterminalEdges[classDeclaration]!!, curSppfNode) - } - 1 -> - { - } - } - } - - private fun parselocalVariableDeclarationStatement(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, localVariableDeclaration, - state.nonterminalEdges[localVariableDeclaration]!!, curSppfNode) - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SEMICOLON -> - handleTerminal(JavaToken.SEMICOLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 2 -> - { - } - } - } - - private fun parselocalVariableDeclaration(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, variableModifier, - state.nonterminalEdges[variableModifier]!!, curSppfNode) - handleNonterminalEdge(descriptor, unannType, state.nonterminalEdges[unannType]!!, - curSppfNode) - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, variableDeclaratorList, - state.nonterminalEdges[variableDeclaratorList]!!, curSppfNode) - } - 2 -> - { - } - } - } - - private fun parsestatement(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, whileStatement, state.nonterminalEdges[whileStatement]!!, - curSppfNode) - handleNonterminalEdge(descriptor, labeledStatement, - state.nonterminalEdges[labeledStatement]!!, curSppfNode) - handleNonterminalEdge(descriptor, forStatement, state.nonterminalEdges[forStatement]!!, - curSppfNode) - handleNonterminalEdge(descriptor, statementWithoutTrailingSubstatement, - state.nonterminalEdges[statementWithoutTrailingSubstatement]!!, curSppfNode) - handleNonterminalEdge(descriptor, ifThenElseStatement, - state.nonterminalEdges[ifThenElseStatement]!!, curSppfNode) - handleNonterminalEdge(descriptor, ifThenStatement, - state.nonterminalEdges[ifThenStatement]!!, curSppfNode) - } - 1 -> - { - } - } - } - - private fun parsestatementNoShortIf(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, whileStatementNoShortIf, - state.nonterminalEdges[whileStatementNoShortIf]!!, curSppfNode) - handleNonterminalEdge(descriptor, labeledStatementNoShortIf, - state.nonterminalEdges[labeledStatementNoShortIf]!!, curSppfNode) - handleNonterminalEdge(descriptor, forStatementNoShortIf, - state.nonterminalEdges[forStatementNoShortIf]!!, curSppfNode) - handleNonterminalEdge(descriptor, statementWithoutTrailingSubstatement, - state.nonterminalEdges[statementWithoutTrailingSubstatement]!!, curSppfNode) - handleNonterminalEdge(descriptor, ifThenElseStatementNoShortIf, - state.nonterminalEdges[ifThenElseStatementNoShortIf]!!, curSppfNode) - } - 1 -> - { - } - } - } - - private fun parsestatementWithoutTrailingSubstatement(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, emptyStatement, state.nonterminalEdges[emptyStatement]!!, - curSppfNode) - handleNonterminalEdge(descriptor, tryStatement, state.nonterminalEdges[tryStatement]!!, - curSppfNode) - handleNonterminalEdge(descriptor, doStatement, state.nonterminalEdges[doStatement]!!, - curSppfNode) - handleNonterminalEdge(descriptor, throwStatement, state.nonterminalEdges[throwStatement]!!, - curSppfNode) - handleNonterminalEdge(descriptor, assertStatement, - state.nonterminalEdges[assertStatement]!!, curSppfNode) - handleNonterminalEdge(descriptor, breakStatement, state.nonterminalEdges[breakStatement]!!, - curSppfNode) - handleNonterminalEdge(descriptor, block, state.nonterminalEdges[block]!!, curSppfNode) - handleNonterminalEdge(descriptor, expressionStatement, - state.nonterminalEdges[expressionStatement]!!, curSppfNode) - handleNonterminalEdge(descriptor, continueStatement, - state.nonterminalEdges[continueStatement]!!, curSppfNode) - handleNonterminalEdge(descriptor, returnStatement, - state.nonterminalEdges[returnStatement]!!, curSppfNode) - handleNonterminalEdge(descriptor, switchStatement, - state.nonterminalEdges[switchStatement]!!, curSppfNode) - handleNonterminalEdge(descriptor, synchronizedStatement, - state.nonterminalEdges[synchronizedStatement]!!, curSppfNode) - } - 1 -> - { - } - } - } - - private fun parseemptyStatement(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SEMICOLON -> - handleTerminal(JavaToken.SEMICOLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - } - } - } - - private fun parselabeledStatement(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, identifier, state.nonterminalEdges[identifier]!!, - curSppfNode) - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.COLON -> - handleTerminal(JavaToken.COLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 2 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, statement, state.nonterminalEdges[statement]!!, - curSppfNode) - } - 3 -> - { - } - } - } - - private fun parselabeledStatementNoShortIf(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, identifier, state.nonterminalEdges[identifier]!!, - curSppfNode) - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.COLON -> - handleTerminal(JavaToken.COLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 2 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, statementNoShortIf, - state.nonterminalEdges[statementNoShortIf]!!, curSppfNode) - } - 3 -> - { - } - } - } - - private fun parseexpressionStatement(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, statementExpression, - state.nonterminalEdges[statementExpression]!!, curSppfNode) - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SEMICOLON -> - handleTerminal(JavaToken.SEMICOLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 2 -> - { - } - } - } - - private fun parsestatementExpression(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, classInstanceCreationExpression, - state.nonterminalEdges[classInstanceCreationExpression]!!, curSppfNode) - handleNonterminalEdge(descriptor, assignment, state.nonterminalEdges[assignment]!!, - curSppfNode) - handleNonterminalEdge(descriptor, methodInvocation, - state.nonterminalEdges[methodInvocation]!!, curSppfNode) - handleNonterminalEdge(descriptor, preDecrementExpression, - state.nonterminalEdges[preDecrementExpression]!!, curSppfNode) - handleNonterminalEdge(descriptor, preIncrementExpression, - state.nonterminalEdges[preIncrementExpression]!!, curSppfNode) - handleNonterminalEdge(descriptor, postIncrementExpression, - state.nonterminalEdges[postIncrementExpression]!!, curSppfNode) - handleNonterminalEdge(descriptor, postDecrementExpression, - state.nonterminalEdges[postDecrementExpression]!!, curSppfNode) - } - 1 -> - { - } - } - } - - private fun parseifThenStatement(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.IF -> - handleTerminal(JavaToken.IF, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.LPAREN -> - handleTerminal(JavaToken.LPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 2 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, expression, state.nonterminalEdges[expression]!!, - curSppfNode) - } - 3 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RPAREN -> - handleTerminal(JavaToken.RPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 4 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, statement, state.nonterminalEdges[statement]!!, - curSppfNode) - } - 5 -> - { - } - } - } - - private fun parseifThenElseStatement(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.IF -> - handleTerminal(JavaToken.IF, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.LPAREN -> - handleTerminal(JavaToken.LPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 2 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, expression, state.nonterminalEdges[expression]!!, - curSppfNode) - } - 3 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RPAREN -> - handleTerminal(JavaToken.RPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 4 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, statementNoShortIf, - state.nonterminalEdges[statementNoShortIf]!!, curSppfNode) - } - 5 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.ELSE -> - handleTerminal(JavaToken.ELSE, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 6 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, statement, state.nonterminalEdges[statement]!!, - curSppfNode) - } - 7 -> - { - } - } - } - - private fun parseifThenElseStatementNoShortIf(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.IF -> - handleTerminal(JavaToken.IF, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.LPAREN -> - handleTerminal(JavaToken.LPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 2 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, expression, state.nonterminalEdges[expression]!!, - curSppfNode) - } - 3 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RPAREN -> - handleTerminal(JavaToken.RPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 4 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, statementNoShortIf, - state.nonterminalEdges[statementNoShortIf]!!, curSppfNode) - } - 5 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.ELSE -> - handleTerminal(JavaToken.ELSE, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 6 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, statementNoShortIf, - state.nonterminalEdges[statementNoShortIf]!!, curSppfNode) - } - 7 -> - { - } - } - } - - private fun parseassertStatement(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.ASSERT -> - handleTerminal(JavaToken.ASSERT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, expression, state.nonterminalEdges[expression]!!, - curSppfNode) - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SEMICOLON -> - handleTerminal(JavaToken.SEMICOLON, state, inputEdge, descriptor, curSppfNode) - JavaToken.COLON -> - handleTerminal(JavaToken.COLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - } - 4 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, expression, state.nonterminalEdges[expression]!!, - curSppfNode) - } - 5 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SEMICOLON -> - handleTerminal(JavaToken.SEMICOLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - } - } - - private fun parseswitchStatement(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SWITCH -> - handleTerminal(JavaToken.SWITCH, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.LPAREN -> - handleTerminal(JavaToken.LPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 2 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, expression, state.nonterminalEdges[expression]!!, - curSppfNode) - } - 3 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RPAREN -> - handleTerminal(JavaToken.RPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 4 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, switchBlock, state.nonterminalEdges[switchBlock]!!, - curSppfNode) - } - 5 -> - { - } - } - } - - private fun parseswitchBlock(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.LBRACE -> - handleTerminal(JavaToken.LBRACE, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RBRACE -> - handleTerminal(JavaToken.RBRACE, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, switchBlockStatementGroup, - state.nonterminalEdges[switchBlockStatementGroup]!!, curSppfNode) - handleNonterminalEdge(descriptor, switchLabel, state.nonterminalEdges[switchLabel]!!, - curSppfNode) - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RBRACE -> - handleTerminal(JavaToken.RBRACE, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, switchLabel, state.nonterminalEdges[switchLabel]!!, - curSppfNode) - } - 3 -> - { - } - } - } - - private fun parseswitchBlockStatementGroup(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, switchLabels, state.nonterminalEdges[switchLabels]!!, - curSppfNode) - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, blockStatements, - state.nonterminalEdges[blockStatements]!!, curSppfNode) - } - 2 -> - { - } - } - } - - private fun parseswitchLabels(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, switchLabel, state.nonterminalEdges[switchLabel]!!, - curSppfNode) - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, switchLabel, state.nonterminalEdges[switchLabel]!!, - curSppfNode) - } - } - } - - private fun parseswitchLabel(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.CASE -> - handleTerminal(JavaToken.CASE, state, inputEdge, descriptor, curSppfNode) - JavaToken.DEFAULT -> - handleTerminal(JavaToken.DEFAULT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, enumConstantName, - state.nonterminalEdges[enumConstantName]!!, curSppfNode) - handleNonterminalEdge(descriptor, constantExpression, - state.nonterminalEdges[constantExpression]!!, curSppfNode) - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.COLON -> - handleTerminal(JavaToken.COLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - } - } - } - - private fun parseenumConstantName(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, identifier, state.nonterminalEdges[identifier]!!, - curSppfNode) - } - 1 -> - { - } - } - } - - private fun parsewhileStatement(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.WHILE -> - handleTerminal(JavaToken.WHILE, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.LPAREN -> - handleTerminal(JavaToken.LPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 2 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, expression, state.nonterminalEdges[expression]!!, - curSppfNode) - } - 3 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RPAREN -> - handleTerminal(JavaToken.RPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 4 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, statement, state.nonterminalEdges[statement]!!, - curSppfNode) - } - 5 -> - { - } - } - } - - private fun parsewhileStatementNoShortIf(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.WHILE -> - handleTerminal(JavaToken.WHILE, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.LPAREN -> - handleTerminal(JavaToken.LPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 2 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, expression, state.nonterminalEdges[expression]!!, - curSppfNode) - } - 3 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RPAREN -> - handleTerminal(JavaToken.RPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 4 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, statementNoShortIf, - state.nonterminalEdges[statementNoShortIf]!!, curSppfNode) - } - 5 -> - { - } - } - } - - private fun parsedoStatement(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.DO -> - handleTerminal(JavaToken.DO, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, statement, state.nonterminalEdges[statement]!!, - curSppfNode) - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.WHILE -> - handleTerminal(JavaToken.WHILE, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.LPAREN -> - handleTerminal(JavaToken.LPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 4 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, expression, state.nonterminalEdges[expression]!!, - curSppfNode) - } - 5 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RPAREN -> - handleTerminal(JavaToken.RPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 6 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SEMICOLON -> - handleTerminal(JavaToken.SEMICOLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 7 -> - { - } - } - } - - private fun parseinterfaceMethodModifier(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.DEFAULT -> - handleTerminal(JavaToken.DEFAULT, state, inputEdge, descriptor, curSppfNode) - JavaToken.STATIC -> - handleTerminal(JavaToken.STATIC, state, inputEdge, descriptor, curSppfNode) - JavaToken.PUBLIC -> - handleTerminal(JavaToken.PUBLIC, state, inputEdge, descriptor, curSppfNode) - JavaToken.ABSTRACT -> - handleTerminal(JavaToken.ABSTRACT, state, inputEdge, descriptor, curSppfNode) - JavaToken.STRICTFP -> - handleTerminal(JavaToken.STRICTFP, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, annotation, state.nonterminalEdges[annotation]!!, - curSppfNode) - } - 1 -> - { - } - } - } - - private fun parseforStatement(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, enhancedForStatement, - state.nonterminalEdges[enhancedForStatement]!!, curSppfNode) - handleNonterminalEdge(descriptor, basicForStatement, - state.nonterminalEdges[basicForStatement]!!, curSppfNode) - } - 1 -> - { - } - } - } - - private fun parseforStatementNoShortIf(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, basicForStatementNoShortIf, - state.nonterminalEdges[basicForStatementNoShortIf]!!, curSppfNode) - handleNonterminalEdge(descriptor, enhancedForStatementNoShortIf, - state.nonterminalEdges[enhancedForStatementNoShortIf]!!, curSppfNode) - } - 1 -> - { - } - } - } - - private fun parsebasicForStatement(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.FOR -> - handleTerminal(JavaToken.FOR, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.LPAREN -> - handleTerminal(JavaToken.LPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SEMICOLON -> - handleTerminal(JavaToken.SEMICOLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, forInit, state.nonterminalEdges[forInit]!!, curSppfNode) - } - 3 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SEMICOLON -> - handleTerminal(JavaToken.SEMICOLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 4 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SEMICOLON -> - handleTerminal(JavaToken.SEMICOLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, expression, state.nonterminalEdges[expression]!!, - curSppfNode) - } - 5 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RPAREN -> - handleTerminal(JavaToken.RPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, forUpdate, state.nonterminalEdges[forUpdate]!!, - curSppfNode) - } - 6 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SEMICOLON -> - handleTerminal(JavaToken.SEMICOLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 7 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RPAREN -> - handleTerminal(JavaToken.RPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 8 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, statement, state.nonterminalEdges[statement]!!, - curSppfNode) - } - 9 -> - { - } - } - } - - private fun parsebasicForStatementNoShortIf(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.FOR -> - handleTerminal(JavaToken.FOR, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.LPAREN -> - handleTerminal(JavaToken.LPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SEMICOLON -> - handleTerminal(JavaToken.SEMICOLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, forInit, state.nonterminalEdges[forInit]!!, curSppfNode) - } - 3 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SEMICOLON -> - handleTerminal(JavaToken.SEMICOLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 4 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SEMICOLON -> - handleTerminal(JavaToken.SEMICOLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, expression, state.nonterminalEdges[expression]!!, - curSppfNode) - } - 5 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RPAREN -> - handleTerminal(JavaToken.RPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, forUpdate, state.nonterminalEdges[forUpdate]!!, - curSppfNode) - } - 6 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SEMICOLON -> - handleTerminal(JavaToken.SEMICOLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 7 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RPAREN -> - handleTerminal(JavaToken.RPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 8 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, statementNoShortIf, - state.nonterminalEdges[statementNoShortIf]!!, curSppfNode) - } - 9 -> - { - } - } - } - - private fun parseforInit(descriptor: Descriptor, curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, localVariableDeclaration, - state.nonterminalEdges[localVariableDeclaration]!!, curSppfNode) - handleNonterminalEdge(descriptor, statementExpressionList, - state.nonterminalEdges[statementExpressionList]!!, curSppfNode) - } - 1 -> - { - } - } - } - - private fun parseforUpdate(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, statementExpressionList, - state.nonterminalEdges[statementExpressionList]!!, curSppfNode) - } - 1 -> - { - } - } - } - - private fun parsestatementExpressionList(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, statementExpression, - state.nonterminalEdges[statementExpression]!!, curSppfNode) - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.COMMA -> - handleTerminal(JavaToken.COMMA, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - } - } - - private fun parseenhancedForStatement(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.FOR -> - handleTerminal(JavaToken.FOR, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.LPAREN -> - handleTerminal(JavaToken.LPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 2 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, variableModifier, - state.nonterminalEdges[variableModifier]!!, curSppfNode) - handleNonterminalEdge(descriptor, unannType, state.nonterminalEdges[unannType]!!, - curSppfNode) - } - 3 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, variableDeclaratorId, - state.nonterminalEdges[variableDeclaratorId]!!, curSppfNode) - } - 4 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.COLON -> - handleTerminal(JavaToken.COLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 5 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, expression, state.nonterminalEdges[expression]!!, - curSppfNode) - } - 6 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RPAREN -> - handleTerminal(JavaToken.RPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 7 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, statement, state.nonterminalEdges[statement]!!, - curSppfNode) - } - 8 -> - { - } - } - } - - private fun parseenhancedForStatementNoShortIf(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.FOR -> - handleTerminal(JavaToken.FOR, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.LPAREN -> - handleTerminal(JavaToken.LPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 2 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, variableModifier, - state.nonterminalEdges[variableModifier]!!, curSppfNode) - handleNonterminalEdge(descriptor, unannType, state.nonterminalEdges[unannType]!!, - curSppfNode) - } - 3 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, variableDeclaratorId, - state.nonterminalEdges[variableDeclaratorId]!!, curSppfNode) - } - 4 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.COLON -> - handleTerminal(JavaToken.COLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 5 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, expression, state.nonterminalEdges[expression]!!, - curSppfNode) - } - 6 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RPAREN -> - handleTerminal(JavaToken.RPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 7 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, statementNoShortIf, - state.nonterminalEdges[statementNoShortIf]!!, curSppfNode) - } - 8 -> - { - } - } - } - - private fun parsebreakStatement(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.BREAK -> - handleTerminal(JavaToken.BREAK, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SEMICOLON -> - handleTerminal(JavaToken.SEMICOLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, identifier, state.nonterminalEdges[identifier]!!, - curSppfNode) - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SEMICOLON -> - handleTerminal(JavaToken.SEMICOLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - } - } - } - - private fun parsecontinueStatement(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.CONTINUE -> - handleTerminal(JavaToken.CONTINUE, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SEMICOLON -> - handleTerminal(JavaToken.SEMICOLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, identifier, state.nonterminalEdges[identifier]!!, - curSppfNode) - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SEMICOLON -> - handleTerminal(JavaToken.SEMICOLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - } - } - } - - private fun parsereturnStatement(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RETURN -> - handleTerminal(JavaToken.RETURN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SEMICOLON -> - handleTerminal(JavaToken.SEMICOLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, expression, state.nonterminalEdges[expression]!!, - curSppfNode) - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SEMICOLON -> - handleTerminal(JavaToken.SEMICOLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - } - } - } - - private fun parsethrowStatement(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.THROW -> - handleTerminal(JavaToken.THROW, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, expression, state.nonterminalEdges[expression]!!, - curSppfNode) - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SEMICOLON -> - handleTerminal(JavaToken.SEMICOLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - } - } - } - - private fun parsesynchronizedStatement(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SYNCHRONIZED -> - handleTerminal(JavaToken.SYNCHRONIZED, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.LPAREN -> - handleTerminal(JavaToken.LPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 2 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, expression, state.nonterminalEdges[expression]!!, - curSppfNode) - } - 3 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RPAREN -> - handleTerminal(JavaToken.RPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 4 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, block, state.nonterminalEdges[block]!!, curSppfNode) - } - 5 -> - { - } - } - } - - private fun parsetryStatement(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.TRY -> - handleTerminal(JavaToken.TRY, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, tryWithResourcesStatement, - state.nonterminalEdges[tryWithResourcesStatement]!!, curSppfNode) - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, block, state.nonterminalEdges[block]!!, curSppfNode) - } - 2 -> - { - } - 3 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, finally, state.nonterminalEdges[finally]!!, curSppfNode) - handleNonterminalEdge(descriptor, catches, state.nonterminalEdges[catches]!!, curSppfNode) - } - 4 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, finally, state.nonterminalEdges[finally]!!, curSppfNode) - } - } - } - - private fun parsecatches(descriptor: Descriptor, curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, catchClause, state.nonterminalEdges[catchClause]!!, - curSppfNode) - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, catchClause, state.nonterminalEdges[catchClause]!!, - curSppfNode) - } - } - } - - private fun parsecatchClause(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.CATCH -> - handleTerminal(JavaToken.CATCH, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.LPAREN -> - handleTerminal(JavaToken.LPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 2 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, catchFormalParameter, - state.nonterminalEdges[catchFormalParameter]!!, curSppfNode) - } - 3 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RPAREN -> - handleTerminal(JavaToken.RPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 4 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, block, state.nonterminalEdges[block]!!, curSppfNode) - } - 5 -> - { - } - } - } - - private fun parsecatchFormalParameter(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, variableModifier, - state.nonterminalEdges[variableModifier]!!, curSppfNode) - handleNonterminalEdge(descriptor, catchType, state.nonterminalEdges[catchType]!!, - curSppfNode) - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, variableDeclaratorId, - state.nonterminalEdges[variableDeclaratorId]!!, curSppfNode) - } - 2 -> - { - } - } - } - - private fun parsecatchType(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, unannClassType, state.nonterminalEdges[unannClassType]!!, - curSppfNode) - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.OR -> - handleTerminal(JavaToken.OR, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 2 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, classType, state.nonterminalEdges[classType]!!, - curSppfNode) - } - } - } - - private fun parsefinally(descriptor: Descriptor, curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.FINALLY -> - handleTerminal(JavaToken.FINALLY, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, block, state.nonterminalEdges[block]!!, curSppfNode) - } - 2 -> - { - } - } - } - - private fun parsetryWithResourcesStatement(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.TRY -> - handleTerminal(JavaToken.TRY, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, resourceSpecification, - state.nonterminalEdges[resourceSpecification]!!, curSppfNode) - } - 2 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, block, state.nonterminalEdges[block]!!, curSppfNode) - } - 3 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, finally, state.nonterminalEdges[finally]!!, curSppfNode) - handleNonterminalEdge(descriptor, catches, state.nonterminalEdges[catches]!!, curSppfNode) - } - 4 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, finally, state.nonterminalEdges[finally]!!, curSppfNode) - } - 5 -> - { - } - } - } - - private fun parseresourceSpecification(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.LPAREN -> - handleTerminal(JavaToken.LPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, resourceList, state.nonterminalEdges[resourceList]!!, - curSppfNode) - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RPAREN -> - handleTerminal(JavaToken.RPAREN, state, inputEdge, descriptor, curSppfNode) - JavaToken.SEMICOLON -> - handleTerminal(JavaToken.SEMICOLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RPAREN -> - handleTerminal(JavaToken.RPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 4 -> - { - } - } - } - - private fun parseresourceList(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, resource, state.nonterminalEdges[resource]!!, curSppfNode) - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.COMMA -> - handleTerminal(JavaToken.COMMA, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - } - } - - private fun parseresource(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, variableModifier, - state.nonterminalEdges[variableModifier]!!, curSppfNode) - handleNonterminalEdge(descriptor, unannType, state.nonterminalEdges[unannType]!!, - curSppfNode) - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, variableDeclaratorId, - state.nonterminalEdges[variableDeclaratorId]!!, curSppfNode) - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.EQ -> - handleTerminal(JavaToken.EQ, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, expression, state.nonterminalEdges[expression]!!, - curSppfNode) - } - 4 -> - { - } - } - } - - private fun parseprimaryNoNewArray(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.THIS -> - handleTerminal(JavaToken.THIS, state, inputEdge, descriptor, curSppfNode) - JavaToken.LPAREN -> - handleTerminal(JavaToken.LPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, classInstanceCreationExpression, - state.nonterminalEdges[classInstanceCreationExpression]!!, curSppfNode) - handleNonterminalEdge(descriptor, methodInvocation, - state.nonterminalEdges[methodInvocation]!!, curSppfNode) - handleNonterminalEdge(descriptor, fieldAccess, state.nonterminalEdges[fieldAccess]!!, - curSppfNode) - handleNonterminalEdge(descriptor, methodReference, - state.nonterminalEdges[methodReference]!!, curSppfNode) - handleNonterminalEdge(descriptor, classLiteral, state.nonterminalEdges[classLiteral]!!, - curSppfNode) - handleNonterminalEdge(descriptor, typeName, state.nonterminalEdges[typeName]!!, curSppfNode) - handleNonterminalEdge(descriptor, arrayAccess, state.nonterminalEdges[arrayAccess]!!, - curSppfNode) - handleNonterminalEdge(descriptor, literal, state.nonterminalEdges[literal]!!, curSppfNode) - } - 1 -> - { - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.DOT -> - handleTerminal(JavaToken.DOT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, expression, state.nonterminalEdges[expression]!!, - curSppfNode) - } - 4 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RPAREN -> - handleTerminal(JavaToken.RPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 5 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.THIS -> - handleTerminal(JavaToken.THIS, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - } - } - - private fun parseclassLiteral(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.BOOLEAN -> - handleTerminal(JavaToken.BOOLEAN, state, inputEdge, descriptor, curSppfNode) - JavaToken.VOID -> - handleTerminal(JavaToken.VOID, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, typeName, state.nonterminalEdges[typeName]!!, curSppfNode) - handleNonterminalEdge(descriptor, numericType, state.nonterminalEdges[numericType]!!, - curSppfNode) - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.LBRACK -> - handleTerminal(JavaToken.LBRACK, state, inputEdge, descriptor, curSppfNode) - JavaToken.DOT -> - handleTerminal(JavaToken.DOT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.DOT -> - handleTerminal(JavaToken.DOT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.CLASS -> - handleTerminal(JavaToken.CLASS, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 4 -> - { - } - 5 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RBRACK -> - handleTerminal(JavaToken.RBRACK, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - } - } - - private fun parseclassOrInterfaceTypeToInstantiate(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, annotation, state.nonterminalEdges[annotation]!!, - curSppfNode) - handleNonterminalEdge(descriptor, identifier, state.nonterminalEdges[identifier]!!, - curSppfNode) - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.DOT -> - handleTerminal(JavaToken.DOT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, typeArgumentsOrDiamond, - state.nonterminalEdges[typeArgumentsOrDiamond]!!, curSppfNode) - } - 2 -> - { - } - } - } - - private fun parseunqualifiedClassInstanceCreationExpression(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.NEW -> - handleTerminal(JavaToken.NEW, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, typeArguments, state.nonterminalEdges[typeArguments]!!, - curSppfNode) - handleNonterminalEdge(descriptor, classOrInterfaceTypeToInstantiate, - state.nonterminalEdges[classOrInterfaceTypeToInstantiate]!!, curSppfNode) - } - 2 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, classOrInterfaceTypeToInstantiate, - state.nonterminalEdges[classOrInterfaceTypeToInstantiate]!!, curSppfNode) - } - 3 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.LPAREN -> - handleTerminal(JavaToken.LPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 4 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RPAREN -> - handleTerminal(JavaToken.RPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, argumentList, state.nonterminalEdges[argumentList]!!, - curSppfNode) - } - 5 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RPAREN -> - handleTerminal(JavaToken.RPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 6 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, classBody, state.nonterminalEdges[classBody]!!, - curSppfNode) - } - 7 -> - { - } - } - } - - private fun parseclassInstanceCreationExpression(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, expressionName, state.nonterminalEdges[expressionName]!!, - curSppfNode) - handleNonterminalEdge(descriptor, unqualifiedClassInstanceCreationExpression, - state.nonterminalEdges[unqualifiedClassInstanceCreationExpression]!!, curSppfNode) - handleNonterminalEdge(descriptor, primary, state.nonterminalEdges[primary]!!, curSppfNode) - } - 1 -> - { - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.DOT -> - handleTerminal(JavaToken.DOT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, unqualifiedClassInstanceCreationExpression, - state.nonterminalEdges[unqualifiedClassInstanceCreationExpression]!!, curSppfNode) - } - } - } - - private fun parsefieldAccess(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SUPER -> - handleTerminal(JavaToken.SUPER, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, typeName, state.nonterminalEdges[typeName]!!, curSppfNode) - handleNonterminalEdge(descriptor, primary, state.nonterminalEdges[primary]!!, curSppfNode) - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.DOT -> - handleTerminal(JavaToken.DOT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.DOT -> - handleTerminal(JavaToken.DOT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SUPER -> - handleTerminal(JavaToken.SUPER, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 4 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, identifier, state.nonterminalEdges[identifier]!!, - curSppfNode) - } - 5 -> - { - } - } - } - - private fun parsetypeArgumentsOrDiamond(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.LT -> - handleTerminal(JavaToken.LT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, typeArguments, state.nonterminalEdges[typeArguments]!!, - curSppfNode) - } - 1 -> - { - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.GT -> - handleTerminal(JavaToken.GT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - } - } - - private fun parsearrayAccess(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, expressionName, state.nonterminalEdges[expressionName]!!, - curSppfNode) - handleNonterminalEdge(descriptor, primaryNoNewArray, - state.nonterminalEdges[primaryNoNewArray]!!, curSppfNode) - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.LBRACK -> - handleTerminal(JavaToken.LBRACK, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 2 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, expression, state.nonterminalEdges[expression]!!, - curSppfNode) - } - 3 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RBRACK -> - handleTerminal(JavaToken.RBRACK, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 4 -> - { - } - } - } - - private fun parsemethodInvocation(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SUPER -> - handleTerminal(JavaToken.SUPER, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, expressionName, state.nonterminalEdges[expressionName]!!, - curSppfNode) - handleNonterminalEdge(descriptor, typeName, state.nonterminalEdges[typeName]!!, curSppfNode) - handleNonterminalEdge(descriptor, methodName, state.nonterminalEdges[methodName]!!, - curSppfNode) - handleNonterminalEdge(descriptor, primary, state.nonterminalEdges[primary]!!, curSppfNode) - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.LPAREN -> - handleTerminal(JavaToken.LPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.DOT -> - handleTerminal(JavaToken.DOT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.DOT -> - handleTerminal(JavaToken.DOT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 4 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, typeArguments, state.nonterminalEdges[typeArguments]!!, - curSppfNode) - handleNonterminalEdge(descriptor, identifier, state.nonterminalEdges[identifier]!!, - curSppfNode) - } - 5 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, identifier, state.nonterminalEdges[identifier]!!, - curSppfNode) - } - 6 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SUPER -> - handleTerminal(JavaToken.SUPER, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, typeArguments, state.nonterminalEdges[typeArguments]!!, - curSppfNode) - handleNonterminalEdge(descriptor, identifier, state.nonterminalEdges[identifier]!!, - curSppfNode) - } - 7 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RPAREN -> - handleTerminal(JavaToken.RPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, argumentList, state.nonterminalEdges[argumentList]!!, - curSppfNode) - } - 8 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RPAREN -> - handleTerminal(JavaToken.RPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 9 -> - { - } - } - } - - private fun parsemethodReference(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SUPER -> - handleTerminal(JavaToken.SUPER, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, arrayType, state.nonterminalEdges[arrayType]!!, - curSppfNode) - handleNonterminalEdge(descriptor, expressionName, state.nonterminalEdges[expressionName]!!, - curSppfNode) - handleNonterminalEdge(descriptor, typeName, state.nonterminalEdges[typeName]!!, curSppfNode) - handleNonterminalEdge(descriptor, referenceType, state.nonterminalEdges[referenceType]!!, - curSppfNode) - handleNonterminalEdge(descriptor, classType, state.nonterminalEdges[classType]!!, - curSppfNode) - handleNonterminalEdge(descriptor, primary, state.nonterminalEdges[primary]!!, curSppfNode) - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.COLONCOLON -> - handleTerminal(JavaToken.COLONCOLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.DOT -> - handleTerminal(JavaToken.DOT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.COLONCOLON -> - handleTerminal(JavaToken.COLONCOLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 4 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.COLONCOLON -> - handleTerminal(JavaToken.COLONCOLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 5 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.NEW -> - handleTerminal(JavaToken.NEW, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 6 -> - { - } - 7 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.NEW -> - handleTerminal(JavaToken.NEW, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, typeArguments, state.nonterminalEdges[typeArguments]!!, - curSppfNode) - } - 8 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SUPER -> - handleTerminal(JavaToken.SUPER, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 9 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, typeArguments, state.nonterminalEdges[typeArguments]!!, - curSppfNode) - handleNonterminalEdge(descriptor, identifier, state.nonterminalEdges[identifier]!!, - curSppfNode) - } - 10 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, identifier, state.nonterminalEdges[identifier]!!, - curSppfNode) - } - } - } - - private fun parsearrayCreationExpression(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.NEW -> - handleTerminal(JavaToken.NEW, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, classOrInterfaceType, - state.nonterminalEdges[classOrInterfaceType]!!, curSppfNode) - handleNonterminalEdge(descriptor, primitiveType, state.nonterminalEdges[primitiveType]!!, - curSppfNode) - } - 2 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, dims, state.nonterminalEdges[dims]!!, curSppfNode) - handleNonterminalEdge(descriptor, dimExprs, state.nonterminalEdges[dimExprs]!!, curSppfNode) - } - 3 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, dims, state.nonterminalEdges[dims]!!, curSppfNode) - } - 4 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, arrayInitializer, - state.nonterminalEdges[arrayInitializer]!!, curSppfNode) - } - 5 -> - { - } - } - } - - private fun parsedimExprs(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, dimExpr, state.nonterminalEdges[dimExpr]!!, curSppfNode) - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, dimExpr, state.nonterminalEdges[dimExpr]!!, curSppfNode) - } - } - } - - private fun parsedimExpr(descriptor: Descriptor, curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.LBRACK -> - handleTerminal(JavaToken.LBRACK, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, annotation, state.nonterminalEdges[annotation]!!, - curSppfNode) - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, expression, state.nonterminalEdges[expression]!!, - curSppfNode) - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RBRACK -> - handleTerminal(JavaToken.RBRACK, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - } - } - } - - private fun parselambdaExpression(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, lambdaParameters, - state.nonterminalEdges[lambdaParameters]!!, curSppfNode) - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.ARROW -> - handleTerminal(JavaToken.ARROW, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 2 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, lambdaBody, state.nonterminalEdges[lambdaBody]!!, - curSppfNode) - } - 3 -> - { - } - } - } - - private fun parselambdaParameters(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.LPAREN -> - handleTerminal(JavaToken.LPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, identifier, state.nonterminalEdges[identifier]!!, - curSppfNode) - } - 1 -> - { - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RPAREN -> - handleTerminal(JavaToken.RPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, inferredFormalParameterList, - state.nonterminalEdges[inferredFormalParameterList]!!, curSppfNode) - handleNonterminalEdge(descriptor, formalParameterList, - state.nonterminalEdges[formalParameterList]!!, curSppfNode) - } - 3 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RPAREN -> - handleTerminal(JavaToken.RPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - } - } - - private fun parseinferredFormalParameterList(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, identifier, state.nonterminalEdges[identifier]!!, - curSppfNode) - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.COMMA -> - handleTerminal(JavaToken.COMMA, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - } - } - - private fun parselambdaBody(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, expression, state.nonterminalEdges[expression]!!, - curSppfNode) - handleNonterminalEdge(descriptor, block, state.nonterminalEdges[block]!!, curSppfNode) - } - 1 -> - { - } - } - } - - private fun parseassignmentExpression(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, conditionalExpression, - state.nonterminalEdges[conditionalExpression]!!, curSppfNode) - handleNonterminalEdge(descriptor, assignment, state.nonterminalEdges[assignment]!!, - curSppfNode) - } - 1 -> - { - } - } - } - - private fun parseassignment(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, leftHandSide, state.nonterminalEdges[leftHandSide]!!, - curSppfNode) - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, assignmentOperator, - state.nonterminalEdges[assignmentOperator]!!, curSppfNode) - } - 2 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, expression, state.nonterminalEdges[expression]!!, - curSppfNode) - } - 3 -> - { - } - } - } - - private fun parseleftHandSide(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, expressionName, state.nonterminalEdges[expressionName]!!, - curSppfNode) - handleNonterminalEdge(descriptor, fieldAccess, state.nonterminalEdges[fieldAccess]!!, - curSppfNode) - handleNonterminalEdge(descriptor, arrayAccess, state.nonterminalEdges[arrayAccess]!!, - curSppfNode) - } - 1 -> - { - } - } - } - - private fun parseassignmentOperator(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.MODEQ -> - handleTerminal(JavaToken.MODEQ, state, inputEdge, descriptor, curSppfNode) - JavaToken.OREQ -> - handleTerminal(JavaToken.OREQ, state, inputEdge, descriptor, curSppfNode) - JavaToken.MULTEQ -> - handleTerminal(JavaToken.MULTEQ, state, inputEdge, descriptor, curSppfNode) - JavaToken.DIVEQ -> - handleTerminal(JavaToken.DIVEQ, state, inputEdge, descriptor, curSppfNode) - JavaToken.PLUSEQ -> - handleTerminal(JavaToken.PLUSEQ, state, inputEdge, descriptor, curSppfNode) - JavaToken.URSHIFTEQ -> - handleTerminal(JavaToken.URSHIFTEQ, state, inputEdge, descriptor, curSppfNode) - JavaToken.MINUSEQ -> - handleTerminal(JavaToken.MINUSEQ, state, inputEdge, descriptor, curSppfNode) - JavaToken.LSHIFTEQ -> - handleTerminal(JavaToken.LSHIFTEQ, state, inputEdge, descriptor, curSppfNode) - JavaToken.ANDEQ -> - handleTerminal(JavaToken.ANDEQ, state, inputEdge, descriptor, curSppfNode) - JavaToken.EQ -> - handleTerminal(JavaToken.EQ, state, inputEdge, descriptor, curSppfNode) - JavaToken.RSHIFTEQ -> - handleTerminal(JavaToken.RSHIFTEQ, state, inputEdge, descriptor, curSppfNode) - JavaToken.XOREQ -> - handleTerminal(JavaToken.XOREQ, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - } - } - } - - private fun parseconditionalOrExpression(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, conditionalOrExpression, - state.nonterminalEdges[conditionalOrExpression]!!, curSppfNode) - handleNonterminalEdge(descriptor, conditionalAndExpression, - state.nonterminalEdges[conditionalAndExpression]!!, curSppfNode) - } - 1 -> - { - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.OROR -> - handleTerminal(JavaToken.OROR, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, conditionalAndExpression, - state.nonterminalEdges[conditionalAndExpression]!!, curSppfNode) - } - } - } - - private fun parseconditionalAndExpression(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, inclusiveOrExpression, - state.nonterminalEdges[inclusiveOrExpression]!!, curSppfNode) - handleNonterminalEdge(descriptor, conditionalAndExpression, - state.nonterminalEdges[conditionalAndExpression]!!, curSppfNode) - } - 1 -> - { - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.ANDAND -> - handleTerminal(JavaToken.ANDAND, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, inclusiveOrExpression, - state.nonterminalEdges[inclusiveOrExpression]!!, curSppfNode) - } - } - } - - private fun parseinclusiveOrExpression(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, exclusiveOrExpression, - state.nonterminalEdges[exclusiveOrExpression]!!, curSppfNode) - handleNonterminalEdge(descriptor, inclusiveOrExpression, - state.nonterminalEdges[inclusiveOrExpression]!!, curSppfNode) - } - 1 -> - { - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.OR -> - handleTerminal(JavaToken.OR, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, exclusiveOrExpression, - state.nonterminalEdges[exclusiveOrExpression]!!, curSppfNode) - } - } - } - - private fun parseexclusiveOrExpression(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, andExpression, state.nonterminalEdges[andExpression]!!, - curSppfNode) - handleNonterminalEdge(descriptor, exclusiveOrExpression, - state.nonterminalEdges[exclusiveOrExpression]!!, curSppfNode) - } - 1 -> - { - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.XOR -> - handleTerminal(JavaToken.XOR, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, andExpression, state.nonterminalEdges[andExpression]!!, - curSppfNode) - } - } - } - - private fun parseandExpression(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, andExpression, state.nonterminalEdges[andExpression]!!, - curSppfNode) - handleNonterminalEdge(descriptor, equalityExpression, - state.nonterminalEdges[equalityExpression]!!, curSppfNode) - } - 1 -> - { - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.AND -> - handleTerminal(JavaToken.AND, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, equalityExpression, - state.nonterminalEdges[equalityExpression]!!, curSppfNode) - } - } - } - - private fun parseequalityExpression(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, relationalExpression, - state.nonterminalEdges[relationalExpression]!!, curSppfNode) - handleNonterminalEdge(descriptor, equalityExpression, - state.nonterminalEdges[equalityExpression]!!, curSppfNode) - } - 1 -> - { - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.EQEQ -> - handleTerminal(JavaToken.EQEQ, state, inputEdge, descriptor, curSppfNode) - JavaToken.NOTEQ -> - handleTerminal(JavaToken.NOTEQ, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, relationalExpression, - state.nonterminalEdges[relationalExpression]!!, curSppfNode) - } - } - } - - private fun parserelationalExpression(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, shiftExpression, - state.nonterminalEdges[shiftExpression]!!, curSppfNode) - handleNonterminalEdge(descriptor, relationalExpression, - state.nonterminalEdges[relationalExpression]!!, curSppfNode) - } - 1 -> - { - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.LTEQ -> - handleTerminal(JavaToken.LTEQ, state, inputEdge, descriptor, curSppfNode) - JavaToken.INSTANCEOF -> - handleTerminal(JavaToken.INSTANCEOF, state, inputEdge, descriptor, curSppfNode) - JavaToken.GTEQ -> - handleTerminal(JavaToken.GTEQ, state, inputEdge, descriptor, curSppfNode) - JavaToken.GT -> - handleTerminal(JavaToken.GT, state, inputEdge, descriptor, curSppfNode) - JavaToken.LT -> - handleTerminal(JavaToken.LT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, shiftExpression, - state.nonterminalEdges[shiftExpression]!!, curSppfNode) - } - 4 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, referenceType, state.nonterminalEdges[referenceType]!!, - curSppfNode) - } - } - } - - private fun parseshiftExpression(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, shiftExpression, - state.nonterminalEdges[shiftExpression]!!, curSppfNode) - handleNonterminalEdge(descriptor, additiveExpression, - state.nonterminalEdges[additiveExpression]!!, curSppfNode) - } - 1 -> - { - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.GT -> - handleTerminal(JavaToken.GT, state, inputEdge, descriptor, curSppfNode) - JavaToken.LT -> - handleTerminal(JavaToken.LT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.LT -> - handleTerminal(JavaToken.LT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 4 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.GT -> - handleTerminal(JavaToken.GT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 5 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.GT -> - handleTerminal(JavaToken.GT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, additiveExpression, - state.nonterminalEdges[additiveExpression]!!, curSppfNode) - } - 6 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, additiveExpression, - state.nonterminalEdges[additiveExpression]!!, curSppfNode) - } - } - } - - private fun parseadditiveExpression(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, additiveExpression, - state.nonterminalEdges[additiveExpression]!!, curSppfNode) - handleNonterminalEdge(descriptor, multiplicativeExpression, - state.nonterminalEdges[multiplicativeExpression]!!, curSppfNode) - } - 1 -> - { - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.PLUS -> - handleTerminal(JavaToken.PLUS, state, inputEdge, descriptor, curSppfNode) - JavaToken.MINUS -> - handleTerminal(JavaToken.MINUS, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, multiplicativeExpression, - state.nonterminalEdges[multiplicativeExpression]!!, curSppfNode) - } - } - } - - private fun parsemultiplicativeExpression(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, multiplicativeExpression, - state.nonterminalEdges[multiplicativeExpression]!!, curSppfNode) - handleNonterminalEdge(descriptor, unaryExpression, - state.nonterminalEdges[unaryExpression]!!, curSppfNode) - } - 1 -> - { - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.DIV -> - handleTerminal(JavaToken.DIV, state, inputEdge, descriptor, curSppfNode) - JavaToken.MOD -> - handleTerminal(JavaToken.MOD, state, inputEdge, descriptor, curSppfNode) - JavaToken.MULT -> - handleTerminal(JavaToken.MULT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, unaryExpression, - state.nonterminalEdges[unaryExpression]!!, curSppfNode) - } - } - } - - private fun parsepreIncrementExpression(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.PLUSPLUS -> - handleTerminal(JavaToken.PLUSPLUS, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, unaryExpression, - state.nonterminalEdges[unaryExpression]!!, curSppfNode) - } - 2 -> - { - } - } - } - - private fun parsepreDecrementExpression(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.MINUSMINUS -> - handleTerminal(JavaToken.MINUSMINUS, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, unaryExpression, - state.nonterminalEdges[unaryExpression]!!, curSppfNode) - } - 2 -> - { - } - } - } - - private fun parseunaryExpressionNotPlusMinus(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.NOT -> - handleTerminal(JavaToken.NOT, state, inputEdge, descriptor, curSppfNode) - JavaToken.COMP -> - handleTerminal(JavaToken.COMP, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, castExpression, state.nonterminalEdges[castExpression]!!, - curSppfNode) - handleNonterminalEdge(descriptor, postfixExpression, - state.nonterminalEdges[postfixExpression]!!, curSppfNode) - } - 1 -> - { - } - 2 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, unaryExpression, - state.nonterminalEdges[unaryExpression]!!, curSppfNode) - } - } - } - - private fun parseunaryExpression(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.PLUS -> - handleTerminal(JavaToken.PLUS, state, inputEdge, descriptor, curSppfNode) - JavaToken.MINUS -> - handleTerminal(JavaToken.MINUS, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, unaryExpressionNotPlusMinus, - state.nonterminalEdges[unaryExpressionNotPlusMinus]!!, curSppfNode) - handleNonterminalEdge(descriptor, preDecrementExpression, - state.nonterminalEdges[preDecrementExpression]!!, curSppfNode) - handleNonterminalEdge(descriptor, preIncrementExpression, - state.nonterminalEdges[preIncrementExpression]!!, curSppfNode) - } - 1 -> - { - } - 2 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, unaryExpression, - state.nonterminalEdges[unaryExpression]!!, curSppfNode) - } - } - } - - private fun parsepostfixExpression(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, expressionName, state.nonterminalEdges[expressionName]!!, - curSppfNode) - handleNonterminalEdge(descriptor, postIncrementExpression, - state.nonterminalEdges[postIncrementExpression]!!, curSppfNode) - handleNonterminalEdge(descriptor, postDecrementExpression, - state.nonterminalEdges[postDecrementExpression]!!, curSppfNode) - handleNonterminalEdge(descriptor, primary, state.nonterminalEdges[primary]!!, curSppfNode) - } - 1 -> - { - } - } - } - - private fun parsepostIncrementExpression(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, postfixExpression, - state.nonterminalEdges[postfixExpression]!!, curSppfNode) - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.PLUSPLUS -> - handleTerminal(JavaToken.PLUSPLUS, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 2 -> - { - } - } - } - - private fun parsepostDecrementExpression(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, postfixExpression, - state.nonterminalEdges[postfixExpression]!!, curSppfNode) - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.MINUSMINUS -> - handleTerminal(JavaToken.MINUSMINUS, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 2 -> - { - } - } - } - - private fun parsecastExpression(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.LPAREN -> - handleTerminal(JavaToken.LPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, referenceType, state.nonterminalEdges[referenceType]!!, - curSppfNode) - handleNonterminalEdge(descriptor, primitiveType, state.nonterminalEdges[primitiveType]!!, - curSppfNode) - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RPAREN -> - handleTerminal(JavaToken.RPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RPAREN -> - handleTerminal(JavaToken.RPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, additionalBound, - state.nonterminalEdges[additionalBound]!!, curSppfNode) - } - 4 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, unaryExpressionNotPlusMinus, - state.nonterminalEdges[unaryExpressionNotPlusMinus]!!, curSppfNode) - handleNonterminalEdge(descriptor, lambdaExpression, - state.nonterminalEdges[lambdaExpression]!!, curSppfNode) - } - 5 -> - { - } - 6 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, unaryExpression, - state.nonterminalEdges[unaryExpression]!!, curSppfNode) - } - } - } - - private fun parseconstantExpression(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, expression, state.nonterminalEdges[expression]!!, - curSppfNode) - } - 1 -> - { - } - } - } - - override fun setInput(`value`: IInputGraph) { - ctx = org.ucfs.parser.context.Context(grammar.rsm, value) - } -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/Java8ParserRecovery.kt b/benchmarks/src/main/kotlin/org/ucfs/Java8ParserRecovery.kt deleted file mode 100644 index 15a29e389..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/Java8ParserRecovery.kt +++ /dev/null @@ -1,8659 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs - -import org.ucfs.descriptors.Descriptor -import org.ucfs.input.IInputGraph -import org.ucfs.input.ILabel -import org.ucfs.parser.GeneratedParser -import org.ucfs.rsm.symbol.Nonterminal -import org.ucfs.sppf.node.SppfNode - -public class Java8ParserRecovery : - GeneratedParser() { - public val grammar: Java8 = Java8() - - private val compilationUnit: Nonterminal = grammar.compilationUnit.nonterm - - private val identifier: Nonterminal = grammar.identifier.nonterm - - private val literal: Nonterminal = grammar.literal.nonterm - - private val type: Nonterminal = grammar.type.nonterm - - private val primitiveType: Nonterminal = grammar.primitiveType.nonterm - - private val referenceType: Nonterminal = grammar.referenceType.nonterm - - private val `annotation`: Nonterminal = grammar.annotation.nonterm - - private val numericType: Nonterminal = grammar.numericType.nonterm - - private val integralType: Nonterminal = grammar.integralType.nonterm - - private val floatingPointType: Nonterminal = grammar.floatingPointType.nonterm - - private val classOrInterfaceType: Nonterminal = grammar.classOrInterfaceType.nonterm - - private val typeVariable: Nonterminal = grammar.typeVariable.nonterm - - private val arrayType: Nonterminal = grammar.arrayType.nonterm - - private val classType: Nonterminal = grammar.classType.nonterm - - private val interfaceType: Nonterminal = grammar.interfaceType.nonterm - - private val typeArguments: Nonterminal = grammar.typeArguments.nonterm - - private val dims: Nonterminal = grammar.dims.nonterm - - private val typeParameter: Nonterminal = grammar.typeParameter.nonterm - - private val typeParameterModifier: Nonterminal = grammar.typeParameterModifier.nonterm - - private val typeBound: Nonterminal = grammar.typeBound.nonterm - - private val additionalBound: Nonterminal = grammar.additionalBound.nonterm - - private val typeArgumentList: Nonterminal = grammar.typeArgumentList.nonterm - - private val typeArgument: Nonterminal = grammar.typeArgument.nonterm - - private val wildcard: Nonterminal = grammar.wildcard.nonterm - - private val wildcardBounds: Nonterminal = grammar.wildcardBounds.nonterm - - private val typeName: Nonterminal = grammar.typeName.nonterm - - private val packageOrTypeName: Nonterminal = grammar.packageOrTypeName.nonterm - - private val expressionName: Nonterminal = grammar.expressionName.nonterm - - private val ambiguousName: Nonterminal = grammar.ambiguousName.nonterm - - private val methodName: Nonterminal = grammar.methodName.nonterm - - private val packageName: Nonterminal = grammar.packageName.nonterm - - private val result: Nonterminal = grammar.result.nonterm - - private val packageDeclaration: Nonterminal = grammar.packageDeclaration.nonterm - - private val importDeclaration: Nonterminal = grammar.importDeclaration.nonterm - - private val typeDeclaration: Nonterminal = grammar.typeDeclaration.nonterm - - private val packageModifier: Nonterminal = grammar.packageModifier.nonterm - - private val singleTypeImportDeclaration: Nonterminal = grammar.singleTypeImportDeclaration.nonterm - - private val typeImportOnDemandDeclaration: Nonterminal = - grammar.typeImportOnDemandDeclaration.nonterm - - private val singleStaticImportDeclaration: Nonterminal = - grammar.singleStaticImportDeclaration.nonterm - - private val staticImportOnDemandDeclaration: Nonterminal = - grammar.staticImportOnDemandDeclaration.nonterm - - private val classDeclaration: Nonterminal = grammar.classDeclaration.nonterm - - private val interfaceDeclaration: Nonterminal = grammar.interfaceDeclaration.nonterm - - private val throws: Nonterminal = grammar.throws.nonterm - - private val normalClassDeclaration: Nonterminal = grammar.normalClassDeclaration.nonterm - - private val enumDeclaration: Nonterminal = grammar.enumDeclaration.nonterm - - private val classModifier: Nonterminal = grammar.classModifier.nonterm - - private val typeParameters: Nonterminal = grammar.typeParameters.nonterm - - private val superclass: Nonterminal = grammar.superclass.nonterm - - private val superinterfaces: Nonterminal = grammar.superinterfaces.nonterm - - private val classBody: Nonterminal = grammar.classBody.nonterm - - private val typeParameterList: Nonterminal = grammar.typeParameterList.nonterm - - private val interfaceTypeList: Nonterminal = grammar.interfaceTypeList.nonterm - - private val classBodyDeclaration: Nonterminal = grammar.classBodyDeclaration.nonterm - - private val classMemberDeclaration: Nonterminal = grammar.classMemberDeclaration.nonterm - - private val instanceInitializer: Nonterminal = grammar.instanceInitializer.nonterm - - private val staticInitializer: Nonterminal = grammar.staticInitializer.nonterm - - private val constructorDeclaration: Nonterminal = grammar.constructorDeclaration.nonterm - - private val fieldDeclaration: Nonterminal = grammar.fieldDeclaration.nonterm - - private val methodDeclaration: Nonterminal = grammar.methodDeclaration.nonterm - - private val fieldModifier: Nonterminal = grammar.fieldModifier.nonterm - - private val unannType: Nonterminal = grammar.unannType.nonterm - - private val variableDeclaratorList: Nonterminal = grammar.variableDeclaratorList.nonterm - - private val variableDeclarator: Nonterminal = grammar.variableDeclarator.nonterm - - private val variableDeclaratorId: Nonterminal = grammar.variableDeclaratorId.nonterm - - private val variableInitializer: Nonterminal = grammar.variableInitializer.nonterm - - private val expression: Nonterminal = grammar.expression.nonterm - - private val arrayInitializer: Nonterminal = grammar.arrayInitializer.nonterm - - private val unannPrimitiveType: Nonterminal = grammar.unannPrimitiveType.nonterm - - private val unannReferenceType: Nonterminal = grammar.unannReferenceType.nonterm - - private val unannClassOrInterfaceType: Nonterminal = grammar.unannClassOrInterfaceType.nonterm - - private val unannTypeVariable: Nonterminal = grammar.unannTypeVariable.nonterm - - private val unannArrayType: Nonterminal = grammar.unannArrayType.nonterm - - private val unannClassType: Nonterminal = grammar.unannClassType.nonterm - - private val unannInterfaceType: Nonterminal = grammar.unannInterfaceType.nonterm - - private val methodModifier: Nonterminal = grammar.methodModifier.nonterm - - private val methodHeader: Nonterminal = grammar.methodHeader.nonterm - - private val methodBody: Nonterminal = grammar.methodBody.nonterm - - private val methodDeclarator: Nonterminal = grammar.methodDeclarator.nonterm - - private val formalParameterList: Nonterminal = grammar.formalParameterList.nonterm - - private val receiverParameter: Nonterminal = grammar.receiverParameter.nonterm - - private val formalParameters: Nonterminal = grammar.formalParameters.nonterm - - private val lastFormalParameter: Nonterminal = grammar.lastFormalParameter.nonterm - - private val formalParameter: Nonterminal = grammar.formalParameter.nonterm - - private val variableModifier: Nonterminal = grammar.variableModifier.nonterm - - private val exceptionTypeList: Nonterminal = grammar.exceptionTypeList.nonterm - - private val exceptionType: Nonterminal = grammar.exceptionType.nonterm - - private val block: Nonterminal = grammar.block.nonterm - - private val constructorModifier: Nonterminal = grammar.constructorModifier.nonterm - - private val constructorDeclarator: Nonterminal = grammar.constructorDeclarator.nonterm - - private val constructorBody: Nonterminal = grammar.constructorBody.nonterm - - private val simpleTypeName: Nonterminal = grammar.simpleTypeName.nonterm - - private val explicitConstructorInvocation: Nonterminal = - grammar.explicitConstructorInvocation.nonterm - - private val enumBody: Nonterminal = grammar.enumBody.nonterm - - private val enumConstantList: Nonterminal = grammar.enumConstantList.nonterm - - private val enumConstant: Nonterminal = grammar.enumConstant.nonterm - - private val enumConstantModifier: Nonterminal = grammar.enumConstantModifier.nonterm - - private val enumBodyDeclarations: Nonterminal = grammar.enumBodyDeclarations.nonterm - - private val blockStatements: Nonterminal = grammar.blockStatements.nonterm - - private val argumentList: Nonterminal = grammar.argumentList.nonterm - - private val primary: Nonterminal = grammar.primary.nonterm - - private val normalInterfaceDeclaration: Nonterminal = grammar.normalInterfaceDeclaration.nonterm - - private val interfaceModifier: Nonterminal = grammar.interfaceModifier.nonterm - - private val extendsInterfaces: Nonterminal = grammar.extendsInterfaces.nonterm - - private val interfaceBody: Nonterminal = grammar.interfaceBody.nonterm - - private val interfaceMemberDeclaration: Nonterminal = grammar.interfaceMemberDeclaration.nonterm - - private val constantDeclaration: Nonterminal = grammar.constantDeclaration.nonterm - - private val constantModifier: Nonterminal = grammar.constantModifier.nonterm - - private val annotationTypeDeclaration: Nonterminal = grammar.annotationTypeDeclaration.nonterm - - private val annotationTypeBody: Nonterminal = grammar.annotationTypeBody.nonterm - - private val annotationTypeMemberDeclaration: Nonterminal = - grammar.annotationTypeMemberDeclaration.nonterm - - private val annotationTypeElementDeclaration: Nonterminal = - grammar.annotationTypeElementDeclaration.nonterm - - private val defaultValue: Nonterminal = grammar.defaultValue.nonterm - - private val normalAnnotation: Nonterminal = grammar.normalAnnotation.nonterm - - private val elementValuePairList: Nonterminal = grammar.elementValuePairList.nonterm - - private val elementValuePair: Nonterminal = grammar.elementValuePair.nonterm - - private val elementValue: Nonterminal = grammar.elementValue.nonterm - - private val elementValueArrayInitializer: Nonterminal = - grammar.elementValueArrayInitializer.nonterm - - private val elementValueList: Nonterminal = grammar.elementValueList.nonterm - - private val markerAnnotation: Nonterminal = grammar.markerAnnotation.nonterm - - private val singleElementAnnotation: Nonterminal = grammar.singleElementAnnotation.nonterm - - private val interfaceMethodDeclaration: Nonterminal = grammar.interfaceMethodDeclaration.nonterm - - private val annotationTypeElementModifier: Nonterminal = - grammar.annotationTypeElementModifier.nonterm - - private val conditionalExpression: Nonterminal = grammar.conditionalExpression.nonterm - - private val variableInitializerList: Nonterminal = grammar.variableInitializerList.nonterm - - private val blockStatement: Nonterminal = grammar.blockStatement.nonterm - - private val localVariableDeclarationStatement: Nonterminal = - grammar.localVariableDeclarationStatement.nonterm - - private val localVariableDeclaration: Nonterminal = grammar.localVariableDeclaration.nonterm - - private val statement: Nonterminal = grammar.statement.nonterm - - private val statementNoShortIf: Nonterminal = grammar.statementNoShortIf.nonterm - - private val statementWithoutTrailingSubstatement: Nonterminal = - grammar.statementWithoutTrailingSubstatement.nonterm - - private val emptyStatement: Nonterminal = grammar.emptyStatement.nonterm - - private val labeledStatement: Nonterminal = grammar.labeledStatement.nonterm - - private val labeledStatementNoShortIf: Nonterminal = grammar.labeledStatementNoShortIf.nonterm - - private val expressionStatement: Nonterminal = grammar.expressionStatement.nonterm - - private val statementExpression: Nonterminal = grammar.statementExpression.nonterm - - private val ifThenStatement: Nonterminal = grammar.ifThenStatement.nonterm - - private val ifThenElseStatement: Nonterminal = grammar.ifThenElseStatement.nonterm - - private val ifThenElseStatementNoShortIf: Nonterminal = - grammar.ifThenElseStatementNoShortIf.nonterm - - private val assertStatement: Nonterminal = grammar.assertStatement.nonterm - - private val switchStatement: Nonterminal = grammar.switchStatement.nonterm - - private val switchBlock: Nonterminal = grammar.switchBlock.nonterm - - private val switchBlockStatementGroup: Nonterminal = grammar.switchBlockStatementGroup.nonterm - - private val switchLabels: Nonterminal = grammar.switchLabels.nonterm - - private val switchLabel: Nonterminal = grammar.switchLabel.nonterm - - private val enumConstantName: Nonterminal = grammar.enumConstantName.nonterm - - private val whileStatement: Nonterminal = grammar.whileStatement.nonterm - - private val whileStatementNoShortIf: Nonterminal = grammar.whileStatementNoShortIf.nonterm - - private val doStatement: Nonterminal = grammar.doStatement.nonterm - - private val interfaceMethodModifier: Nonterminal = grammar.interfaceMethodModifier.nonterm - - private val forStatement: Nonterminal = grammar.forStatement.nonterm - - private val forStatementNoShortIf: Nonterminal = grammar.forStatementNoShortIf.nonterm - - private val basicForStatement: Nonterminal = grammar.basicForStatement.nonterm - - private val basicForStatementNoShortIf: Nonterminal = grammar.basicForStatementNoShortIf.nonterm - - private val forInit: Nonterminal = grammar.forInit.nonterm - - private val forUpdate: Nonterminal = grammar.forUpdate.nonterm - - private val statementExpressionList: Nonterminal = grammar.statementExpressionList.nonterm - - private val enhancedForStatement: Nonterminal = grammar.enhancedForStatement.nonterm - - private val enhancedForStatementNoShortIf: Nonterminal = - grammar.enhancedForStatementNoShortIf.nonterm - - private val breakStatement: Nonterminal = grammar.breakStatement.nonterm - - private val continueStatement: Nonterminal = grammar.continueStatement.nonterm - - private val returnStatement: Nonterminal = grammar.returnStatement.nonterm - - private val throwStatement: Nonterminal = grammar.throwStatement.nonterm - - private val synchronizedStatement: Nonterminal = grammar.synchronizedStatement.nonterm - - private val tryStatement: Nonterminal = grammar.tryStatement.nonterm - - private val catches: Nonterminal = grammar.catches.nonterm - - private val catchClause: Nonterminal = grammar.catchClause.nonterm - - private val catchFormalParameter: Nonterminal = grammar.catchFormalParameter.nonterm - - private val catchType: Nonterminal = grammar.catchType.nonterm - - private val `finally`: Nonterminal = grammar.finally.nonterm - - private val tryWithResourcesStatement: Nonterminal = grammar.tryWithResourcesStatement.nonterm - - private val resourceSpecification: Nonterminal = grammar.resourceSpecification.nonterm - - private val resourceList: Nonterminal = grammar.resourceList.nonterm - - private val resource: Nonterminal = grammar.resource.nonterm - - private val primaryNoNewArray: Nonterminal = grammar.primaryNoNewArray.nonterm - - private val classLiteral: Nonterminal = grammar.classLiteral.nonterm - - private val classOrInterfaceTypeToInstantiate: Nonterminal = - grammar.classOrInterfaceTypeToInstantiate.nonterm - - private val unqualifiedClassInstanceCreationExpression: Nonterminal = - grammar.unqualifiedClassInstanceCreationExpression.nonterm - - private val classInstanceCreationExpression: Nonterminal = - grammar.classInstanceCreationExpression.nonterm - - private val fieldAccess: Nonterminal = grammar.fieldAccess.nonterm - - private val typeArgumentsOrDiamond: Nonterminal = grammar.typeArgumentsOrDiamond.nonterm - - private val arrayAccess: Nonterminal = grammar.arrayAccess.nonterm - - private val methodInvocation: Nonterminal = grammar.methodInvocation.nonterm - - private val methodReference: Nonterminal = grammar.methodReference.nonterm - - private val arrayCreationExpression: Nonterminal = grammar.arrayCreationExpression.nonterm - - private val dimExprs: Nonterminal = grammar.dimExprs.nonterm - - private val dimExpr: Nonterminal = grammar.dimExpr.nonterm - - private val lambdaExpression: Nonterminal = grammar.lambdaExpression.nonterm - - private val lambdaParameters: Nonterminal = grammar.lambdaParameters.nonterm - - private val inferredFormalParameterList: Nonterminal = grammar.inferredFormalParameterList.nonterm - - private val lambdaBody: Nonterminal = grammar.lambdaBody.nonterm - - private val assignmentExpression: Nonterminal = grammar.assignmentExpression.nonterm - - private val assignment: Nonterminal = grammar.assignment.nonterm - - private val leftHandSide: Nonterminal = grammar.leftHandSide.nonterm - - private val assignmentOperator: Nonterminal = grammar.assignmentOperator.nonterm - - private val conditionalOrExpression: Nonterminal = grammar.conditionalOrExpression.nonterm - - private val conditionalAndExpression: Nonterminal = grammar.conditionalAndExpression.nonterm - - private val inclusiveOrExpression: Nonterminal = grammar.inclusiveOrExpression.nonterm - - private val exclusiveOrExpression: Nonterminal = grammar.exclusiveOrExpression.nonterm - - private val andExpression: Nonterminal = grammar.andExpression.nonterm - - private val equalityExpression: Nonterminal = grammar.equalityExpression.nonterm - - private val relationalExpression: Nonterminal = grammar.relationalExpression.nonterm - - private val shiftExpression: Nonterminal = grammar.shiftExpression.nonterm - - private val additiveExpression: Nonterminal = grammar.additiveExpression.nonterm - - private val multiplicativeExpression: Nonterminal = grammar.multiplicativeExpression.nonterm - - private val preIncrementExpression: Nonterminal = grammar.preIncrementExpression.nonterm - - private val preDecrementExpression: Nonterminal = grammar.preDecrementExpression.nonterm - - private val unaryExpressionNotPlusMinus: Nonterminal = grammar.unaryExpressionNotPlusMinus.nonterm - - private val unaryExpression: Nonterminal = grammar.unaryExpression.nonterm - - private val postfixExpression: Nonterminal = grammar.postfixExpression.nonterm - - private val postIncrementExpression: Nonterminal = grammar.postIncrementExpression.nonterm - - private val postDecrementExpression: Nonterminal = grammar.postDecrementExpression.nonterm - - private val castExpression: Nonterminal = grammar.castExpression.nonterm - - private val constantExpression: Nonterminal = grammar.constantExpression.nonterm - - override fun callNtFuncs( - nt: Nonterminal, - descriptor: Descriptor, - curSppfNode: SppfNode?, - ) { - when(nt.name) { - "compilationUnit" -> parsecompilationUnit(descriptor, curSppfNode) - "identifier" -> parseidentifier(descriptor, curSppfNode) - "literal" -> parseliteral(descriptor, curSppfNode) - "type" -> parsetype(descriptor, curSppfNode) - "primitiveType" -> parseprimitiveType(descriptor, curSppfNode) - "referenceType" -> parsereferenceType(descriptor, curSppfNode) - "annotation" -> parseannotation(descriptor, curSppfNode) - "numericType" -> parsenumericType(descriptor, curSppfNode) - "integralType" -> parseintegralType(descriptor, curSppfNode) - "floatingPointType" -> parsefloatingPointType(descriptor, curSppfNode) - "classOrInterfaceType" -> parseclassOrInterfaceType(descriptor, curSppfNode) - "typeVariable" -> parsetypeVariable(descriptor, curSppfNode) - "arrayType" -> parsearrayType(descriptor, curSppfNode) - "classType" -> parseclassType(descriptor, curSppfNode) - "interfaceType" -> parseinterfaceType(descriptor, curSppfNode) - "typeArguments" -> parsetypeArguments(descriptor, curSppfNode) - "dims" -> parsedims(descriptor, curSppfNode) - "typeParameter" -> parsetypeParameter(descriptor, curSppfNode) - "typeParameterModifier" -> parsetypeParameterModifier(descriptor, curSppfNode) - "typeBound" -> parsetypeBound(descriptor, curSppfNode) - "additionalBound" -> parseadditionalBound(descriptor, curSppfNode) - "typeArgumentList" -> parsetypeArgumentList(descriptor, curSppfNode) - "typeArgument" -> parsetypeArgument(descriptor, curSppfNode) - "wildcard" -> parsewildcard(descriptor, curSppfNode) - "wildcardBounds" -> parsewildcardBounds(descriptor, curSppfNode) - "typeName" -> parsetypeName(descriptor, curSppfNode) - "packageOrTypeName" -> parsepackageOrTypeName(descriptor, curSppfNode) - "expressionName" -> parseexpressionName(descriptor, curSppfNode) - "ambiguousName" -> parseambiguousName(descriptor, curSppfNode) - "methodName" -> parsemethodName(descriptor, curSppfNode) - "packageName" -> parsepackageName(descriptor, curSppfNode) - "result" -> parseresult(descriptor, curSppfNode) - "packageDeclaration" -> parsepackageDeclaration(descriptor, curSppfNode) - "importDeclaration" -> parseimportDeclaration(descriptor, curSppfNode) - "typeDeclaration" -> parsetypeDeclaration(descriptor, curSppfNode) - "packageModifier" -> parsepackageModifier(descriptor, curSppfNode) - "singleTypeImportDeclaration" -> parsesingleTypeImportDeclaration(descriptor, curSppfNode) - "typeImportOnDemandDeclaration" -> parsetypeImportOnDemandDeclaration(descriptor, curSppfNode) - "singleStaticImportDeclaration" -> parsesingleStaticImportDeclaration(descriptor, curSppfNode) - "staticImportOnDemandDeclaration" -> parsestaticImportOnDemandDeclaration(descriptor, - curSppfNode) - "classDeclaration" -> parseclassDeclaration(descriptor, curSppfNode) - "interfaceDeclaration" -> parseinterfaceDeclaration(descriptor, curSppfNode) - "throws" -> parsethrows(descriptor, curSppfNode) - "normalClassDeclaration" -> parsenormalClassDeclaration(descriptor, curSppfNode) - "enumDeclaration" -> parseenumDeclaration(descriptor, curSppfNode) - "classModifier" -> parseclassModifier(descriptor, curSppfNode) - "typeParameters" -> parsetypeParameters(descriptor, curSppfNode) - "superclass" -> parsesuperclass(descriptor, curSppfNode) - "superinterfaces" -> parsesuperinterfaces(descriptor, curSppfNode) - "classBody" -> parseclassBody(descriptor, curSppfNode) - "typeParameterList" -> parsetypeParameterList(descriptor, curSppfNode) - "interfaceTypeList" -> parseinterfaceTypeList(descriptor, curSppfNode) - "classBodyDeclaration" -> parseclassBodyDeclaration(descriptor, curSppfNode) - "classMemberDeclaration" -> parseclassMemberDeclaration(descriptor, curSppfNode) - "instanceInitializer" -> parseinstanceInitializer(descriptor, curSppfNode) - "staticInitializer" -> parsestaticInitializer(descriptor, curSppfNode) - "constructorDeclaration" -> parseconstructorDeclaration(descriptor, curSppfNode) - "fieldDeclaration" -> parsefieldDeclaration(descriptor, curSppfNode) - "methodDeclaration" -> parsemethodDeclaration(descriptor, curSppfNode) - "fieldModifier" -> parsefieldModifier(descriptor, curSppfNode) - "unannType" -> parseunannType(descriptor, curSppfNode) - "variableDeclaratorList" -> parsevariableDeclaratorList(descriptor, curSppfNode) - "variableDeclarator" -> parsevariableDeclarator(descriptor, curSppfNode) - "variableDeclaratorId" -> parsevariableDeclaratorId(descriptor, curSppfNode) - "variableInitializer" -> parsevariableInitializer(descriptor, curSppfNode) - "expression" -> parseexpression(descriptor, curSppfNode) - "arrayInitializer" -> parsearrayInitializer(descriptor, curSppfNode) - "unannPrimitiveType" -> parseunannPrimitiveType(descriptor, curSppfNode) - "unannReferenceType" -> parseunannReferenceType(descriptor, curSppfNode) - "unannClassOrInterfaceType" -> parseunannClassOrInterfaceType(descriptor, curSppfNode) - "unannTypeVariable" -> parseunannTypeVariable(descriptor, curSppfNode) - "unannArrayType" -> parseunannArrayType(descriptor, curSppfNode) - "unannClassType" -> parseunannClassType(descriptor, curSppfNode) - "unannInterfaceType" -> parseunannInterfaceType(descriptor, curSppfNode) - "methodModifier" -> parsemethodModifier(descriptor, curSppfNode) - "methodHeader" -> parsemethodHeader(descriptor, curSppfNode) - "methodBody" -> parsemethodBody(descriptor, curSppfNode) - "methodDeclarator" -> parsemethodDeclarator(descriptor, curSppfNode) - "formalParameterList" -> parseformalParameterList(descriptor, curSppfNode) - "receiverParameter" -> parsereceiverParameter(descriptor, curSppfNode) - "formalParameters" -> parseformalParameters(descriptor, curSppfNode) - "lastFormalParameter" -> parselastFormalParameter(descriptor, curSppfNode) - "formalParameter" -> parseformalParameter(descriptor, curSppfNode) - "variableModifier" -> parsevariableModifier(descriptor, curSppfNode) - "exceptionTypeList" -> parseexceptionTypeList(descriptor, curSppfNode) - "exceptionType" -> parseexceptionType(descriptor, curSppfNode) - "block" -> parseblock(descriptor, curSppfNode) - "constructorModifier" -> parseconstructorModifier(descriptor, curSppfNode) - "constructorDeclarator" -> parseconstructorDeclarator(descriptor, curSppfNode) - "constructorBody" -> parseconstructorBody(descriptor, curSppfNode) - "simpleTypeName" -> parsesimpleTypeName(descriptor, curSppfNode) - "explicitConstructorInvocation" -> parseexplicitConstructorInvocation(descriptor, curSppfNode) - "enumBody" -> parseenumBody(descriptor, curSppfNode) - "enumConstantList" -> parseenumConstantList(descriptor, curSppfNode) - "enumConstant" -> parseenumConstant(descriptor, curSppfNode) - "enumConstantModifier" -> parseenumConstantModifier(descriptor, curSppfNode) - "enumBodyDeclarations" -> parseenumBodyDeclarations(descriptor, curSppfNode) - "blockStatements" -> parseblockStatements(descriptor, curSppfNode) - "argumentList" -> parseargumentList(descriptor, curSppfNode) - "primary" -> parseprimary(descriptor, curSppfNode) - "normalInterfaceDeclaration" -> parsenormalInterfaceDeclaration(descriptor, curSppfNode) - "interfaceModifier" -> parseinterfaceModifier(descriptor, curSppfNode) - "extendsInterfaces" -> parseextendsInterfaces(descriptor, curSppfNode) - "interfaceBody" -> parseinterfaceBody(descriptor, curSppfNode) - "interfaceMemberDeclaration" -> parseinterfaceMemberDeclaration(descriptor, curSppfNode) - "constantDeclaration" -> parseconstantDeclaration(descriptor, curSppfNode) - "constantModifier" -> parseconstantModifier(descriptor, curSppfNode) - "annotationTypeDeclaration" -> parseannotationTypeDeclaration(descriptor, curSppfNode) - "annotationTypeBody" -> parseannotationTypeBody(descriptor, curSppfNode) - "annotationTypeMemberDeclaration" -> parseannotationTypeMemberDeclaration(descriptor, - curSppfNode) - "annotationTypeElementDeclaration" -> parseannotationTypeElementDeclaration(descriptor, - curSppfNode) - "defaultValue" -> parsedefaultValue(descriptor, curSppfNode) - "normalAnnotation" -> parsenormalAnnotation(descriptor, curSppfNode) - "elementValuePairList" -> parseelementValuePairList(descriptor, curSppfNode) - "elementValuePair" -> parseelementValuePair(descriptor, curSppfNode) - "elementValue" -> parseelementValue(descriptor, curSppfNode) - "elementValueArrayInitializer" -> parseelementValueArrayInitializer(descriptor, curSppfNode) - "elementValueList" -> parseelementValueList(descriptor, curSppfNode) - "markerAnnotation" -> parsemarkerAnnotation(descriptor, curSppfNode) - "singleElementAnnotation" -> parsesingleElementAnnotation(descriptor, curSppfNode) - "interfaceMethodDeclaration" -> parseinterfaceMethodDeclaration(descriptor, curSppfNode) - "annotationTypeElementModifier" -> parseannotationTypeElementModifier(descriptor, curSppfNode) - "conditionalExpression" -> parseconditionalExpression(descriptor, curSppfNode) - "variableInitializerList" -> parsevariableInitializerList(descriptor, curSppfNode) - "blockStatement" -> parseblockStatement(descriptor, curSppfNode) - "localVariableDeclarationStatement" -> parselocalVariableDeclarationStatement(descriptor, - curSppfNode) - "localVariableDeclaration" -> parselocalVariableDeclaration(descriptor, curSppfNode) - "statement" -> parsestatement(descriptor, curSppfNode) - "statementNoShortIf" -> parsestatementNoShortIf(descriptor, curSppfNode) - "statementWithoutTrailingSubstatement" -> - parsestatementWithoutTrailingSubstatement(descriptor, curSppfNode) - "emptyStatement" -> parseemptyStatement(descriptor, curSppfNode) - "labeledStatement" -> parselabeledStatement(descriptor, curSppfNode) - "labeledStatementNoShortIf" -> parselabeledStatementNoShortIf(descriptor, curSppfNode) - "expressionStatement" -> parseexpressionStatement(descriptor, curSppfNode) - "statementExpression" -> parsestatementExpression(descriptor, curSppfNode) - "ifThenStatement" -> parseifThenStatement(descriptor, curSppfNode) - "ifThenElseStatement" -> parseifThenElseStatement(descriptor, curSppfNode) - "ifThenElseStatementNoShortIf" -> parseifThenElseStatementNoShortIf(descriptor, curSppfNode) - "assertStatement" -> parseassertStatement(descriptor, curSppfNode) - "switchStatement" -> parseswitchStatement(descriptor, curSppfNode) - "switchBlock" -> parseswitchBlock(descriptor, curSppfNode) - "switchBlockStatementGroup" -> parseswitchBlockStatementGroup(descriptor, curSppfNode) - "switchLabels" -> parseswitchLabels(descriptor, curSppfNode) - "switchLabel" -> parseswitchLabel(descriptor, curSppfNode) - "enumConstantName" -> parseenumConstantName(descriptor, curSppfNode) - "whileStatement" -> parsewhileStatement(descriptor, curSppfNode) - "whileStatementNoShortIf" -> parsewhileStatementNoShortIf(descriptor, curSppfNode) - "doStatement" -> parsedoStatement(descriptor, curSppfNode) - "interfaceMethodModifier" -> parseinterfaceMethodModifier(descriptor, curSppfNode) - "forStatement" -> parseforStatement(descriptor, curSppfNode) - "forStatementNoShortIf" -> parseforStatementNoShortIf(descriptor, curSppfNode) - "basicForStatement" -> parsebasicForStatement(descriptor, curSppfNode) - "basicForStatementNoShortIf" -> parsebasicForStatementNoShortIf(descriptor, curSppfNode) - "forInit" -> parseforInit(descriptor, curSppfNode) - "forUpdate" -> parseforUpdate(descriptor, curSppfNode) - "statementExpressionList" -> parsestatementExpressionList(descriptor, curSppfNode) - "enhancedForStatement" -> parseenhancedForStatement(descriptor, curSppfNode) - "enhancedForStatementNoShortIf" -> parseenhancedForStatementNoShortIf(descriptor, curSppfNode) - "breakStatement" -> parsebreakStatement(descriptor, curSppfNode) - "continueStatement" -> parsecontinueStatement(descriptor, curSppfNode) - "returnStatement" -> parsereturnStatement(descriptor, curSppfNode) - "throwStatement" -> parsethrowStatement(descriptor, curSppfNode) - "synchronizedStatement" -> parsesynchronizedStatement(descriptor, curSppfNode) - "tryStatement" -> parsetryStatement(descriptor, curSppfNode) - "catches" -> parsecatches(descriptor, curSppfNode) - "catchClause" -> parsecatchClause(descriptor, curSppfNode) - "catchFormalParameter" -> parsecatchFormalParameter(descriptor, curSppfNode) - "catchType" -> parsecatchType(descriptor, curSppfNode) - "finally" -> parsefinally(descriptor, curSppfNode) - "tryWithResourcesStatement" -> parsetryWithResourcesStatement(descriptor, curSppfNode) - "resourceSpecification" -> parseresourceSpecification(descriptor, curSppfNode) - "resourceList" -> parseresourceList(descriptor, curSppfNode) - "resource" -> parseresource(descriptor, curSppfNode) - "primaryNoNewArray" -> parseprimaryNoNewArray(descriptor, curSppfNode) - "classLiteral" -> parseclassLiteral(descriptor, curSppfNode) - "classOrInterfaceTypeToInstantiate" -> parseclassOrInterfaceTypeToInstantiate(descriptor, - curSppfNode) - "unqualifiedClassInstanceCreationExpression" -> - parseunqualifiedClassInstanceCreationExpression(descriptor, curSppfNode) - "classInstanceCreationExpression" -> parseclassInstanceCreationExpression(descriptor, - curSppfNode) - "fieldAccess" -> parsefieldAccess(descriptor, curSppfNode) - "typeArgumentsOrDiamond" -> parsetypeArgumentsOrDiamond(descriptor, curSppfNode) - "arrayAccess" -> parsearrayAccess(descriptor, curSppfNode) - "methodInvocation" -> parsemethodInvocation(descriptor, curSppfNode) - "methodReference" -> parsemethodReference(descriptor, curSppfNode) - "arrayCreationExpression" -> parsearrayCreationExpression(descriptor, curSppfNode) - "dimExprs" -> parsedimExprs(descriptor, curSppfNode) - "dimExpr" -> parsedimExpr(descriptor, curSppfNode) - "lambdaExpression" -> parselambdaExpression(descriptor, curSppfNode) - "lambdaParameters" -> parselambdaParameters(descriptor, curSppfNode) - "inferredFormalParameterList" -> parseinferredFormalParameterList(descriptor, curSppfNode) - "lambdaBody" -> parselambdaBody(descriptor, curSppfNode) - "assignmentExpression" -> parseassignmentExpression(descriptor, curSppfNode) - "assignment" -> parseassignment(descriptor, curSppfNode) - "leftHandSide" -> parseleftHandSide(descriptor, curSppfNode) - "assignmentOperator" -> parseassignmentOperator(descriptor, curSppfNode) - "conditionalOrExpression" -> parseconditionalOrExpression(descriptor, curSppfNode) - "conditionalAndExpression" -> parseconditionalAndExpression(descriptor, curSppfNode) - "inclusiveOrExpression" -> parseinclusiveOrExpression(descriptor, curSppfNode) - "exclusiveOrExpression" -> parseexclusiveOrExpression(descriptor, curSppfNode) - "andExpression" -> parseandExpression(descriptor, curSppfNode) - "equalityExpression" -> parseequalityExpression(descriptor, curSppfNode) - "relationalExpression" -> parserelationalExpression(descriptor, curSppfNode) - "shiftExpression" -> parseshiftExpression(descriptor, curSppfNode) - "additiveExpression" -> parseadditiveExpression(descriptor, curSppfNode) - "multiplicativeExpression" -> parsemultiplicativeExpression(descriptor, curSppfNode) - "preIncrementExpression" -> parsepreIncrementExpression(descriptor, curSppfNode) - "preDecrementExpression" -> parsepreDecrementExpression(descriptor, curSppfNode) - "unaryExpressionNotPlusMinus" -> parseunaryExpressionNotPlusMinus(descriptor, curSppfNode) - "unaryExpression" -> parseunaryExpression(descriptor, curSppfNode) - "postfixExpression" -> parsepostfixExpression(descriptor, curSppfNode) - "postIncrementExpression" -> parsepostIncrementExpression(descriptor, curSppfNode) - "postDecrementExpression" -> parsepostDecrementExpression(descriptor, curSppfNode) - "castExpression" -> parsecastExpression(descriptor, curSppfNode) - "constantExpression" -> parseconstantExpression(descriptor, curSppfNode) - } - } - - private fun parsecompilationUnit(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, packageDeclaration, - state.nonterminalEdges[packageDeclaration]!!, curSppfNode) - handleNonterminalEdge(descriptor, typeDeclaration, - state.nonterminalEdges[typeDeclaration]!!, curSppfNode) - handleNonterminalEdge(descriptor, importDeclaration, - state.nonterminalEdges[importDeclaration]!!, curSppfNode) - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, typeDeclaration, - state.nonterminalEdges[typeDeclaration]!!, curSppfNode) - handleNonterminalEdge(descriptor, importDeclaration, - state.nonterminalEdges[importDeclaration]!!, curSppfNode) - } - 2 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, typeDeclaration, - state.nonterminalEdges[typeDeclaration]!!, curSppfNode) - } - } - } - - private fun parseidentifier(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.IDENTIFIER -> - handleTerminal(JavaToken.IDENTIFIER, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - } - } - } - - private fun parseliteral(descriptor: Descriptor, curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.FLOATING_POINT_LITERAL -> - handleTerminal(JavaToken.FLOATING_POINT_LITERAL, state, inputEdge, descriptor, - curSppfNode) - JavaToken.BOOLEAN_LITERAL -> - handleTerminal(JavaToken.BOOLEAN_LITERAL, state, inputEdge, descriptor, curSppfNode) - JavaToken.CHARACTER_LITERAL -> - handleTerminal(JavaToken.CHARACTER_LITERAL, state, inputEdge, descriptor, curSppfNode) - JavaToken.INTEGER_LITERAL -> - handleTerminal(JavaToken.INTEGER_LITERAL, state, inputEdge, descriptor, curSppfNode) - JavaToken.STRING_LITERAL -> - handleTerminal(JavaToken.STRING_LITERAL, state, inputEdge, descriptor, curSppfNode) - JavaToken.NULL_LITERAL -> - handleTerminal(JavaToken.NULL_LITERAL, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - } - } - } - - private fun parsetype(descriptor: Descriptor, curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, referenceType, state.nonterminalEdges[referenceType]!!, - curSppfNode) - handleNonterminalEdge(descriptor, primitiveType, state.nonterminalEdges[primitiveType]!!, - curSppfNode) - } - 1 -> - { - } - } - } - - private fun parseprimitiveType(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.BOOLEAN -> - handleTerminal(JavaToken.BOOLEAN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, annotation, state.nonterminalEdges[annotation]!!, - curSppfNode) - handleNonterminalEdge(descriptor, numericType, state.nonterminalEdges[numericType]!!, - curSppfNode) - } - 1 -> - { - } - } - } - - private fun parsereferenceType(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, typeVariable, state.nonterminalEdges[typeVariable]!!, - curSppfNode) - handleNonterminalEdge(descriptor, arrayType, state.nonterminalEdges[arrayType]!!, - curSppfNode) - handleNonterminalEdge(descriptor, classOrInterfaceType, - state.nonterminalEdges[classOrInterfaceType]!!, curSppfNode) - } - 1 -> - { - } - } - } - - private fun parseannotation(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, singleElementAnnotation, - state.nonterminalEdges[singleElementAnnotation]!!, curSppfNode) - handleNonterminalEdge(descriptor, normalAnnotation, - state.nonterminalEdges[normalAnnotation]!!, curSppfNode) - handleNonterminalEdge(descriptor, markerAnnotation, - state.nonterminalEdges[markerAnnotation]!!, curSppfNode) - } - 1 -> - { - } - } - } - - private fun parsenumericType(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, floatingPointType, - state.nonterminalEdges[floatingPointType]!!, curSppfNode) - handleNonterminalEdge(descriptor, integralType, state.nonterminalEdges[integralType]!!, - curSppfNode) - } - 1 -> - { - } - } - } - - private fun parseintegralType(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.CHAR -> - handleTerminal(JavaToken.CHAR, state, inputEdge, descriptor, curSppfNode) - JavaToken.BYTE -> - handleTerminal(JavaToken.BYTE, state, inputEdge, descriptor, curSppfNode) - JavaToken.INT -> - handleTerminal(JavaToken.INT, state, inputEdge, descriptor, curSppfNode) - JavaToken.LONG -> - handleTerminal(JavaToken.LONG, state, inputEdge, descriptor, curSppfNode) - JavaToken.SHORT -> - handleTerminal(JavaToken.SHORT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - } - } - } - - private fun parsefloatingPointType(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.DOUBLE -> - handleTerminal(JavaToken.DOUBLE, state, inputEdge, descriptor, curSppfNode) - JavaToken.FLOAT -> - handleTerminal(JavaToken.FLOAT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - } - } - } - - private fun parseclassOrInterfaceType(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, interfaceType, state.nonterminalEdges[interfaceType]!!, - curSppfNode) - handleNonterminalEdge(descriptor, classType, state.nonterminalEdges[classType]!!, - curSppfNode) - } - 1 -> - { - } - } - } - - private fun parsetypeVariable(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, annotation, state.nonterminalEdges[annotation]!!, - curSppfNode) - handleNonterminalEdge(descriptor, identifier, state.nonterminalEdges[identifier]!!, - curSppfNode) - } - 1 -> - { - } - } - } - - private fun parsearrayType(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, typeVariable, state.nonterminalEdges[typeVariable]!!, - curSppfNode) - handleNonterminalEdge(descriptor, classOrInterfaceType, - state.nonterminalEdges[classOrInterfaceType]!!, curSppfNode) - handleNonterminalEdge(descriptor, primitiveType, state.nonterminalEdges[primitiveType]!!, - curSppfNode) - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, dims, state.nonterminalEdges[dims]!!, curSppfNode) - } - 2 -> - { - } - } - } - - private fun parseclassType(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, annotation, state.nonterminalEdges[annotation]!!, - curSppfNode) - handleNonterminalEdge(descriptor, identifier, state.nonterminalEdges[identifier]!!, - curSppfNode) - handleNonterminalEdge(descriptor, classOrInterfaceType, - state.nonterminalEdges[classOrInterfaceType]!!, curSppfNode) - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, annotation, state.nonterminalEdges[annotation]!!, - curSppfNode) - handleNonterminalEdge(descriptor, identifier, state.nonterminalEdges[identifier]!!, - curSppfNode) - } - 2 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, typeArguments, state.nonterminalEdges[typeArguments]!!, - curSppfNode) - } - 3 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.DOT -> - handleTerminal(JavaToken.DOT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 4 -> - { - } - } - } - - private fun parseinterfaceType(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, classType, state.nonterminalEdges[classType]!!, - curSppfNode) - } - 1 -> - { - } - } - } - - private fun parsetypeArguments(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.LT -> - handleTerminal(JavaToken.LT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, typeArgumentList, - state.nonterminalEdges[typeArgumentList]!!, curSppfNode) - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.GT -> - handleTerminal(JavaToken.GT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - } - } - } - - private fun parsedims(descriptor: Descriptor, curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.LBRACK -> - handleTerminal(JavaToken.LBRACK, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, annotation, state.nonterminalEdges[annotation]!!, - curSppfNode) - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RBRACK -> - handleTerminal(JavaToken.RBRACK, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.LBRACK -> - handleTerminal(JavaToken.LBRACK, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, annotation, state.nonterminalEdges[annotation]!!, - curSppfNode) - } - } - } - - private fun parsetypeParameter(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, identifier, state.nonterminalEdges[identifier]!!, - curSppfNode) - handleNonterminalEdge(descriptor, typeParameterModifier, - state.nonterminalEdges[typeParameterModifier]!!, curSppfNode) - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, typeBound, state.nonterminalEdges[typeBound]!!, - curSppfNode) - } - 2 -> - { - } - } - } - - private fun parsetypeParameterModifier(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, annotation, state.nonterminalEdges[annotation]!!, - curSppfNode) - } - 1 -> - { - } - } - } - - private fun parsetypeBound(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.EXTENDS -> - handleTerminal(JavaToken.EXTENDS, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, typeVariable, state.nonterminalEdges[typeVariable]!!, - curSppfNode) - handleNonterminalEdge(descriptor, classOrInterfaceType, - state.nonterminalEdges[classOrInterfaceType]!!, curSppfNode) - } - 2 -> - { - } - 3 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, additionalBound, - state.nonterminalEdges[additionalBound]!!, curSppfNode) - } - } - } - - private fun parseadditionalBound(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.AND -> - handleTerminal(JavaToken.AND, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, interfaceType, state.nonterminalEdges[interfaceType]!!, - curSppfNode) - } - 2 -> - { - } - } - } - - private fun parsetypeArgumentList(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, typeArgument, state.nonterminalEdges[typeArgument]!!, - curSppfNode) - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.COMMA -> - handleTerminal(JavaToken.COMMA, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - } - } - - private fun parsetypeArgument(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, referenceType, state.nonterminalEdges[referenceType]!!, - curSppfNode) - handleNonterminalEdge(descriptor, wildcard, state.nonterminalEdges[wildcard]!!, curSppfNode) - } - 1 -> - { - } - } - } - - private fun parsewildcard(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.QUESTION -> - handleTerminal(JavaToken.QUESTION, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, annotation, state.nonterminalEdges[annotation]!!, - curSppfNode) - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, wildcardBounds, state.nonterminalEdges[wildcardBounds]!!, - curSppfNode) - } - 2 -> - { - } - } - } - - private fun parsewildcardBounds(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SUPER -> - handleTerminal(JavaToken.SUPER, state, inputEdge, descriptor, curSppfNode) - JavaToken.EXTENDS -> - handleTerminal(JavaToken.EXTENDS, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, referenceType, state.nonterminalEdges[referenceType]!!, - curSppfNode) - } - 2 -> - { - } - } - } - - private fun parsetypeName(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, identifier, state.nonterminalEdges[identifier]!!, - curSppfNode) - handleNonterminalEdge(descriptor, packageOrTypeName, - state.nonterminalEdges[packageOrTypeName]!!, curSppfNode) - } - 1 -> - { - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.DOT -> - handleTerminal(JavaToken.DOT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, identifier, state.nonterminalEdges[identifier]!!, - curSppfNode) - } - } - } - - private fun parsepackageOrTypeName(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, identifier, state.nonterminalEdges[identifier]!!, - curSppfNode) - handleNonterminalEdge(descriptor, packageOrTypeName, - state.nonterminalEdges[packageOrTypeName]!!, curSppfNode) - } - 1 -> - { - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.DOT -> - handleTerminal(JavaToken.DOT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, identifier, state.nonterminalEdges[identifier]!!, - curSppfNode) - } - } - } - - private fun parseexpressionName(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, identifier, state.nonterminalEdges[identifier]!!, - curSppfNode) - handleNonterminalEdge(descriptor, ambiguousName, state.nonterminalEdges[ambiguousName]!!, - curSppfNode) - } - 1 -> - { - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.DOT -> - handleTerminal(JavaToken.DOT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, identifier, state.nonterminalEdges[identifier]!!, - curSppfNode) - } - } - } - - private fun parseambiguousName(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, identifier, state.nonterminalEdges[identifier]!!, - curSppfNode) - handleNonterminalEdge(descriptor, ambiguousName, state.nonterminalEdges[ambiguousName]!!, - curSppfNode) - } - 1 -> - { - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.DOT -> - handleTerminal(JavaToken.DOT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, identifier, state.nonterminalEdges[identifier]!!, - curSppfNode) - } - } - } - - private fun parsemethodName(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, identifier, state.nonterminalEdges[identifier]!!, - curSppfNode) - } - 1 -> - { - } - } - } - - private fun parsepackageName(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, identifier, state.nonterminalEdges[identifier]!!, - curSppfNode) - handleNonterminalEdge(descriptor, packageName, state.nonterminalEdges[packageName]!!, - curSppfNode) - } - 1 -> - { - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.DOT -> - handleTerminal(JavaToken.DOT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, identifier, state.nonterminalEdges[identifier]!!, - curSppfNode) - } - } - } - - private fun parseresult(descriptor: Descriptor, curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.VOID -> - handleTerminal(JavaToken.VOID, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, unannType, state.nonterminalEdges[unannType]!!, - curSppfNode) - } - 1 -> - { - } - } - } - - private fun parsepackageDeclaration(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.PACKAGE -> - handleTerminal(JavaToken.PACKAGE, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, packageModifier, - state.nonterminalEdges[packageModifier]!!, curSppfNode) - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, identifier, state.nonterminalEdges[identifier]!!, - curSppfNode) - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SEMICOLON -> - handleTerminal(JavaToken.SEMICOLON, state, inputEdge, descriptor, curSppfNode) - JavaToken.DOT -> - handleTerminal(JavaToken.DOT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - } - } - } - - private fun parseimportDeclaration(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, singleTypeImportDeclaration, - state.nonterminalEdges[singleTypeImportDeclaration]!!, curSppfNode) - handleNonterminalEdge(descriptor, staticImportOnDemandDeclaration, - state.nonterminalEdges[staticImportOnDemandDeclaration]!!, curSppfNode) - handleNonterminalEdge(descriptor, singleStaticImportDeclaration, - state.nonterminalEdges[singleStaticImportDeclaration]!!, curSppfNode) - handleNonterminalEdge(descriptor, typeImportOnDemandDeclaration, - state.nonterminalEdges[typeImportOnDemandDeclaration]!!, curSppfNode) - } - 1 -> - { - } - } - } - - private fun parsetypeDeclaration(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SEMICOLON -> - handleTerminal(JavaToken.SEMICOLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, interfaceDeclaration, - state.nonterminalEdges[interfaceDeclaration]!!, curSppfNode) - handleNonterminalEdge(descriptor, classDeclaration, - state.nonterminalEdges[classDeclaration]!!, curSppfNode) - } - 1 -> - { - } - } - } - - private fun parsepackageModifier(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, annotation, state.nonterminalEdges[annotation]!!, - curSppfNode) - } - 1 -> - { - } - } - } - - private fun parsesingleTypeImportDeclaration(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.IMPORT -> - handleTerminal(JavaToken.IMPORT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, typeName, state.nonterminalEdges[typeName]!!, curSppfNode) - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SEMICOLON -> - handleTerminal(JavaToken.SEMICOLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - } - } - } - - private fun parsetypeImportOnDemandDeclaration(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.IMPORT -> - handleTerminal(JavaToken.IMPORT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, packageOrTypeName, - state.nonterminalEdges[packageOrTypeName]!!, curSppfNode) - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.DOT -> - handleTerminal(JavaToken.DOT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.MULT -> - handleTerminal(JavaToken.MULT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 4 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SEMICOLON -> - handleTerminal(JavaToken.SEMICOLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 5 -> - { - } - } - } - - private fun parsesingleStaticImportDeclaration(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.IMPORT -> - handleTerminal(JavaToken.IMPORT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.STATIC -> - handleTerminal(JavaToken.STATIC, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 2 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, typeName, state.nonterminalEdges[typeName]!!, curSppfNode) - } - 3 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.DOT -> - handleTerminal(JavaToken.DOT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 4 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, identifier, state.nonterminalEdges[identifier]!!, - curSppfNode) - } - 5 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SEMICOLON -> - handleTerminal(JavaToken.SEMICOLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 6 -> - { - } - } - } - - private fun parsestaticImportOnDemandDeclaration(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.IMPORT -> - handleTerminal(JavaToken.IMPORT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.STATIC -> - handleTerminal(JavaToken.STATIC, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 2 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, typeName, state.nonterminalEdges[typeName]!!, curSppfNode) - } - 3 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.DOT -> - handleTerminal(JavaToken.DOT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 4 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.MULT -> - handleTerminal(JavaToken.MULT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 5 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SEMICOLON -> - handleTerminal(JavaToken.SEMICOLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 6 -> - { - } - } - } - - private fun parseclassDeclaration(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, enumDeclaration, - state.nonterminalEdges[enumDeclaration]!!, curSppfNode) - handleNonterminalEdge(descriptor, normalClassDeclaration, - state.nonterminalEdges[normalClassDeclaration]!!, curSppfNode) - } - 1 -> - { - } - } - } - - private fun parseinterfaceDeclaration(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, annotationTypeDeclaration, - state.nonterminalEdges[annotationTypeDeclaration]!!, curSppfNode) - handleNonterminalEdge(descriptor, normalInterfaceDeclaration, - state.nonterminalEdges[normalInterfaceDeclaration]!!, curSppfNode) - } - 1 -> - { - } - } - } - - private fun parsethrows(descriptor: Descriptor, curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.THROWS -> - handleTerminal(JavaToken.THROWS, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, exceptionTypeList, - state.nonterminalEdges[exceptionTypeList]!!, curSppfNode) - } - 2 -> - { - } - } - } - - private fun parsenormalClassDeclaration(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.CLASS -> - handleTerminal(JavaToken.CLASS, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, classModifier, state.nonterminalEdges[classModifier]!!, - curSppfNode) - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, identifier, state.nonterminalEdges[identifier]!!, - curSppfNode) - } - 2 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, superinterfaces, - state.nonterminalEdges[superinterfaces]!!, curSppfNode) - handleNonterminalEdge(descriptor, superclass, state.nonterminalEdges[superclass]!!, - curSppfNode) - handleNonterminalEdge(descriptor, classBody, state.nonterminalEdges[classBody]!!, - curSppfNode) - handleNonterminalEdge(descriptor, typeParameters, state.nonterminalEdges[typeParameters]!!, - curSppfNode) - } - 3 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, superinterfaces, - state.nonterminalEdges[superinterfaces]!!, curSppfNode) - handleNonterminalEdge(descriptor, superclass, state.nonterminalEdges[superclass]!!, - curSppfNode) - handleNonterminalEdge(descriptor, classBody, state.nonterminalEdges[classBody]!!, - curSppfNode) - } - 4 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, superinterfaces, - state.nonterminalEdges[superinterfaces]!!, curSppfNode) - handleNonterminalEdge(descriptor, classBody, state.nonterminalEdges[classBody]!!, - curSppfNode) - } - 5 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, classBody, state.nonterminalEdges[classBody]!!, - curSppfNode) - } - 6 -> - { - } - } - } - - private fun parseenumDeclaration(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.ENUM -> - handleTerminal(JavaToken.ENUM, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, classModifier, state.nonterminalEdges[classModifier]!!, - curSppfNode) - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, identifier, state.nonterminalEdges[identifier]!!, - curSppfNode) - } - 2 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, superinterfaces, - state.nonterminalEdges[superinterfaces]!!, curSppfNode) - handleNonterminalEdge(descriptor, enumBody, state.nonterminalEdges[enumBody]!!, curSppfNode) - } - 3 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, enumBody, state.nonterminalEdges[enumBody]!!, curSppfNode) - } - 4 -> - { - } - } - } - - private fun parseclassModifier(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.STATIC -> - handleTerminal(JavaToken.STATIC, state, inputEdge, descriptor, curSppfNode) - JavaToken.PUBLIC -> - handleTerminal(JavaToken.PUBLIC, state, inputEdge, descriptor, curSppfNode) - JavaToken.ABSTRACT -> - handleTerminal(JavaToken.ABSTRACT, state, inputEdge, descriptor, curSppfNode) - JavaToken.FINAL -> - handleTerminal(JavaToken.FINAL, state, inputEdge, descriptor, curSppfNode) - JavaToken.STRICTFP -> - handleTerminal(JavaToken.STRICTFP, state, inputEdge, descriptor, curSppfNode) - JavaToken.PROTECTED -> - handleTerminal(JavaToken.PROTECTED, state, inputEdge, descriptor, curSppfNode) - JavaToken.PRIVATE -> - handleTerminal(JavaToken.PRIVATE, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, annotation, state.nonterminalEdges[annotation]!!, - curSppfNode) - } - 1 -> - { - } - } - } - - private fun parsetypeParameters(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.LT -> - handleTerminal(JavaToken.LT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, typeParameterList, - state.nonterminalEdges[typeParameterList]!!, curSppfNode) - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.GT -> - handleTerminal(JavaToken.GT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - } - } - } - - private fun parsesuperclass(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.EXTENDS -> - handleTerminal(JavaToken.EXTENDS, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, classType, state.nonterminalEdges[classType]!!, - curSppfNode) - } - 2 -> - { - } - } - } - - private fun parsesuperinterfaces(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.IMPLEMENTS -> - handleTerminal(JavaToken.IMPLEMENTS, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, interfaceTypeList, - state.nonterminalEdges[interfaceTypeList]!!, curSppfNode) - } - 2 -> - { - } - } - } - - private fun parseclassBody(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.LBRACE -> - handleTerminal(JavaToken.LBRACE, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RBRACE -> - handleTerminal(JavaToken.RBRACE, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, classBodyDeclaration, - state.nonterminalEdges[classBodyDeclaration]!!, curSppfNode) - } - 2 -> - { - } - } - } - - private fun parsetypeParameterList(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, typeParameter, state.nonterminalEdges[typeParameter]!!, - curSppfNode) - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.COMMA -> - handleTerminal(JavaToken.COMMA, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - } - } - - private fun parseinterfaceTypeList(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, interfaceType, state.nonterminalEdges[interfaceType]!!, - curSppfNode) - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.COMMA -> - handleTerminal(JavaToken.COMMA, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - } - } - - private fun parseclassBodyDeclaration(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, classMemberDeclaration, - state.nonterminalEdges[classMemberDeclaration]!!, curSppfNode) - handleNonterminalEdge(descriptor, staticInitializer, - state.nonterminalEdges[staticInitializer]!!, curSppfNode) - handleNonterminalEdge(descriptor, instanceInitializer, - state.nonterminalEdges[instanceInitializer]!!, curSppfNode) - handleNonterminalEdge(descriptor, constructorDeclaration, - state.nonterminalEdges[constructorDeclaration]!!, curSppfNode) - } - 1 -> - { - } - } - } - - private fun parseclassMemberDeclaration(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SEMICOLON -> - handleTerminal(JavaToken.SEMICOLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, methodDeclaration, - state.nonterminalEdges[methodDeclaration]!!, curSppfNode) - handleNonterminalEdge(descriptor, interfaceDeclaration, - state.nonterminalEdges[interfaceDeclaration]!!, curSppfNode) - handleNonterminalEdge(descriptor, fieldDeclaration, - state.nonterminalEdges[fieldDeclaration]!!, curSppfNode) - handleNonterminalEdge(descriptor, classDeclaration, - state.nonterminalEdges[classDeclaration]!!, curSppfNode) - } - 1 -> - { - } - } - } - - private fun parseinstanceInitializer(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, block, state.nonterminalEdges[block]!!, curSppfNode) - } - 1 -> - { - } - } - } - - private fun parsestaticInitializer(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.STATIC -> - handleTerminal(JavaToken.STATIC, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, block, state.nonterminalEdges[block]!!, curSppfNode) - } - 2 -> - { - } - } - } - - private fun parseconstructorDeclaration(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, constructorDeclarator, - state.nonterminalEdges[constructorDeclarator]!!, curSppfNode) - handleNonterminalEdge(descriptor, constructorModifier, - state.nonterminalEdges[constructorModifier]!!, curSppfNode) - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, throws, state.nonterminalEdges[throws]!!, curSppfNode) - handleNonterminalEdge(descriptor, constructorBody, - state.nonterminalEdges[constructorBody]!!, curSppfNode) - } - 2 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, constructorBody, - state.nonterminalEdges[constructorBody]!!, curSppfNode) - } - 3 -> - { - } - } - } - - private fun parsefieldDeclaration(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, fieldModifier, state.nonterminalEdges[fieldModifier]!!, - curSppfNode) - handleNonterminalEdge(descriptor, unannType, state.nonterminalEdges[unannType]!!, - curSppfNode) - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, variableDeclaratorList, - state.nonterminalEdges[variableDeclaratorList]!!, curSppfNode) - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SEMICOLON -> - handleTerminal(JavaToken.SEMICOLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - } - } - } - - private fun parsemethodDeclaration(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, methodHeader, state.nonterminalEdges[methodHeader]!!, - curSppfNode) - handleNonterminalEdge(descriptor, methodModifier, state.nonterminalEdges[methodModifier]!!, - curSppfNode) - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, methodBody, state.nonterminalEdges[methodBody]!!, - curSppfNode) - } - 2 -> - { - } - } - } - - private fun parsefieldModifier(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.TRANSIENT -> - handleTerminal(JavaToken.TRANSIENT, state, inputEdge, descriptor, curSppfNode) - JavaToken.VOLATILE -> - handleTerminal(JavaToken.VOLATILE, state, inputEdge, descriptor, curSppfNode) - JavaToken.STATIC -> - handleTerminal(JavaToken.STATIC, state, inputEdge, descriptor, curSppfNode) - JavaToken.PUBLIC -> - handleTerminal(JavaToken.PUBLIC, state, inputEdge, descriptor, curSppfNode) - JavaToken.FINAL -> - handleTerminal(JavaToken.FINAL, state, inputEdge, descriptor, curSppfNode) - JavaToken.PROTECTED -> - handleTerminal(JavaToken.PROTECTED, state, inputEdge, descriptor, curSppfNode) - JavaToken.PRIVATE -> - handleTerminal(JavaToken.PRIVATE, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, annotation, state.nonterminalEdges[annotation]!!, - curSppfNode) - } - 1 -> - { - } - } - } - - private fun parseunannType(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, unannReferenceType, - state.nonterminalEdges[unannReferenceType]!!, curSppfNode) - handleNonterminalEdge(descriptor, unannPrimitiveType, - state.nonterminalEdges[unannPrimitiveType]!!, curSppfNode) - } - 1 -> - { - } - } - } - - private fun parsevariableDeclaratorList(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, variableDeclarator, - state.nonterminalEdges[variableDeclarator]!!, curSppfNode) - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.COMMA -> - handleTerminal(JavaToken.COMMA, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - } - } - - private fun parsevariableDeclarator(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, variableDeclaratorId, - state.nonterminalEdges[variableDeclaratorId]!!, curSppfNode) - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.EQ -> - handleTerminal(JavaToken.EQ, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 2 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, variableInitializer, - state.nonterminalEdges[variableInitializer]!!, curSppfNode) - } - 3 -> - { - } - } - } - - private fun parsevariableDeclaratorId(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, identifier, state.nonterminalEdges[identifier]!!, - curSppfNode) - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, dims, state.nonterminalEdges[dims]!!, curSppfNode) - } - 2 -> - { - } - } - } - - private fun parsevariableInitializer(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, expression, state.nonterminalEdges[expression]!!, - curSppfNode) - handleNonterminalEdge(descriptor, arrayInitializer, - state.nonterminalEdges[arrayInitializer]!!, curSppfNode) - } - 1 -> - { - } - } - } - - private fun parseexpression(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, lambdaExpression, - state.nonterminalEdges[lambdaExpression]!!, curSppfNode) - handleNonterminalEdge(descriptor, assignmentExpression, - state.nonterminalEdges[assignmentExpression]!!, curSppfNode) - } - 1 -> - { - } - } - } - - private fun parsearrayInitializer(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.LBRACE -> - handleTerminal(JavaToken.LBRACE, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.COMMA -> - handleTerminal(JavaToken.COMMA, state, inputEdge, descriptor, curSppfNode) - JavaToken.RBRACE -> - handleTerminal(JavaToken.RBRACE, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, variableInitializerList, - state.nonterminalEdges[variableInitializerList]!!, curSppfNode) - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.COMMA -> - handleTerminal(JavaToken.COMMA, state, inputEdge, descriptor, curSppfNode) - JavaToken.RBRACE -> - handleTerminal(JavaToken.RBRACE, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RBRACE -> - handleTerminal(JavaToken.RBRACE, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 4 -> - { - } - } - } - - private fun parseunannPrimitiveType(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.BOOLEAN -> - handleTerminal(JavaToken.BOOLEAN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, numericType, state.nonterminalEdges[numericType]!!, - curSppfNode) - } - 1 -> - { - } - } - } - - private fun parseunannReferenceType(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, unannTypeVariable, - state.nonterminalEdges[unannTypeVariable]!!, curSppfNode) - handleNonterminalEdge(descriptor, unannArrayType, state.nonterminalEdges[unannArrayType]!!, - curSppfNode) - handleNonterminalEdge(descriptor, unannClassOrInterfaceType, - state.nonterminalEdges[unannClassOrInterfaceType]!!, curSppfNode) - } - 1 -> - { - } - } - } - - private fun parseunannClassOrInterfaceType(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, unannClassType, state.nonterminalEdges[unannClassType]!!, - curSppfNode) - handleNonterminalEdge(descriptor, unannInterfaceType, - state.nonterminalEdges[unannInterfaceType]!!, curSppfNode) - } - 1 -> - { - } - } - } - - private fun parseunannTypeVariable(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, identifier, state.nonterminalEdges[identifier]!!, - curSppfNode) - } - 1 -> - { - } - } - } - - private fun parseunannArrayType(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, unannTypeVariable, - state.nonterminalEdges[unannTypeVariable]!!, curSppfNode) - handleNonterminalEdge(descriptor, unannPrimitiveType, - state.nonterminalEdges[unannPrimitiveType]!!, curSppfNode) - handleNonterminalEdge(descriptor, unannClassOrInterfaceType, - state.nonterminalEdges[unannClassOrInterfaceType]!!, curSppfNode) - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, dims, state.nonterminalEdges[dims]!!, curSppfNode) - } - 2 -> - { - } - } - } - - private fun parseunannClassType(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, identifier, state.nonterminalEdges[identifier]!!, - curSppfNode) - handleNonterminalEdge(descriptor, unannClassOrInterfaceType, - state.nonterminalEdges[unannClassOrInterfaceType]!!, curSppfNode) - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, typeArguments, state.nonterminalEdges[typeArguments]!!, - curSppfNode) - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.DOT -> - handleTerminal(JavaToken.DOT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, annotation, state.nonterminalEdges[annotation]!!, - curSppfNode) - handleNonterminalEdge(descriptor, identifier, state.nonterminalEdges[identifier]!!, - curSppfNode) - } - 4 -> - { - } - } - } - - private fun parseunannInterfaceType(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, unannClassType, state.nonterminalEdges[unannClassType]!!, - curSppfNode) - } - 1 -> - { - } - } - } - - private fun parsemethodModifier(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.NATIVE -> - handleTerminal(JavaToken.NATIVE, state, inputEdge, descriptor, curSppfNode) - JavaToken.STATIC -> - handleTerminal(JavaToken.STATIC, state, inputEdge, descriptor, curSppfNode) - JavaToken.PUBLIC -> - handleTerminal(JavaToken.PUBLIC, state, inputEdge, descriptor, curSppfNode) - JavaToken.ABSTRACT -> - handleTerminal(JavaToken.ABSTRACT, state, inputEdge, descriptor, curSppfNode) - JavaToken.FINAL -> - handleTerminal(JavaToken.FINAL, state, inputEdge, descriptor, curSppfNode) - JavaToken.SYNCHRONIZED -> - handleTerminal(JavaToken.SYNCHRONIZED, state, inputEdge, descriptor, curSppfNode) - JavaToken.STRICTFP -> - handleTerminal(JavaToken.STRICTFP, state, inputEdge, descriptor, curSppfNode) - JavaToken.PROTECTED -> - handleTerminal(JavaToken.PROTECTED, state, inputEdge, descriptor, curSppfNode) - JavaToken.PRIVATE -> - handleTerminal(JavaToken.PRIVATE, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, annotation, state.nonterminalEdges[annotation]!!, - curSppfNode) - } - 1 -> - { - } - } - } - - private fun parsemethodHeader(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, result, state.nonterminalEdges[result]!!, curSppfNode) - handleNonterminalEdge(descriptor, typeParameters, state.nonterminalEdges[typeParameters]!!, - curSppfNode) - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, methodDeclarator, - state.nonterminalEdges[methodDeclarator]!!, curSppfNode) - } - 2 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, result, state.nonterminalEdges[result]!!, curSppfNode) - handleNonterminalEdge(descriptor, annotation, state.nonterminalEdges[annotation]!!, - curSppfNode) - } - 3 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, throws, state.nonterminalEdges[throws]!!, curSppfNode) - } - 4 -> - { - } - } - } - - private fun parsemethodBody(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SEMICOLON -> - handleTerminal(JavaToken.SEMICOLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, block, state.nonterminalEdges[block]!!, curSppfNode) - } - 1 -> - { - } - } - } - - private fun parsemethodDeclarator(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, identifier, state.nonterminalEdges[identifier]!!, - curSppfNode) - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.LPAREN -> - handleTerminal(JavaToken.LPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RPAREN -> - handleTerminal(JavaToken.RPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, formalParameterList, - state.nonterminalEdges[formalParameterList]!!, curSppfNode) - } - 3 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RPAREN -> - handleTerminal(JavaToken.RPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 4 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, dims, state.nonterminalEdges[dims]!!, curSppfNode) - } - 5 -> - { - } - } - } - - private fun parseformalParameterList(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, receiverParameter, - state.nonterminalEdges[receiverParameter]!!, curSppfNode) - handleNonterminalEdge(descriptor, formalParameters, - state.nonterminalEdges[formalParameters]!!, curSppfNode) - handleNonterminalEdge(descriptor, lastFormalParameter, - state.nonterminalEdges[lastFormalParameter]!!, curSppfNode) - } - 1 -> - { - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.COMMA -> - handleTerminal(JavaToken.COMMA, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, lastFormalParameter, - state.nonterminalEdges[lastFormalParameter]!!, curSppfNode) - } - } - } - - private fun parsereceiverParameter(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, annotation, state.nonterminalEdges[annotation]!!, - curSppfNode) - handleNonterminalEdge(descriptor, unannType, state.nonterminalEdges[unannType]!!, - curSppfNode) - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.THIS -> - handleTerminal(JavaToken.THIS, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, identifier, state.nonterminalEdges[identifier]!!, - curSppfNode) - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.DOT -> - handleTerminal(JavaToken.DOT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - } - 4 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.THIS -> - handleTerminal(JavaToken.THIS, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - } - } - - private fun parseformalParameters(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, receiverParameter, - state.nonterminalEdges[receiverParameter]!!, curSppfNode) - handleNonterminalEdge(descriptor, formalParameter, - state.nonterminalEdges[formalParameter]!!, curSppfNode) - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.COMMA -> - handleTerminal(JavaToken.COMMA, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 2 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, formalParameter, - state.nonterminalEdges[formalParameter]!!, curSppfNode) - } - } - } - - private fun parselastFormalParameter(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, variableModifier, - state.nonterminalEdges[variableModifier]!!, curSppfNode) - handleNonterminalEdge(descriptor, unannType, state.nonterminalEdges[unannType]!!, - curSppfNode) - handleNonterminalEdge(descriptor, formalParameter, - state.nonterminalEdges[formalParameter]!!, curSppfNode) - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, variableModifier, - state.nonterminalEdges[variableModifier]!!, curSppfNode) - handleNonterminalEdge(descriptor, unannType, state.nonterminalEdges[unannType]!!, - curSppfNode) - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.ELLIPSIS -> - handleTerminal(JavaToken.ELLIPSIS, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, annotation, state.nonterminalEdges[annotation]!!, - curSppfNode) - } - 3 -> - { - } - 4 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, variableDeclaratorId, - state.nonterminalEdges[variableDeclaratorId]!!, curSppfNode) - } - } - } - - private fun parseformalParameter(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, variableModifier, - state.nonterminalEdges[variableModifier]!!, curSppfNode) - handleNonterminalEdge(descriptor, unannType, state.nonterminalEdges[unannType]!!, - curSppfNode) - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, variableDeclaratorId, - state.nonterminalEdges[variableDeclaratorId]!!, curSppfNode) - } - 2 -> - { - } - } - } - - private fun parsevariableModifier(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.FINAL -> - handleTerminal(JavaToken.FINAL, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, annotation, state.nonterminalEdges[annotation]!!, - curSppfNode) - } - 1 -> - { - } - } - } - - private fun parseexceptionTypeList(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, exceptionType, state.nonterminalEdges[exceptionType]!!, - curSppfNode) - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.COMMA -> - handleTerminal(JavaToken.COMMA, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - } - } - - private fun parseexceptionType(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, typeVariable, state.nonterminalEdges[typeVariable]!!, - curSppfNode) - handleNonterminalEdge(descriptor, classType, state.nonterminalEdges[classType]!!, - curSppfNode) - } - 1 -> - { - } - } - } - - private fun parseblock(descriptor: Descriptor, curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.LBRACE -> - handleTerminal(JavaToken.LBRACE, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RBRACE -> - handleTerminal(JavaToken.RBRACE, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, blockStatements, - state.nonterminalEdges[blockStatements]!!, curSppfNode) - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RBRACE -> - handleTerminal(JavaToken.RBRACE, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - } - } - } - - private fun parseconstructorModifier(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.PUBLIC -> - handleTerminal(JavaToken.PUBLIC, state, inputEdge, descriptor, curSppfNode) - JavaToken.PROTECTED -> - handleTerminal(JavaToken.PROTECTED, state, inputEdge, descriptor, curSppfNode) - JavaToken.PRIVATE -> - handleTerminal(JavaToken.PRIVATE, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, annotation, state.nonterminalEdges[annotation]!!, - curSppfNode) - } - 1 -> - { - } - } - } - - private fun parseconstructorDeclarator(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, simpleTypeName, state.nonterminalEdges[simpleTypeName]!!, - curSppfNode) - handleNonterminalEdge(descriptor, typeParameters, state.nonterminalEdges[typeParameters]!!, - curSppfNode) - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, simpleTypeName, state.nonterminalEdges[simpleTypeName]!!, - curSppfNode) - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.LPAREN -> - handleTerminal(JavaToken.LPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RPAREN -> - handleTerminal(JavaToken.RPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, formalParameterList, - state.nonterminalEdges[formalParameterList]!!, curSppfNode) - } - 4 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RPAREN -> - handleTerminal(JavaToken.RPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 5 -> - { - } - } - } - - private fun parseconstructorBody(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.LBRACE -> - handleTerminal(JavaToken.LBRACE, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RBRACE -> - handleTerminal(JavaToken.RBRACE, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, blockStatements, - state.nonterminalEdges[blockStatements]!!, curSppfNode) - handleNonterminalEdge(descriptor, explicitConstructorInvocation, - state.nonterminalEdges[explicitConstructorInvocation]!!, curSppfNode) - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RBRACE -> - handleTerminal(JavaToken.RBRACE, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, blockStatements, - state.nonterminalEdges[blockStatements]!!, curSppfNode) - } - 3 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RBRACE -> - handleTerminal(JavaToken.RBRACE, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 4 -> - { - } - } - } - - private fun parsesimpleTypeName(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, identifier, state.nonterminalEdges[identifier]!!, - curSppfNode) - } - 1 -> - { - } - } - } - - private fun parseexplicitConstructorInvocation(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.THIS -> - handleTerminal(JavaToken.THIS, state, inputEdge, descriptor, curSppfNode) - JavaToken.SUPER -> - handleTerminal(JavaToken.SUPER, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, typeArguments, state.nonterminalEdges[typeArguments]!!, - curSppfNode) - handleNonterminalEdge(descriptor, expressionName, state.nonterminalEdges[expressionName]!!, - curSppfNode) - handleNonterminalEdge(descriptor, primary, state.nonterminalEdges[primary]!!, curSppfNode) - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.THIS -> - handleTerminal(JavaToken.THIS, state, inputEdge, descriptor, curSppfNode) - JavaToken.SUPER -> - handleTerminal(JavaToken.SUPER, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.LPAREN -> - handleTerminal(JavaToken.LPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.DOT -> - handleTerminal(JavaToken.DOT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 4 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SUPER -> - handleTerminal(JavaToken.SUPER, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, typeArguments, state.nonterminalEdges[typeArguments]!!, - curSppfNode) - } - 5 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SUPER -> - handleTerminal(JavaToken.SUPER, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 6 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RPAREN -> - handleTerminal(JavaToken.RPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, argumentList, state.nonterminalEdges[argumentList]!!, - curSppfNode) - } - 7 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RPAREN -> - handleTerminal(JavaToken.RPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 8 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SEMICOLON -> - handleTerminal(JavaToken.SEMICOLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 9 -> - { - } - } - } - - private fun parseenumBody(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.LBRACE -> - handleTerminal(JavaToken.LBRACE, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.COMMA -> - handleTerminal(JavaToken.COMMA, state, inputEdge, descriptor, curSppfNode) - JavaToken.RBRACE -> - handleTerminal(JavaToken.RBRACE, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, enumConstantList, - state.nonterminalEdges[enumConstantList]!!, curSppfNode) - handleNonterminalEdge(descriptor, enumBodyDeclarations, - state.nonterminalEdges[enumBodyDeclarations]!!, curSppfNode) - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.COMMA -> - handleTerminal(JavaToken.COMMA, state, inputEdge, descriptor, curSppfNode) - JavaToken.RBRACE -> - handleTerminal(JavaToken.RBRACE, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, enumBodyDeclarations, - state.nonterminalEdges[enumBodyDeclarations]!!, curSppfNode) - } - 3 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RBRACE -> - handleTerminal(JavaToken.RBRACE, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, enumBodyDeclarations, - state.nonterminalEdges[enumBodyDeclarations]!!, curSppfNode) - } - 4 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RBRACE -> - handleTerminal(JavaToken.RBRACE, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 5 -> - { - } - } - } - - private fun parseenumConstantList(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, enumConstant, state.nonterminalEdges[enumConstant]!!, - curSppfNode) - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.COMMA -> - handleTerminal(JavaToken.COMMA, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - } - } - - private fun parseenumConstant(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, identifier, state.nonterminalEdges[identifier]!!, - curSppfNode) - handleNonterminalEdge(descriptor, enumConstantModifier, - state.nonterminalEdges[enumConstantModifier]!!, curSppfNode) - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.LPAREN -> - handleTerminal(JavaToken.LPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RPAREN -> - handleTerminal(JavaToken.RPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, argumentList, state.nonterminalEdges[argumentList]!!, - curSppfNode) - } - 3 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RPAREN -> - handleTerminal(JavaToken.RPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 4 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, classBody, state.nonterminalEdges[classBody]!!, - curSppfNode) - } - 5 -> - { - } - } - } - - private fun parseenumConstantModifier(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, annotation, state.nonterminalEdges[annotation]!!, - curSppfNode) - } - 1 -> - { - } - } - } - - private fun parseenumBodyDeclarations(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SEMICOLON -> - handleTerminal(JavaToken.SEMICOLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, classBodyDeclaration, - state.nonterminalEdges[classBodyDeclaration]!!, curSppfNode) - } - } - } - - private fun parseblockStatements(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, blockStatement, state.nonterminalEdges[blockStatement]!!, - curSppfNode) - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, blockStatement, state.nonterminalEdges[blockStatement]!!, - curSppfNode) - } - } - } - - private fun parseargumentList(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, expression, state.nonterminalEdges[expression]!!, - curSppfNode) - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.COMMA -> - handleTerminal(JavaToken.COMMA, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - } - } - - private fun parseprimary(descriptor: Descriptor, curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, primaryNoNewArray, - state.nonterminalEdges[primaryNoNewArray]!!, curSppfNode) - handleNonterminalEdge(descriptor, arrayCreationExpression, - state.nonterminalEdges[arrayCreationExpression]!!, curSppfNode) - } - 1 -> - { - } - } - } - - private fun parsenormalInterfaceDeclaration(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.INTERFACE -> - handleTerminal(JavaToken.INTERFACE, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, interfaceModifier, - state.nonterminalEdges[interfaceModifier]!!, curSppfNode) - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, identifier, state.nonterminalEdges[identifier]!!, - curSppfNode) - } - 2 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, interfaceBody, state.nonterminalEdges[interfaceBody]!!, - curSppfNode) - handleNonterminalEdge(descriptor, extendsInterfaces, - state.nonterminalEdges[extendsInterfaces]!!, curSppfNode) - handleNonterminalEdge(descriptor, typeParameters, state.nonterminalEdges[typeParameters]!!, - curSppfNode) - } - 3 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, interfaceBody, state.nonterminalEdges[interfaceBody]!!, - curSppfNode) - handleNonterminalEdge(descriptor, extendsInterfaces, - state.nonterminalEdges[extendsInterfaces]!!, curSppfNode) - } - 4 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, interfaceBody, state.nonterminalEdges[interfaceBody]!!, - curSppfNode) - } - 5 -> - { - } - } - } - - private fun parseinterfaceModifier(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.STATIC -> - handleTerminal(JavaToken.STATIC, state, inputEdge, descriptor, curSppfNode) - JavaToken.PUBLIC -> - handleTerminal(JavaToken.PUBLIC, state, inputEdge, descriptor, curSppfNode) - JavaToken.ABSTRACT -> - handleTerminal(JavaToken.ABSTRACT, state, inputEdge, descriptor, curSppfNode) - JavaToken.STRICTFP -> - handleTerminal(JavaToken.STRICTFP, state, inputEdge, descriptor, curSppfNode) - JavaToken.PROTECTED -> - handleTerminal(JavaToken.PROTECTED, state, inputEdge, descriptor, curSppfNode) - JavaToken.PRIVATE -> - handleTerminal(JavaToken.PRIVATE, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, annotation, state.nonterminalEdges[annotation]!!, - curSppfNode) - } - 1 -> - { - } - } - } - - private fun parseextendsInterfaces(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.EXTENDS -> - handleTerminal(JavaToken.EXTENDS, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, interfaceTypeList, - state.nonterminalEdges[interfaceTypeList]!!, curSppfNode) - } - 2 -> - { - } - } - } - - private fun parseinterfaceBody(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.LBRACE -> - handleTerminal(JavaToken.LBRACE, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RBRACE -> - handleTerminal(JavaToken.RBRACE, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, interfaceMemberDeclaration, - state.nonterminalEdges[interfaceMemberDeclaration]!!, curSppfNode) - } - 2 -> - { - } - } - } - - private fun parseinterfaceMemberDeclaration(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SEMICOLON -> - handleTerminal(JavaToken.SEMICOLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, interfaceDeclaration, - state.nonterminalEdges[interfaceDeclaration]!!, curSppfNode) - handleNonterminalEdge(descriptor, constantDeclaration, - state.nonterminalEdges[constantDeclaration]!!, curSppfNode) - handleNonterminalEdge(descriptor, interfaceMethodDeclaration, - state.nonterminalEdges[interfaceMethodDeclaration]!!, curSppfNode) - handleNonterminalEdge(descriptor, classDeclaration, - state.nonterminalEdges[classDeclaration]!!, curSppfNode) - } - 1 -> - { - } - } - } - - private fun parseconstantDeclaration(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, constantModifier, - state.nonterminalEdges[constantModifier]!!, curSppfNode) - handleNonterminalEdge(descriptor, unannType, state.nonterminalEdges[unannType]!!, - curSppfNode) - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, variableDeclaratorList, - state.nonterminalEdges[variableDeclaratorList]!!, curSppfNode) - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SEMICOLON -> - handleTerminal(JavaToken.SEMICOLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - } - } - } - - private fun parseconstantModifier(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.STATIC -> - handleTerminal(JavaToken.STATIC, state, inputEdge, descriptor, curSppfNode) - JavaToken.PUBLIC -> - handleTerminal(JavaToken.PUBLIC, state, inputEdge, descriptor, curSppfNode) - JavaToken.FINAL -> - handleTerminal(JavaToken.FINAL, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, annotation, state.nonterminalEdges[annotation]!!, - curSppfNode) - } - 1 -> - { - } - } - } - - private fun parseannotationTypeDeclaration(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.AT -> - handleTerminal(JavaToken.AT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, interfaceModifier, - state.nonterminalEdges[interfaceModifier]!!, curSppfNode) - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.INTERFACE -> - handleTerminal(JavaToken.INTERFACE, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 2 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, identifier, state.nonterminalEdges[identifier]!!, - curSppfNode) - } - 3 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, annotationTypeBody, - state.nonterminalEdges[annotationTypeBody]!!, curSppfNode) - } - 4 -> - { - } - } - } - - private fun parseannotationTypeBody(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.LBRACE -> - handleTerminal(JavaToken.LBRACE, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RBRACE -> - handleTerminal(JavaToken.RBRACE, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, annotationTypeMemberDeclaration, - state.nonterminalEdges[annotationTypeMemberDeclaration]!!, curSppfNode) - } - 2 -> - { - } - } - } - - private fun parseannotationTypeMemberDeclaration(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SEMICOLON -> - handleTerminal(JavaToken.SEMICOLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, interfaceDeclaration, - state.nonterminalEdges[interfaceDeclaration]!!, curSppfNode) - handleNonterminalEdge(descriptor, annotationTypeElementDeclaration, - state.nonterminalEdges[annotationTypeElementDeclaration]!!, curSppfNode) - handleNonterminalEdge(descriptor, constantDeclaration, - state.nonterminalEdges[constantDeclaration]!!, curSppfNode) - handleNonterminalEdge(descriptor, classDeclaration, - state.nonterminalEdges[classDeclaration]!!, curSppfNode) - } - 1 -> - { - } - } - } - - private fun parseannotationTypeElementDeclaration(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, annotationTypeElementModifier, - state.nonterminalEdges[annotationTypeElementModifier]!!, curSppfNode) - handleNonterminalEdge(descriptor, unannType, state.nonterminalEdges[unannType]!!, - curSppfNode) - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, identifier, state.nonterminalEdges[identifier]!!, - curSppfNode) - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.LPAREN -> - handleTerminal(JavaToken.LPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RPAREN -> - handleTerminal(JavaToken.RPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 4 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SEMICOLON -> - handleTerminal(JavaToken.SEMICOLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, dims, state.nonterminalEdges[dims]!!, curSppfNode) - handleNonterminalEdge(descriptor, defaultValue, state.nonterminalEdges[defaultValue]!!, - curSppfNode) - } - 5 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SEMICOLON -> - handleTerminal(JavaToken.SEMICOLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, defaultValue, state.nonterminalEdges[defaultValue]!!, - curSppfNode) - } - 6 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SEMICOLON -> - handleTerminal(JavaToken.SEMICOLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 7 -> - { - } - } - } - - private fun parsedefaultValue(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.DEFAULT -> - handleTerminal(JavaToken.DEFAULT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, elementValue, state.nonterminalEdges[elementValue]!!, - curSppfNode) - } - 2 -> - { - } - } - } - - private fun parsenormalAnnotation(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.AT -> - handleTerminal(JavaToken.AT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, typeName, state.nonterminalEdges[typeName]!!, curSppfNode) - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.LPAREN -> - handleTerminal(JavaToken.LPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RPAREN -> - handleTerminal(JavaToken.RPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, elementValuePairList, - state.nonterminalEdges[elementValuePairList]!!, curSppfNode) - } - 4 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RPAREN -> - handleTerminal(JavaToken.RPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 5 -> - { - } - } - } - - private fun parseelementValuePairList(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, elementValuePair, - state.nonterminalEdges[elementValuePair]!!, curSppfNode) - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.COMMA -> - handleTerminal(JavaToken.COMMA, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - } - } - - private fun parseelementValuePair(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, identifier, state.nonterminalEdges[identifier]!!, - curSppfNode) - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.EQ -> - handleTerminal(JavaToken.EQ, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 2 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, elementValue, state.nonterminalEdges[elementValue]!!, - curSppfNode) - } - 3 -> - { - } - } - } - - private fun parseelementValue(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, annotation, state.nonterminalEdges[annotation]!!, - curSppfNode) - handleNonterminalEdge(descriptor, elementValueArrayInitializer, - state.nonterminalEdges[elementValueArrayInitializer]!!, curSppfNode) - handleNonterminalEdge(descriptor, conditionalExpression, - state.nonterminalEdges[conditionalExpression]!!, curSppfNode) - } - 1 -> - { - } - } - } - - private fun parseelementValueArrayInitializer(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.LBRACE -> - handleTerminal(JavaToken.LBRACE, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.COMMA -> - handleTerminal(JavaToken.COMMA, state, inputEdge, descriptor, curSppfNode) - JavaToken.RBRACE -> - handleTerminal(JavaToken.RBRACE, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, elementValueList, - state.nonterminalEdges[elementValueList]!!, curSppfNode) - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.COMMA -> - handleTerminal(JavaToken.COMMA, state, inputEdge, descriptor, curSppfNode) - JavaToken.RBRACE -> - handleTerminal(JavaToken.RBRACE, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RBRACE -> - handleTerminal(JavaToken.RBRACE, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 4 -> - { - } - } - } - - private fun parseelementValueList(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, elementValue, state.nonterminalEdges[elementValue]!!, - curSppfNode) - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.COMMA -> - handleTerminal(JavaToken.COMMA, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - } - } - - private fun parsemarkerAnnotation(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.AT -> - handleTerminal(JavaToken.AT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, typeName, state.nonterminalEdges[typeName]!!, curSppfNode) - } - 2 -> - { - } - } - } - - private fun parsesingleElementAnnotation(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.AT -> - handleTerminal(JavaToken.AT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, typeName, state.nonterminalEdges[typeName]!!, curSppfNode) - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.LPAREN -> - handleTerminal(JavaToken.LPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, elementValue, state.nonterminalEdges[elementValue]!!, - curSppfNode) - } - 4 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RPAREN -> - handleTerminal(JavaToken.RPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 5 -> - { - } - } - } - - private fun parseinterfaceMethodDeclaration(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, methodHeader, state.nonterminalEdges[methodHeader]!!, - curSppfNode) - handleNonterminalEdge(descriptor, interfaceMethodModifier, - state.nonterminalEdges[interfaceMethodModifier]!!, curSppfNode) - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, methodBody, state.nonterminalEdges[methodBody]!!, - curSppfNode) - } - 2 -> - { - } - } - } - - private fun parseannotationTypeElementModifier(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.PUBLIC -> - handleTerminal(JavaToken.PUBLIC, state, inputEdge, descriptor, curSppfNode) - JavaToken.ABSTRACT -> - handleTerminal(JavaToken.ABSTRACT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, annotation, state.nonterminalEdges[annotation]!!, - curSppfNode) - } - 1 -> - { - } - } - } - - private fun parseconditionalExpression(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, conditionalOrExpression, - state.nonterminalEdges[conditionalOrExpression]!!, curSppfNode) - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.QUESTION -> - handleTerminal(JavaToken.QUESTION, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 2 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, expression, state.nonterminalEdges[expression]!!, - curSppfNode) - } - 3 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.COLON -> - handleTerminal(JavaToken.COLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 4 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, lambdaExpression, - state.nonterminalEdges[lambdaExpression]!!, curSppfNode) - handleNonterminalEdge(descriptor, conditionalExpression, - state.nonterminalEdges[conditionalExpression]!!, curSppfNode) - } - 5 -> - { - } - } - } - - private fun parsevariableInitializerList(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, variableInitializer, - state.nonterminalEdges[variableInitializer]!!, curSppfNode) - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.COMMA -> - handleTerminal(JavaToken.COMMA, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - } - } - - private fun parseblockStatement(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, localVariableDeclarationStatement, - state.nonterminalEdges[localVariableDeclarationStatement]!!, curSppfNode) - handleNonterminalEdge(descriptor, statement, state.nonterminalEdges[statement]!!, - curSppfNode) - handleNonterminalEdge(descriptor, classDeclaration, - state.nonterminalEdges[classDeclaration]!!, curSppfNode) - } - 1 -> - { - } - } - } - - private fun parselocalVariableDeclarationStatement(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, localVariableDeclaration, - state.nonterminalEdges[localVariableDeclaration]!!, curSppfNode) - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SEMICOLON -> - handleTerminal(JavaToken.SEMICOLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 2 -> - { - } - } - } - - private fun parselocalVariableDeclaration(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, variableModifier, - state.nonterminalEdges[variableModifier]!!, curSppfNode) - handleNonterminalEdge(descriptor, unannType, state.nonterminalEdges[unannType]!!, - curSppfNode) - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, variableDeclaratorList, - state.nonterminalEdges[variableDeclaratorList]!!, curSppfNode) - } - 2 -> - { - } - } - } - - private fun parsestatement(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, whileStatement, state.nonterminalEdges[whileStatement]!!, - curSppfNode) - handleNonterminalEdge(descriptor, labeledStatement, - state.nonterminalEdges[labeledStatement]!!, curSppfNode) - handleNonterminalEdge(descriptor, forStatement, state.nonterminalEdges[forStatement]!!, - curSppfNode) - handleNonterminalEdge(descriptor, statementWithoutTrailingSubstatement, - state.nonterminalEdges[statementWithoutTrailingSubstatement]!!, curSppfNode) - handleNonterminalEdge(descriptor, ifThenElseStatement, - state.nonterminalEdges[ifThenElseStatement]!!, curSppfNode) - handleNonterminalEdge(descriptor, ifThenStatement, - state.nonterminalEdges[ifThenStatement]!!, curSppfNode) - } - 1 -> - { - } - } - } - - private fun parsestatementNoShortIf(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, whileStatementNoShortIf, - state.nonterminalEdges[whileStatementNoShortIf]!!, curSppfNode) - handleNonterminalEdge(descriptor, labeledStatementNoShortIf, - state.nonterminalEdges[labeledStatementNoShortIf]!!, curSppfNode) - handleNonterminalEdge(descriptor, forStatementNoShortIf, - state.nonterminalEdges[forStatementNoShortIf]!!, curSppfNode) - handleNonterminalEdge(descriptor, statementWithoutTrailingSubstatement, - state.nonterminalEdges[statementWithoutTrailingSubstatement]!!, curSppfNode) - handleNonterminalEdge(descriptor, ifThenElseStatementNoShortIf, - state.nonterminalEdges[ifThenElseStatementNoShortIf]!!, curSppfNode) - } - 1 -> - { - } - } - } - - private fun parsestatementWithoutTrailingSubstatement(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, emptyStatement, state.nonterminalEdges[emptyStatement]!!, - curSppfNode) - handleNonterminalEdge(descriptor, tryStatement, state.nonterminalEdges[tryStatement]!!, - curSppfNode) - handleNonterminalEdge(descriptor, doStatement, state.nonterminalEdges[doStatement]!!, - curSppfNode) - handleNonterminalEdge(descriptor, throwStatement, state.nonterminalEdges[throwStatement]!!, - curSppfNode) - handleNonterminalEdge(descriptor, assertStatement, - state.nonterminalEdges[assertStatement]!!, curSppfNode) - handleNonterminalEdge(descriptor, breakStatement, state.nonterminalEdges[breakStatement]!!, - curSppfNode) - handleNonterminalEdge(descriptor, block, state.nonterminalEdges[block]!!, curSppfNode) - handleNonterminalEdge(descriptor, expressionStatement, - state.nonterminalEdges[expressionStatement]!!, curSppfNode) - handleNonterminalEdge(descriptor, continueStatement, - state.nonterminalEdges[continueStatement]!!, curSppfNode) - handleNonterminalEdge(descriptor, returnStatement, - state.nonterminalEdges[returnStatement]!!, curSppfNode) - handleNonterminalEdge(descriptor, switchStatement, - state.nonterminalEdges[switchStatement]!!, curSppfNode) - handleNonterminalEdge(descriptor, synchronizedStatement, - state.nonterminalEdges[synchronizedStatement]!!, curSppfNode) - } - 1 -> - { - } - } - } - - private fun parseemptyStatement(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SEMICOLON -> - handleTerminal(JavaToken.SEMICOLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - } - } - } - - private fun parselabeledStatement(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, identifier, state.nonterminalEdges[identifier]!!, - curSppfNode) - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.COLON -> - handleTerminal(JavaToken.COLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 2 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, statement, state.nonterminalEdges[statement]!!, - curSppfNode) - } - 3 -> - { - } - } - } - - private fun parselabeledStatementNoShortIf(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, identifier, state.nonterminalEdges[identifier]!!, - curSppfNode) - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.COLON -> - handleTerminal(JavaToken.COLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 2 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, statementNoShortIf, - state.nonterminalEdges[statementNoShortIf]!!, curSppfNode) - } - 3 -> - { - } - } - } - - private fun parseexpressionStatement(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, statementExpression, - state.nonterminalEdges[statementExpression]!!, curSppfNode) - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SEMICOLON -> - handleTerminal(JavaToken.SEMICOLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 2 -> - { - } - } - } - - private fun parsestatementExpression(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, classInstanceCreationExpression, - state.nonterminalEdges[classInstanceCreationExpression]!!, curSppfNode) - handleNonterminalEdge(descriptor, assignment, state.nonterminalEdges[assignment]!!, - curSppfNode) - handleNonterminalEdge(descriptor, methodInvocation, - state.nonterminalEdges[methodInvocation]!!, curSppfNode) - handleNonterminalEdge(descriptor, preDecrementExpression, - state.nonterminalEdges[preDecrementExpression]!!, curSppfNode) - handleNonterminalEdge(descriptor, preIncrementExpression, - state.nonterminalEdges[preIncrementExpression]!!, curSppfNode) - handleNonterminalEdge(descriptor, postIncrementExpression, - state.nonterminalEdges[postIncrementExpression]!!, curSppfNode) - handleNonterminalEdge(descriptor, postDecrementExpression, - state.nonterminalEdges[postDecrementExpression]!!, curSppfNode) - } - 1 -> - { - } - } - } - - private fun parseifThenStatement(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.IF -> - handleTerminal(JavaToken.IF, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.LPAREN -> - handleTerminal(JavaToken.LPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 2 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, expression, state.nonterminalEdges[expression]!!, - curSppfNode) - } - 3 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RPAREN -> - handleTerminal(JavaToken.RPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 4 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, statement, state.nonterminalEdges[statement]!!, - curSppfNode) - } - 5 -> - { - } - } - } - - private fun parseifThenElseStatement(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.IF -> - handleTerminal(JavaToken.IF, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.LPAREN -> - handleTerminal(JavaToken.LPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 2 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, expression, state.nonterminalEdges[expression]!!, - curSppfNode) - } - 3 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RPAREN -> - handleTerminal(JavaToken.RPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 4 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, statementNoShortIf, - state.nonterminalEdges[statementNoShortIf]!!, curSppfNode) - } - 5 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.ELSE -> - handleTerminal(JavaToken.ELSE, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 6 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, statement, state.nonterminalEdges[statement]!!, - curSppfNode) - } - 7 -> - { - } - } - } - - private fun parseifThenElseStatementNoShortIf(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.IF -> - handleTerminal(JavaToken.IF, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.LPAREN -> - handleTerminal(JavaToken.LPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 2 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, expression, state.nonterminalEdges[expression]!!, - curSppfNode) - } - 3 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RPAREN -> - handleTerminal(JavaToken.RPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 4 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, statementNoShortIf, - state.nonterminalEdges[statementNoShortIf]!!, curSppfNode) - } - 5 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.ELSE -> - handleTerminal(JavaToken.ELSE, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 6 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, statementNoShortIf, - state.nonterminalEdges[statementNoShortIf]!!, curSppfNode) - } - 7 -> - { - } - } - } - - private fun parseassertStatement(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.ASSERT -> - handleTerminal(JavaToken.ASSERT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, expression, state.nonterminalEdges[expression]!!, - curSppfNode) - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SEMICOLON -> - handleTerminal(JavaToken.SEMICOLON, state, inputEdge, descriptor, curSppfNode) - JavaToken.COLON -> - handleTerminal(JavaToken.COLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - } - 4 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, expression, state.nonterminalEdges[expression]!!, - curSppfNode) - } - 5 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SEMICOLON -> - handleTerminal(JavaToken.SEMICOLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - } - } - - private fun parseswitchStatement(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SWITCH -> - handleTerminal(JavaToken.SWITCH, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.LPAREN -> - handleTerminal(JavaToken.LPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 2 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, expression, state.nonterminalEdges[expression]!!, - curSppfNode) - } - 3 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RPAREN -> - handleTerminal(JavaToken.RPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 4 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, switchBlock, state.nonterminalEdges[switchBlock]!!, - curSppfNode) - } - 5 -> - { - } - } - } - - private fun parseswitchBlock(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.LBRACE -> - handleTerminal(JavaToken.LBRACE, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RBRACE -> - handleTerminal(JavaToken.RBRACE, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, switchBlockStatementGroup, - state.nonterminalEdges[switchBlockStatementGroup]!!, curSppfNode) - handleNonterminalEdge(descriptor, switchLabel, state.nonterminalEdges[switchLabel]!!, - curSppfNode) - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RBRACE -> - handleTerminal(JavaToken.RBRACE, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, switchLabel, state.nonterminalEdges[switchLabel]!!, - curSppfNode) - } - 3 -> - { - } - } - } - - private fun parseswitchBlockStatementGroup(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, switchLabels, state.nonterminalEdges[switchLabels]!!, - curSppfNode) - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, blockStatements, - state.nonterminalEdges[blockStatements]!!, curSppfNode) - } - 2 -> - { - } - } - } - - private fun parseswitchLabels(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, switchLabel, state.nonterminalEdges[switchLabel]!!, - curSppfNode) - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, switchLabel, state.nonterminalEdges[switchLabel]!!, - curSppfNode) - } - } - } - - private fun parseswitchLabel(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.CASE -> - handleTerminal(JavaToken.CASE, state, inputEdge, descriptor, curSppfNode) - JavaToken.DEFAULT -> - handleTerminal(JavaToken.DEFAULT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, enumConstantName, - state.nonterminalEdges[enumConstantName]!!, curSppfNode) - handleNonterminalEdge(descriptor, constantExpression, - state.nonterminalEdges[constantExpression]!!, curSppfNode) - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.COLON -> - handleTerminal(JavaToken.COLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - } - } - } - - private fun parseenumConstantName(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, identifier, state.nonterminalEdges[identifier]!!, - curSppfNode) - } - 1 -> - { - } - } - } - - private fun parsewhileStatement(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.WHILE -> - handleTerminal(JavaToken.WHILE, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.LPAREN -> - handleTerminal(JavaToken.LPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 2 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, expression, state.nonterminalEdges[expression]!!, - curSppfNode) - } - 3 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RPAREN -> - handleTerminal(JavaToken.RPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 4 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, statement, state.nonterminalEdges[statement]!!, - curSppfNode) - } - 5 -> - { - } - } - } - - private fun parsewhileStatementNoShortIf(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.WHILE -> - handleTerminal(JavaToken.WHILE, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.LPAREN -> - handleTerminal(JavaToken.LPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 2 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, expression, state.nonterminalEdges[expression]!!, - curSppfNode) - } - 3 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RPAREN -> - handleTerminal(JavaToken.RPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 4 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, statementNoShortIf, - state.nonterminalEdges[statementNoShortIf]!!, curSppfNode) - } - 5 -> - { - } - } - } - - private fun parsedoStatement(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.DO -> - handleTerminal(JavaToken.DO, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, statement, state.nonterminalEdges[statement]!!, - curSppfNode) - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.WHILE -> - handleTerminal(JavaToken.WHILE, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.LPAREN -> - handleTerminal(JavaToken.LPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 4 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, expression, state.nonterminalEdges[expression]!!, - curSppfNode) - } - 5 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RPAREN -> - handleTerminal(JavaToken.RPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 6 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SEMICOLON -> - handleTerminal(JavaToken.SEMICOLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 7 -> - { - } - } - } - - private fun parseinterfaceMethodModifier(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.DEFAULT -> - handleTerminal(JavaToken.DEFAULT, state, inputEdge, descriptor, curSppfNode) - JavaToken.STATIC -> - handleTerminal(JavaToken.STATIC, state, inputEdge, descriptor, curSppfNode) - JavaToken.PUBLIC -> - handleTerminal(JavaToken.PUBLIC, state, inputEdge, descriptor, curSppfNode) - JavaToken.ABSTRACT -> - handleTerminal(JavaToken.ABSTRACT, state, inputEdge, descriptor, curSppfNode) - JavaToken.STRICTFP -> - handleTerminal(JavaToken.STRICTFP, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, annotation, state.nonterminalEdges[annotation]!!, - curSppfNode) - } - 1 -> - { - } - } - } - - private fun parseforStatement(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, enhancedForStatement, - state.nonterminalEdges[enhancedForStatement]!!, curSppfNode) - handleNonterminalEdge(descriptor, basicForStatement, - state.nonterminalEdges[basicForStatement]!!, curSppfNode) - } - 1 -> - { - } - } - } - - private fun parseforStatementNoShortIf(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, basicForStatementNoShortIf, - state.nonterminalEdges[basicForStatementNoShortIf]!!, curSppfNode) - handleNonterminalEdge(descriptor, enhancedForStatementNoShortIf, - state.nonterminalEdges[enhancedForStatementNoShortIf]!!, curSppfNode) - } - 1 -> - { - } - } - } - - private fun parsebasicForStatement(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.FOR -> - handleTerminal(JavaToken.FOR, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.LPAREN -> - handleTerminal(JavaToken.LPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SEMICOLON -> - handleTerminal(JavaToken.SEMICOLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, forInit, state.nonterminalEdges[forInit]!!, curSppfNode) - } - 3 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SEMICOLON -> - handleTerminal(JavaToken.SEMICOLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 4 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SEMICOLON -> - handleTerminal(JavaToken.SEMICOLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, expression, state.nonterminalEdges[expression]!!, - curSppfNode) - } - 5 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RPAREN -> - handleTerminal(JavaToken.RPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, forUpdate, state.nonterminalEdges[forUpdate]!!, - curSppfNode) - } - 6 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SEMICOLON -> - handleTerminal(JavaToken.SEMICOLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 7 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RPAREN -> - handleTerminal(JavaToken.RPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 8 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, statement, state.nonterminalEdges[statement]!!, - curSppfNode) - } - 9 -> - { - } - } - } - - private fun parsebasicForStatementNoShortIf(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.FOR -> - handleTerminal(JavaToken.FOR, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.LPAREN -> - handleTerminal(JavaToken.LPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SEMICOLON -> - handleTerminal(JavaToken.SEMICOLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, forInit, state.nonterminalEdges[forInit]!!, curSppfNode) - } - 3 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SEMICOLON -> - handleTerminal(JavaToken.SEMICOLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 4 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SEMICOLON -> - handleTerminal(JavaToken.SEMICOLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, expression, state.nonterminalEdges[expression]!!, - curSppfNode) - } - 5 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RPAREN -> - handleTerminal(JavaToken.RPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, forUpdate, state.nonterminalEdges[forUpdate]!!, - curSppfNode) - } - 6 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SEMICOLON -> - handleTerminal(JavaToken.SEMICOLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 7 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RPAREN -> - handleTerminal(JavaToken.RPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 8 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, statementNoShortIf, - state.nonterminalEdges[statementNoShortIf]!!, curSppfNode) - } - 9 -> - { - } - } - } - - private fun parseforInit(descriptor: Descriptor, curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, localVariableDeclaration, - state.nonterminalEdges[localVariableDeclaration]!!, curSppfNode) - handleNonterminalEdge(descriptor, statementExpressionList, - state.nonterminalEdges[statementExpressionList]!!, curSppfNode) - } - 1 -> - { - } - } - } - - private fun parseforUpdate(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, statementExpressionList, - state.nonterminalEdges[statementExpressionList]!!, curSppfNode) - } - 1 -> - { - } - } - } - - private fun parsestatementExpressionList(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, statementExpression, - state.nonterminalEdges[statementExpression]!!, curSppfNode) - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.COMMA -> - handleTerminal(JavaToken.COMMA, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - } - } - - private fun parseenhancedForStatement(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.FOR -> - handleTerminal(JavaToken.FOR, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.LPAREN -> - handleTerminal(JavaToken.LPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 2 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, variableModifier, - state.nonterminalEdges[variableModifier]!!, curSppfNode) - handleNonterminalEdge(descriptor, unannType, state.nonterminalEdges[unannType]!!, - curSppfNode) - } - 3 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, variableDeclaratorId, - state.nonterminalEdges[variableDeclaratorId]!!, curSppfNode) - } - 4 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.COLON -> - handleTerminal(JavaToken.COLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 5 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, expression, state.nonterminalEdges[expression]!!, - curSppfNode) - } - 6 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RPAREN -> - handleTerminal(JavaToken.RPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 7 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, statement, state.nonterminalEdges[statement]!!, - curSppfNode) - } - 8 -> - { - } - } - } - - private fun parseenhancedForStatementNoShortIf(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.FOR -> - handleTerminal(JavaToken.FOR, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.LPAREN -> - handleTerminal(JavaToken.LPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 2 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, variableModifier, - state.nonterminalEdges[variableModifier]!!, curSppfNode) - handleNonterminalEdge(descriptor, unannType, state.nonterminalEdges[unannType]!!, - curSppfNode) - } - 3 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, variableDeclaratorId, - state.nonterminalEdges[variableDeclaratorId]!!, curSppfNode) - } - 4 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.COLON -> - handleTerminal(JavaToken.COLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 5 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, expression, state.nonterminalEdges[expression]!!, - curSppfNode) - } - 6 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RPAREN -> - handleTerminal(JavaToken.RPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 7 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, statementNoShortIf, - state.nonterminalEdges[statementNoShortIf]!!, curSppfNode) - } - 8 -> - { - } - } - } - - private fun parsebreakStatement(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.BREAK -> - handleTerminal(JavaToken.BREAK, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SEMICOLON -> - handleTerminal(JavaToken.SEMICOLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, identifier, state.nonterminalEdges[identifier]!!, - curSppfNode) - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SEMICOLON -> - handleTerminal(JavaToken.SEMICOLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - } - } - } - - private fun parsecontinueStatement(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.CONTINUE -> - handleTerminal(JavaToken.CONTINUE, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SEMICOLON -> - handleTerminal(JavaToken.SEMICOLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, identifier, state.nonterminalEdges[identifier]!!, - curSppfNode) - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SEMICOLON -> - handleTerminal(JavaToken.SEMICOLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - } - } - } - - private fun parsereturnStatement(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RETURN -> - handleTerminal(JavaToken.RETURN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SEMICOLON -> - handleTerminal(JavaToken.SEMICOLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, expression, state.nonterminalEdges[expression]!!, - curSppfNode) - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SEMICOLON -> - handleTerminal(JavaToken.SEMICOLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - } - } - } - - private fun parsethrowStatement(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.THROW -> - handleTerminal(JavaToken.THROW, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, expression, state.nonterminalEdges[expression]!!, - curSppfNode) - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SEMICOLON -> - handleTerminal(JavaToken.SEMICOLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - } - } - } - - private fun parsesynchronizedStatement(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SYNCHRONIZED -> - handleTerminal(JavaToken.SYNCHRONIZED, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.LPAREN -> - handleTerminal(JavaToken.LPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 2 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, expression, state.nonterminalEdges[expression]!!, - curSppfNode) - } - 3 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RPAREN -> - handleTerminal(JavaToken.RPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 4 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, block, state.nonterminalEdges[block]!!, curSppfNode) - } - 5 -> - { - } - } - } - - private fun parsetryStatement(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.TRY -> - handleTerminal(JavaToken.TRY, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, tryWithResourcesStatement, - state.nonterminalEdges[tryWithResourcesStatement]!!, curSppfNode) - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, block, state.nonterminalEdges[block]!!, curSppfNode) - } - 2 -> - { - } - 3 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, finally, state.nonterminalEdges[finally]!!, curSppfNode) - handleNonterminalEdge(descriptor, catches, state.nonterminalEdges[catches]!!, curSppfNode) - } - 4 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, finally, state.nonterminalEdges[finally]!!, curSppfNode) - } - } - } - - private fun parsecatches(descriptor: Descriptor, curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, catchClause, state.nonterminalEdges[catchClause]!!, - curSppfNode) - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, catchClause, state.nonterminalEdges[catchClause]!!, - curSppfNode) - } - } - } - - private fun parsecatchClause(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.CATCH -> - handleTerminal(JavaToken.CATCH, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.LPAREN -> - handleTerminal(JavaToken.LPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 2 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, catchFormalParameter, - state.nonterminalEdges[catchFormalParameter]!!, curSppfNode) - } - 3 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RPAREN -> - handleTerminal(JavaToken.RPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 4 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, block, state.nonterminalEdges[block]!!, curSppfNode) - } - 5 -> - { - } - } - } - - private fun parsecatchFormalParameter(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, variableModifier, - state.nonterminalEdges[variableModifier]!!, curSppfNode) - handleNonterminalEdge(descriptor, catchType, state.nonterminalEdges[catchType]!!, - curSppfNode) - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, variableDeclaratorId, - state.nonterminalEdges[variableDeclaratorId]!!, curSppfNode) - } - 2 -> - { - } - } - } - - private fun parsecatchType(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, unannClassType, state.nonterminalEdges[unannClassType]!!, - curSppfNode) - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.OR -> - handleTerminal(JavaToken.OR, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 2 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, classType, state.nonterminalEdges[classType]!!, - curSppfNode) - } - } - } - - private fun parsefinally(descriptor: Descriptor, curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.FINALLY -> - handleTerminal(JavaToken.FINALLY, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, block, state.nonterminalEdges[block]!!, curSppfNode) - } - 2 -> - { - } - } - } - - private fun parsetryWithResourcesStatement(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.TRY -> - handleTerminal(JavaToken.TRY, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, resourceSpecification, - state.nonterminalEdges[resourceSpecification]!!, curSppfNode) - } - 2 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, block, state.nonterminalEdges[block]!!, curSppfNode) - } - 3 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, finally, state.nonterminalEdges[finally]!!, curSppfNode) - handleNonterminalEdge(descriptor, catches, state.nonterminalEdges[catches]!!, curSppfNode) - } - 4 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, finally, state.nonterminalEdges[finally]!!, curSppfNode) - } - 5 -> - { - } - } - } - - private fun parseresourceSpecification(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.LPAREN -> - handleTerminal(JavaToken.LPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, resourceList, state.nonterminalEdges[resourceList]!!, - curSppfNode) - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RPAREN -> - handleTerminal(JavaToken.RPAREN, state, inputEdge, descriptor, curSppfNode) - JavaToken.SEMICOLON -> - handleTerminal(JavaToken.SEMICOLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RPAREN -> - handleTerminal(JavaToken.RPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 4 -> - { - } - } - } - - private fun parseresourceList(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, resource, state.nonterminalEdges[resource]!!, curSppfNode) - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.COMMA -> - handleTerminal(JavaToken.COMMA, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - } - } - - private fun parseresource(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, variableModifier, - state.nonterminalEdges[variableModifier]!!, curSppfNode) - handleNonterminalEdge(descriptor, unannType, state.nonterminalEdges[unannType]!!, - curSppfNode) - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, variableDeclaratorId, - state.nonterminalEdges[variableDeclaratorId]!!, curSppfNode) - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.EQ -> - handleTerminal(JavaToken.EQ, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, expression, state.nonterminalEdges[expression]!!, - curSppfNode) - } - 4 -> - { - } - } - } - - private fun parseprimaryNoNewArray(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.THIS -> - handleTerminal(JavaToken.THIS, state, inputEdge, descriptor, curSppfNode) - JavaToken.LPAREN -> - handleTerminal(JavaToken.LPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, classInstanceCreationExpression, - state.nonterminalEdges[classInstanceCreationExpression]!!, curSppfNode) - handleNonterminalEdge(descriptor, methodInvocation, - state.nonterminalEdges[methodInvocation]!!, curSppfNode) - handleNonterminalEdge(descriptor, fieldAccess, state.nonterminalEdges[fieldAccess]!!, - curSppfNode) - handleNonterminalEdge(descriptor, methodReference, - state.nonterminalEdges[methodReference]!!, curSppfNode) - handleNonterminalEdge(descriptor, classLiteral, state.nonterminalEdges[classLiteral]!!, - curSppfNode) - handleNonterminalEdge(descriptor, typeName, state.nonterminalEdges[typeName]!!, curSppfNode) - handleNonterminalEdge(descriptor, arrayAccess, state.nonterminalEdges[arrayAccess]!!, - curSppfNode) - handleNonterminalEdge(descriptor, literal, state.nonterminalEdges[literal]!!, curSppfNode) - } - 1 -> - { - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.DOT -> - handleTerminal(JavaToken.DOT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, expression, state.nonterminalEdges[expression]!!, - curSppfNode) - } - 4 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RPAREN -> - handleTerminal(JavaToken.RPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 5 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.THIS -> - handleTerminal(JavaToken.THIS, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - } - } - - private fun parseclassLiteral(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.BOOLEAN -> - handleTerminal(JavaToken.BOOLEAN, state, inputEdge, descriptor, curSppfNode) - JavaToken.VOID -> - handleTerminal(JavaToken.VOID, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, typeName, state.nonterminalEdges[typeName]!!, curSppfNode) - handleNonterminalEdge(descriptor, numericType, state.nonterminalEdges[numericType]!!, - curSppfNode) - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.LBRACK -> - handleTerminal(JavaToken.LBRACK, state, inputEdge, descriptor, curSppfNode) - JavaToken.DOT -> - handleTerminal(JavaToken.DOT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.DOT -> - handleTerminal(JavaToken.DOT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.CLASS -> - handleTerminal(JavaToken.CLASS, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 4 -> - { - } - 5 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RBRACK -> - handleTerminal(JavaToken.RBRACK, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - } - } - - private fun parseclassOrInterfaceTypeToInstantiate(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, annotation, state.nonterminalEdges[annotation]!!, - curSppfNode) - handleNonterminalEdge(descriptor, identifier, state.nonterminalEdges[identifier]!!, - curSppfNode) - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.DOT -> - handleTerminal(JavaToken.DOT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, typeArgumentsOrDiamond, - state.nonterminalEdges[typeArgumentsOrDiamond]!!, curSppfNode) - } - 2 -> - { - } - } - } - - private fun parseunqualifiedClassInstanceCreationExpression(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.NEW -> - handleTerminal(JavaToken.NEW, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, typeArguments, state.nonterminalEdges[typeArguments]!!, - curSppfNode) - handleNonterminalEdge(descriptor, classOrInterfaceTypeToInstantiate, - state.nonterminalEdges[classOrInterfaceTypeToInstantiate]!!, curSppfNode) - } - 2 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, classOrInterfaceTypeToInstantiate, - state.nonterminalEdges[classOrInterfaceTypeToInstantiate]!!, curSppfNode) - } - 3 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.LPAREN -> - handleTerminal(JavaToken.LPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 4 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RPAREN -> - handleTerminal(JavaToken.RPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, argumentList, state.nonterminalEdges[argumentList]!!, - curSppfNode) - } - 5 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RPAREN -> - handleTerminal(JavaToken.RPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 6 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, classBody, state.nonterminalEdges[classBody]!!, - curSppfNode) - } - 7 -> - { - } - } - } - - private fun parseclassInstanceCreationExpression(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, expressionName, state.nonterminalEdges[expressionName]!!, - curSppfNode) - handleNonterminalEdge(descriptor, unqualifiedClassInstanceCreationExpression, - state.nonterminalEdges[unqualifiedClassInstanceCreationExpression]!!, curSppfNode) - handleNonterminalEdge(descriptor, primary, state.nonterminalEdges[primary]!!, curSppfNode) - } - 1 -> - { - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.DOT -> - handleTerminal(JavaToken.DOT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, unqualifiedClassInstanceCreationExpression, - state.nonterminalEdges[unqualifiedClassInstanceCreationExpression]!!, curSppfNode) - } - } - } - - private fun parsefieldAccess(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SUPER -> - handleTerminal(JavaToken.SUPER, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, typeName, state.nonterminalEdges[typeName]!!, curSppfNode) - handleNonterminalEdge(descriptor, primary, state.nonterminalEdges[primary]!!, curSppfNode) - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.DOT -> - handleTerminal(JavaToken.DOT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.DOT -> - handleTerminal(JavaToken.DOT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SUPER -> - handleTerminal(JavaToken.SUPER, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 4 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, identifier, state.nonterminalEdges[identifier]!!, - curSppfNode) - } - 5 -> - { - } - } - } - - private fun parsetypeArgumentsOrDiamond(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.LT -> - handleTerminal(JavaToken.LT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, typeArguments, state.nonterminalEdges[typeArguments]!!, - curSppfNode) - } - 1 -> - { - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.GT -> - handleTerminal(JavaToken.GT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - } - } - - private fun parsearrayAccess(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, expressionName, state.nonterminalEdges[expressionName]!!, - curSppfNode) - handleNonterminalEdge(descriptor, primaryNoNewArray, - state.nonterminalEdges[primaryNoNewArray]!!, curSppfNode) - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.LBRACK -> - handleTerminal(JavaToken.LBRACK, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 2 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, expression, state.nonterminalEdges[expression]!!, - curSppfNode) - } - 3 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RBRACK -> - handleTerminal(JavaToken.RBRACK, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 4 -> - { - } - } - } - - private fun parsemethodInvocation(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SUPER -> - handleTerminal(JavaToken.SUPER, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, expressionName, state.nonterminalEdges[expressionName]!!, - curSppfNode) - handleNonterminalEdge(descriptor, typeName, state.nonterminalEdges[typeName]!!, curSppfNode) - handleNonterminalEdge(descriptor, methodName, state.nonterminalEdges[methodName]!!, - curSppfNode) - handleNonterminalEdge(descriptor, primary, state.nonterminalEdges[primary]!!, curSppfNode) - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.LPAREN -> - handleTerminal(JavaToken.LPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.DOT -> - handleTerminal(JavaToken.DOT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.DOT -> - handleTerminal(JavaToken.DOT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 4 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, typeArguments, state.nonterminalEdges[typeArguments]!!, - curSppfNode) - handleNonterminalEdge(descriptor, identifier, state.nonterminalEdges[identifier]!!, - curSppfNode) - } - 5 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, identifier, state.nonterminalEdges[identifier]!!, - curSppfNode) - } - 6 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SUPER -> - handleTerminal(JavaToken.SUPER, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, typeArguments, state.nonterminalEdges[typeArguments]!!, - curSppfNode) - handleNonterminalEdge(descriptor, identifier, state.nonterminalEdges[identifier]!!, - curSppfNode) - } - 7 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RPAREN -> - handleTerminal(JavaToken.RPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, argumentList, state.nonterminalEdges[argumentList]!!, - curSppfNode) - } - 8 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RPAREN -> - handleTerminal(JavaToken.RPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 9 -> - { - } - } - } - - private fun parsemethodReference(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SUPER -> - handleTerminal(JavaToken.SUPER, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, arrayType, state.nonterminalEdges[arrayType]!!, - curSppfNode) - handleNonterminalEdge(descriptor, expressionName, state.nonterminalEdges[expressionName]!!, - curSppfNode) - handleNonterminalEdge(descriptor, typeName, state.nonterminalEdges[typeName]!!, curSppfNode) - handleNonterminalEdge(descriptor, referenceType, state.nonterminalEdges[referenceType]!!, - curSppfNode) - handleNonterminalEdge(descriptor, classType, state.nonterminalEdges[classType]!!, - curSppfNode) - handleNonterminalEdge(descriptor, primary, state.nonterminalEdges[primary]!!, curSppfNode) - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.COLONCOLON -> - handleTerminal(JavaToken.COLONCOLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.DOT -> - handleTerminal(JavaToken.DOT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.COLONCOLON -> - handleTerminal(JavaToken.COLONCOLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 4 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.COLONCOLON -> - handleTerminal(JavaToken.COLONCOLON, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 5 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.NEW -> - handleTerminal(JavaToken.NEW, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 6 -> - { - } - 7 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.NEW -> - handleTerminal(JavaToken.NEW, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, typeArguments, state.nonterminalEdges[typeArguments]!!, - curSppfNode) - } - 8 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.SUPER -> - handleTerminal(JavaToken.SUPER, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 9 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, typeArguments, state.nonterminalEdges[typeArguments]!!, - curSppfNode) - handleNonterminalEdge(descriptor, identifier, state.nonterminalEdges[identifier]!!, - curSppfNode) - } - 10 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, identifier, state.nonterminalEdges[identifier]!!, - curSppfNode) - } - } - } - - private fun parsearrayCreationExpression(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.NEW -> - handleTerminal(JavaToken.NEW, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, classOrInterfaceType, - state.nonterminalEdges[classOrInterfaceType]!!, curSppfNode) - handleNonterminalEdge(descriptor, primitiveType, state.nonterminalEdges[primitiveType]!!, - curSppfNode) - } - 2 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, dims, state.nonterminalEdges[dims]!!, curSppfNode) - handleNonterminalEdge(descriptor, dimExprs, state.nonterminalEdges[dimExprs]!!, curSppfNode) - } - 3 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, dims, state.nonterminalEdges[dims]!!, curSppfNode) - } - 4 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, arrayInitializer, - state.nonterminalEdges[arrayInitializer]!!, curSppfNode) - } - 5 -> - { - } - } - } - - private fun parsedimExprs(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, dimExpr, state.nonterminalEdges[dimExpr]!!, curSppfNode) - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, dimExpr, state.nonterminalEdges[dimExpr]!!, curSppfNode) - } - } - } - - private fun parsedimExpr(descriptor: Descriptor, curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.LBRACK -> - handleTerminal(JavaToken.LBRACK, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, annotation, state.nonterminalEdges[annotation]!!, - curSppfNode) - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, expression, state.nonterminalEdges[expression]!!, - curSppfNode) - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RBRACK -> - handleTerminal(JavaToken.RBRACK, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - } - } - } - - private fun parselambdaExpression(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, lambdaParameters, - state.nonterminalEdges[lambdaParameters]!!, curSppfNode) - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.ARROW -> - handleTerminal(JavaToken.ARROW, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 2 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, lambdaBody, state.nonterminalEdges[lambdaBody]!!, - curSppfNode) - } - 3 -> - { - } - } - } - - private fun parselambdaParameters(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.LPAREN -> - handleTerminal(JavaToken.LPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, identifier, state.nonterminalEdges[identifier]!!, - curSppfNode) - } - 1 -> - { - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RPAREN -> - handleTerminal(JavaToken.RPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, inferredFormalParameterList, - state.nonterminalEdges[inferredFormalParameterList]!!, curSppfNode) - handleNonterminalEdge(descriptor, formalParameterList, - state.nonterminalEdges[formalParameterList]!!, curSppfNode) - } - 3 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RPAREN -> - handleTerminal(JavaToken.RPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - } - } - - private fun parseinferredFormalParameterList(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, identifier, state.nonterminalEdges[identifier]!!, - curSppfNode) - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.COMMA -> - handleTerminal(JavaToken.COMMA, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - } - } - - private fun parselambdaBody(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, expression, state.nonterminalEdges[expression]!!, - curSppfNode) - handleNonterminalEdge(descriptor, block, state.nonterminalEdges[block]!!, curSppfNode) - } - 1 -> - { - } - } - } - - private fun parseassignmentExpression(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, conditionalExpression, - state.nonterminalEdges[conditionalExpression]!!, curSppfNode) - handleNonterminalEdge(descriptor, assignment, state.nonterminalEdges[assignment]!!, - curSppfNode) - } - 1 -> - { - } - } - } - - private fun parseassignment(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, leftHandSide, state.nonterminalEdges[leftHandSide]!!, - curSppfNode) - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, assignmentOperator, - state.nonterminalEdges[assignmentOperator]!!, curSppfNode) - } - 2 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, expression, state.nonterminalEdges[expression]!!, - curSppfNode) - } - 3 -> - { - } - } - } - - private fun parseleftHandSide(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, expressionName, state.nonterminalEdges[expressionName]!!, - curSppfNode) - handleNonterminalEdge(descriptor, fieldAccess, state.nonterminalEdges[fieldAccess]!!, - curSppfNode) - handleNonterminalEdge(descriptor, arrayAccess, state.nonterminalEdges[arrayAccess]!!, - curSppfNode) - } - 1 -> - { - } - } - } - - private fun parseassignmentOperator(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.MODEQ -> - handleTerminal(JavaToken.MODEQ, state, inputEdge, descriptor, curSppfNode) - JavaToken.OREQ -> - handleTerminal(JavaToken.OREQ, state, inputEdge, descriptor, curSppfNode) - JavaToken.MULTEQ -> - handleTerminal(JavaToken.MULTEQ, state, inputEdge, descriptor, curSppfNode) - JavaToken.DIVEQ -> - handleTerminal(JavaToken.DIVEQ, state, inputEdge, descriptor, curSppfNode) - JavaToken.PLUSEQ -> - handleTerminal(JavaToken.PLUSEQ, state, inputEdge, descriptor, curSppfNode) - JavaToken.URSHIFTEQ -> - handleTerminal(JavaToken.URSHIFTEQ, state, inputEdge, descriptor, curSppfNode) - JavaToken.MINUSEQ -> - handleTerminal(JavaToken.MINUSEQ, state, inputEdge, descriptor, curSppfNode) - JavaToken.LSHIFTEQ -> - handleTerminal(JavaToken.LSHIFTEQ, state, inputEdge, descriptor, curSppfNode) - JavaToken.ANDEQ -> - handleTerminal(JavaToken.ANDEQ, state, inputEdge, descriptor, curSppfNode) - JavaToken.EQ -> - handleTerminal(JavaToken.EQ, state, inputEdge, descriptor, curSppfNode) - JavaToken.RSHIFTEQ -> - handleTerminal(JavaToken.RSHIFTEQ, state, inputEdge, descriptor, curSppfNode) - JavaToken.XOREQ -> - handleTerminal(JavaToken.XOREQ, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - } - } - } - - private fun parseconditionalOrExpression(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, conditionalOrExpression, - state.nonterminalEdges[conditionalOrExpression]!!, curSppfNode) - handleNonterminalEdge(descriptor, conditionalAndExpression, - state.nonterminalEdges[conditionalAndExpression]!!, curSppfNode) - } - 1 -> - { - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.OROR -> - handleTerminal(JavaToken.OROR, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, conditionalAndExpression, - state.nonterminalEdges[conditionalAndExpression]!!, curSppfNode) - } - } - } - - private fun parseconditionalAndExpression(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, inclusiveOrExpression, - state.nonterminalEdges[inclusiveOrExpression]!!, curSppfNode) - handleNonterminalEdge(descriptor, conditionalAndExpression, - state.nonterminalEdges[conditionalAndExpression]!!, curSppfNode) - } - 1 -> - { - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.ANDAND -> - handleTerminal(JavaToken.ANDAND, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, inclusiveOrExpression, - state.nonterminalEdges[inclusiveOrExpression]!!, curSppfNode) - } - } - } - - private fun parseinclusiveOrExpression(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, exclusiveOrExpression, - state.nonterminalEdges[exclusiveOrExpression]!!, curSppfNode) - handleNonterminalEdge(descriptor, inclusiveOrExpression, - state.nonterminalEdges[inclusiveOrExpression]!!, curSppfNode) - } - 1 -> - { - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.OR -> - handleTerminal(JavaToken.OR, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, exclusiveOrExpression, - state.nonterminalEdges[exclusiveOrExpression]!!, curSppfNode) - } - } - } - - private fun parseexclusiveOrExpression(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, andExpression, state.nonterminalEdges[andExpression]!!, - curSppfNode) - handleNonterminalEdge(descriptor, exclusiveOrExpression, - state.nonterminalEdges[exclusiveOrExpression]!!, curSppfNode) - } - 1 -> - { - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.XOR -> - handleTerminal(JavaToken.XOR, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, andExpression, state.nonterminalEdges[andExpression]!!, - curSppfNode) - } - } - } - - private fun parseandExpression(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, andExpression, state.nonterminalEdges[andExpression]!!, - curSppfNode) - handleNonterminalEdge(descriptor, equalityExpression, - state.nonterminalEdges[equalityExpression]!!, curSppfNode) - } - 1 -> - { - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.AND -> - handleTerminal(JavaToken.AND, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, equalityExpression, - state.nonterminalEdges[equalityExpression]!!, curSppfNode) - } - } - } - - private fun parseequalityExpression(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, relationalExpression, - state.nonterminalEdges[relationalExpression]!!, curSppfNode) - handleNonterminalEdge(descriptor, equalityExpression, - state.nonterminalEdges[equalityExpression]!!, curSppfNode) - } - 1 -> - { - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.EQEQ -> - handleTerminal(JavaToken.EQEQ, state, inputEdge, descriptor, curSppfNode) - JavaToken.NOTEQ -> - handleTerminal(JavaToken.NOTEQ, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, relationalExpression, - state.nonterminalEdges[relationalExpression]!!, curSppfNode) - } - } - } - - private fun parserelationalExpression(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, shiftExpression, - state.nonterminalEdges[shiftExpression]!!, curSppfNode) - handleNonterminalEdge(descriptor, relationalExpression, - state.nonterminalEdges[relationalExpression]!!, curSppfNode) - } - 1 -> - { - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.LTEQ -> - handleTerminal(JavaToken.LTEQ, state, inputEdge, descriptor, curSppfNode) - JavaToken.INSTANCEOF -> - handleTerminal(JavaToken.INSTANCEOF, state, inputEdge, descriptor, curSppfNode) - JavaToken.GTEQ -> - handleTerminal(JavaToken.GTEQ, state, inputEdge, descriptor, curSppfNode) - JavaToken.GT -> - handleTerminal(JavaToken.GT, state, inputEdge, descriptor, curSppfNode) - JavaToken.LT -> - handleTerminal(JavaToken.LT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, shiftExpression, - state.nonterminalEdges[shiftExpression]!!, curSppfNode) - } - 4 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, referenceType, state.nonterminalEdges[referenceType]!!, - curSppfNode) - } - } - } - - private fun parseshiftExpression(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, shiftExpression, - state.nonterminalEdges[shiftExpression]!!, curSppfNode) - handleNonterminalEdge(descriptor, additiveExpression, - state.nonterminalEdges[additiveExpression]!!, curSppfNode) - } - 1 -> - { - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.GT -> - handleTerminal(JavaToken.GT, state, inputEdge, descriptor, curSppfNode) - JavaToken.LT -> - handleTerminal(JavaToken.LT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.LT -> - handleTerminal(JavaToken.LT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 4 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.GT -> - handleTerminal(JavaToken.GT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 5 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.GT -> - handleTerminal(JavaToken.GT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, additiveExpression, - state.nonterminalEdges[additiveExpression]!!, curSppfNode) - } - 6 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, additiveExpression, - state.nonterminalEdges[additiveExpression]!!, curSppfNode) - } - } - } - - private fun parseadditiveExpression(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, additiveExpression, - state.nonterminalEdges[additiveExpression]!!, curSppfNode) - handleNonterminalEdge(descriptor, multiplicativeExpression, - state.nonterminalEdges[multiplicativeExpression]!!, curSppfNode) - } - 1 -> - { - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.PLUS -> - handleTerminal(JavaToken.PLUS, state, inputEdge, descriptor, curSppfNode) - JavaToken.MINUS -> - handleTerminal(JavaToken.MINUS, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, multiplicativeExpression, - state.nonterminalEdges[multiplicativeExpression]!!, curSppfNode) - } - } - } - - private fun parsemultiplicativeExpression(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, multiplicativeExpression, - state.nonterminalEdges[multiplicativeExpression]!!, curSppfNode) - handleNonterminalEdge(descriptor, unaryExpression, - state.nonterminalEdges[unaryExpression]!!, curSppfNode) - } - 1 -> - { - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.DIV -> - handleTerminal(JavaToken.DIV, state, inputEdge, descriptor, curSppfNode) - JavaToken.MOD -> - handleTerminal(JavaToken.MOD, state, inputEdge, descriptor, curSppfNode) - JavaToken.MULT -> - handleTerminal(JavaToken.MULT, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, unaryExpression, - state.nonterminalEdges[unaryExpression]!!, curSppfNode) - } - } - } - - private fun parsepreIncrementExpression(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.PLUSPLUS -> - handleTerminal(JavaToken.PLUSPLUS, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, unaryExpression, - state.nonterminalEdges[unaryExpression]!!, curSppfNode) - } - 2 -> - { - } - } - } - - private fun parsepreDecrementExpression(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.MINUSMINUS -> - handleTerminal(JavaToken.MINUSMINUS, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, unaryExpression, - state.nonterminalEdges[unaryExpression]!!, curSppfNode) - } - 2 -> - { - } - } - } - - private fun parseunaryExpressionNotPlusMinus(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.NOT -> - handleTerminal(JavaToken.NOT, state, inputEdge, descriptor, curSppfNode) - JavaToken.COMP -> - handleTerminal(JavaToken.COMP, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, castExpression, state.nonterminalEdges[castExpression]!!, - curSppfNode) - handleNonterminalEdge(descriptor, postfixExpression, - state.nonterminalEdges[postfixExpression]!!, curSppfNode) - } - 1 -> - { - } - 2 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, unaryExpression, - state.nonterminalEdges[unaryExpression]!!, curSppfNode) - } - } - } - - private fun parseunaryExpression(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.PLUS -> - handleTerminal(JavaToken.PLUS, state, inputEdge, descriptor, curSppfNode) - JavaToken.MINUS -> - handleTerminal(JavaToken.MINUS, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, unaryExpressionNotPlusMinus, - state.nonterminalEdges[unaryExpressionNotPlusMinus]!!, curSppfNode) - handleNonterminalEdge(descriptor, preDecrementExpression, - state.nonterminalEdges[preDecrementExpression]!!, curSppfNode) - handleNonterminalEdge(descriptor, preIncrementExpression, - state.nonterminalEdges[preIncrementExpression]!!, curSppfNode) - } - 1 -> - { - } - 2 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, unaryExpression, - state.nonterminalEdges[unaryExpression]!!, curSppfNode) - } - } - } - - private fun parsepostfixExpression(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, expressionName, state.nonterminalEdges[expressionName]!!, - curSppfNode) - handleNonterminalEdge(descriptor, postIncrementExpression, - state.nonterminalEdges[postIncrementExpression]!!, curSppfNode) - handleNonterminalEdge(descriptor, postDecrementExpression, - state.nonterminalEdges[postDecrementExpression]!!, curSppfNode) - handleNonterminalEdge(descriptor, primary, state.nonterminalEdges[primary]!!, curSppfNode) - } - 1 -> - { - } - } - } - - private fun parsepostIncrementExpression(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, postfixExpression, - state.nonterminalEdges[postfixExpression]!!, curSppfNode) - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.PLUSPLUS -> - handleTerminal(JavaToken.PLUSPLUS, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 2 -> - { - } - } - } - - private fun parsepostDecrementExpression(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, postfixExpression, - state.nonterminalEdges[postfixExpression]!!, curSppfNode) - } - 1 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.MINUSMINUS -> - handleTerminal(JavaToken.MINUSMINUS, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 2 -> - { - } - } - } - - private fun parsecastExpression(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - val pos = descriptor.inputPosition - when(state.numId) { - 0 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.LPAREN -> - handleTerminal(JavaToken.LPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 1 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, referenceType, state.nonterminalEdges[referenceType]!!, - curSppfNode) - handleNonterminalEdge(descriptor, primitiveType, state.nonterminalEdges[primitiveType]!!, - curSppfNode) - } - 2 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RPAREN -> - handleTerminal(JavaToken.RPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - } - 3 -> - { - // handle terminal edges - for (inputEdge in ctx.input.getEdges(pos)) { - when(inputEdge.label.terminal) { - JavaToken.RPAREN -> - handleTerminal(JavaToken.RPAREN, state, inputEdge, descriptor, curSppfNode) - else -> {} - } - } - // handle nonterminal edges - handleNonterminalEdge(descriptor, additionalBound, - state.nonterminalEdges[additionalBound]!!, curSppfNode) - } - 4 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, unaryExpressionNotPlusMinus, - state.nonterminalEdges[unaryExpressionNotPlusMinus]!!, curSppfNode) - handleNonterminalEdge(descriptor, lambdaExpression, - state.nonterminalEdges[lambdaExpression]!!, curSppfNode) - } - 5 -> - { - } - 6 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, unaryExpression, - state.nonterminalEdges[unaryExpression]!!, curSppfNode) - } - } - } - - private fun parseconstantExpression(descriptor: Descriptor, - curSppfNode: SppfNode?) { - val state = descriptor.rsmState - when(state.numId) { - 0 -> - { - // handle nonterminal edges - handleNonterminalEdge(descriptor, expression, state.nonterminalEdges[expression]!!, - curSppfNode) - } - 1 -> - { - } - } - } - - override fun handleDescriptor(descriptor: Descriptor) { - super.handleDescriptor(descriptor) - org.ucfs.intersection.RecoveryIntersection.handleRecoveryEdges(this, descriptor) - } - - override fun setInput(`value`: IInputGraph) { - ctx = org.ucfs.parser.context.RecoveryContext(grammar.rsm, value) - } -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/JavaToken.kt b/benchmarks/src/main/kotlin/org/ucfs/JavaToken.kt deleted file mode 100644 index 22e7115ba..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/JavaToken.kt +++ /dev/null @@ -1,141 +0,0 @@ -package org.ucfs - -import org.ucfs.parser.ParsingException -import org.ucfs.rsm.symbol.ITerminal - -enum class JavaToken : ITerminal { - IDENTIFIER, - EOF, - - - /*Literal*/ - INTEGER_LITERAL, - FLOATING_POINT_LITERAL, - BOOLEAN_LITERAL, - CHARACTER_LITERAL, - STRING_LITERAL, - NULL_LITERAL, - - - /*Keywords*/ - ABSTRACT, - ASSERT, - BOOLEAN, - BYTE, - BREAK, - CASE, - CATCH, - CHAR, - CLASS, - CONST, - CONTINUE, - DEFAULT, - DO, - DOUBLE, - ELSE, - ENUM, - EXTENDS, - FINAL, - FINALLY, - FLOAT, - FOR, - IF, - GOTO, - IMPLEMENTS, - IMPORT, - INSTANCEOF, - INT, - INTERFACE, - LONG, - NATIVE, - NEW, - PACKAGE, - PRIVATE, - PROTECTED, - PUBLIC, - RETURN, - SHORT, - STATIC, - STRICTFP, - SUPER, - SWITCH, - SYNCHRONIZED, - THIS, - THROW, - THROWS, - TRANSIENT, - TRY, - VOID, - VOLATILE, - WHILE, - - - /*SEPARATORS*/ - LPAREN, //( - RPAREN, //) - LBRACE, //{ - RBRACE, //} - LBRACK, //[ - RBRACK, //] - SEMICOLON, //; - COMMA, //, - DOT, //. - ELLIPSIS, //... - AT, //@ - COLONCOLON, //:: - - /*OPERATORS*/ - EQ, - LT, - GT, - NOT, - COMP, //~ - QUESTION, - COLON, - ARROW, - EQEQ, - LTEQ, - GTEQ, - NOTEQ, - ANDAND, - OROR, - PLUSPLUS, - MINUSMINUS, - PLUS, - MINUS, - MULT, - DIV, // / - AND, - OR, - XOR, - MOD, //% - // LSHIFT, // << - // RSHIFT, // >> - // URSHIFT, // >>> - PLUSEQ, - MINUSEQ, - MULTEQ, - DIVEQ, - ANDEQ, - OREQ, - XOREQ, - MODEQ, - LSHIFTEQ, - RSHIFTEQ, - URSHIFTEQ, - ; - - override fun getComparator(): Comparator { - return object : Comparator { - override fun compare(a: ITerminal, b: ITerminal): Int { - if (a !is JavaToken || b !is JavaToken) { - throw ParsingException( - "used comparator for $javaClass, " + - "but got elements of ${a.javaClass}$ and ${b.javaClass}\$" - ) - } - return a.ordinal - b.ordinal - } - } - } -} \ No newline at end of file diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/AdditionalBoundNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/AdditionalBoundNode.kt deleted file mode 100644 index b3f815d13..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/AdditionalBoundNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class AdditionalBoundNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/AdditiveExpressionNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/AdditiveExpressionNode.kt deleted file mode 100644 index e8fe1d130..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/AdditiveExpressionNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class AdditiveExpressionNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/AmbiguousNameNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/AmbiguousNameNode.kt deleted file mode 100644 index b645a83d4..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/AmbiguousNameNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class AmbiguousNameNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/AndExpressionNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/AndExpressionNode.kt deleted file mode 100644 index aa7004a5b..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/AndExpressionNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class AndExpressionNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/AnnotationNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/AnnotationNode.kt deleted file mode 100644 index 133fac9a6..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/AnnotationNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class AnnotationNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/AnnotationTypeBodyNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/AnnotationTypeBodyNode.kt deleted file mode 100644 index e2be87410..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/AnnotationTypeBodyNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class AnnotationTypeBodyNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/AnnotationTypeDeclarationNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/AnnotationTypeDeclarationNode.kt deleted file mode 100644 index c3e6c4d32..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/AnnotationTypeDeclarationNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class AnnotationTypeDeclarationNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/AnnotationTypeElementDeclarationNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/AnnotationTypeElementDeclarationNode.kt deleted file mode 100644 index efa568653..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/AnnotationTypeElementDeclarationNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class AnnotationTypeElementDeclarationNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/AnnotationTypeElementModifierNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/AnnotationTypeElementModifierNode.kt deleted file mode 100644 index ab2f26049..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/AnnotationTypeElementModifierNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class AnnotationTypeElementModifierNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/AnnotationTypeMemberDeclarationNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/AnnotationTypeMemberDeclarationNode.kt deleted file mode 100644 index ec0dd8d25..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/AnnotationTypeMemberDeclarationNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class AnnotationTypeMemberDeclarationNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/ArgumentListNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/ArgumentListNode.kt deleted file mode 100644 index 12e8c8711..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/ArgumentListNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class ArgumentListNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/ArrayAccessNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/ArrayAccessNode.kt deleted file mode 100644 index e71758a66..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/ArrayAccessNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class ArrayAccessNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/ArrayCreationExpressionNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/ArrayCreationExpressionNode.kt deleted file mode 100644 index 6d4800a45..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/ArrayCreationExpressionNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class ArrayCreationExpressionNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/ArrayInitializerNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/ArrayInitializerNode.kt deleted file mode 100644 index 8fade6d36..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/ArrayInitializerNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class ArrayInitializerNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/ArrayTypeNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/ArrayTypeNode.kt deleted file mode 100644 index b8089fca3..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/ArrayTypeNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class ArrayTypeNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/AssertStatementNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/AssertStatementNode.kt deleted file mode 100644 index 62da27891..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/AssertStatementNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class AssertStatementNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/AssignmentExpressionNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/AssignmentExpressionNode.kt deleted file mode 100644 index 118faf29e..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/AssignmentExpressionNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class AssignmentExpressionNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/AssignmentNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/AssignmentNode.kt deleted file mode 100644 index 853ba4130..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/AssignmentNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class AssignmentNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/AssignmentOperatorNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/AssignmentOperatorNode.kt deleted file mode 100644 index 5e312bf0c..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/AssignmentOperatorNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class AssignmentOperatorNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/BasicForStatementNoShortIfNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/BasicForStatementNoShortIfNode.kt deleted file mode 100644 index 140db0192..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/BasicForStatementNoShortIfNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class BasicForStatementNoShortIfNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/BasicForStatementNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/BasicForStatementNode.kt deleted file mode 100644 index eb515045f..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/BasicForStatementNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class BasicForStatementNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/BlockNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/BlockNode.kt deleted file mode 100644 index a2b1051f7..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/BlockNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class BlockNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/BlockStatementNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/BlockStatementNode.kt deleted file mode 100644 index 978df848a..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/BlockStatementNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class BlockStatementNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/BlockStatementsNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/BlockStatementsNode.kt deleted file mode 100644 index 47247dc97..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/BlockStatementsNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class BlockStatementsNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/BreakStatementNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/BreakStatementNode.kt deleted file mode 100644 index d982bc223..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/BreakStatementNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class BreakStatementNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/CastExpressionNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/CastExpressionNode.kt deleted file mode 100644 index 249aa0ccd..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/CastExpressionNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class CastExpressionNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/CatchClauseNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/CatchClauseNode.kt deleted file mode 100644 index 9aec602c5..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/CatchClauseNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class CatchClauseNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/CatchFormalParameterNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/CatchFormalParameterNode.kt deleted file mode 100644 index f100ecaed..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/CatchFormalParameterNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class CatchFormalParameterNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/CatchTypeNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/CatchTypeNode.kt deleted file mode 100644 index 364d604b0..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/CatchTypeNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class CatchTypeNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/CatchesNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/CatchesNode.kt deleted file mode 100644 index 5d57b7567..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/CatchesNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class CatchesNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/ClassBodyDeclarationNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/ClassBodyDeclarationNode.kt deleted file mode 100644 index 52ecbbe54..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/ClassBodyDeclarationNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class ClassBodyDeclarationNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/ClassBodyNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/ClassBodyNode.kt deleted file mode 100644 index 12cba5038..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/ClassBodyNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class ClassBodyNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/ClassDeclarationNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/ClassDeclarationNode.kt deleted file mode 100644 index 8f824702d..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/ClassDeclarationNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class ClassDeclarationNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/ClassInstanceCreationExpressionNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/ClassInstanceCreationExpressionNode.kt deleted file mode 100644 index 82fcf29b3..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/ClassInstanceCreationExpressionNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class ClassInstanceCreationExpressionNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/ClassLiteralNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/ClassLiteralNode.kt deleted file mode 100644 index 43e71b58b..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/ClassLiteralNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class ClassLiteralNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/ClassMemberDeclarationNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/ClassMemberDeclarationNode.kt deleted file mode 100644 index 1733834d6..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/ClassMemberDeclarationNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class ClassMemberDeclarationNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/ClassModifierNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/ClassModifierNode.kt deleted file mode 100644 index ec0b2dee0..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/ClassModifierNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class ClassModifierNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/ClassOrInterfaceTypeNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/ClassOrInterfaceTypeNode.kt deleted file mode 100644 index 1b0dc2570..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/ClassOrInterfaceTypeNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class ClassOrInterfaceTypeNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/ClassTypeNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/ClassTypeNode.kt deleted file mode 100644 index 174111858..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/ClassTypeNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class ClassTypeNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/CompilationUnitNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/CompilationUnitNode.kt deleted file mode 100644 index ab84a346e..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/CompilationUnitNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class CompilationUnitNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/ConditionalAndExpressionNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/ConditionalAndExpressionNode.kt deleted file mode 100644 index b719b6b3d..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/ConditionalAndExpressionNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class ConditionalAndExpressionNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/ConditionalExpressionNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/ConditionalExpressionNode.kt deleted file mode 100644 index 830854722..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/ConditionalExpressionNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class ConditionalExpressionNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/ConditionalOrExpressionNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/ConditionalOrExpressionNode.kt deleted file mode 100644 index 156243887..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/ConditionalOrExpressionNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class ConditionalOrExpressionNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/ConstantDeclarationNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/ConstantDeclarationNode.kt deleted file mode 100644 index 1c913a226..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/ConstantDeclarationNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class ConstantDeclarationNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/ConstantExpressionNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/ConstantExpressionNode.kt deleted file mode 100644 index c43f1a398..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/ConstantExpressionNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class ConstantExpressionNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/ConstantModifierNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/ConstantModifierNode.kt deleted file mode 100644 index 85f4cbaa3..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/ConstantModifierNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class ConstantModifierNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/ConstructorBodyNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/ConstructorBodyNode.kt deleted file mode 100644 index 4bdee3711..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/ConstructorBodyNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class ConstructorBodyNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/ConstructorDeclarationNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/ConstructorDeclarationNode.kt deleted file mode 100644 index 1180cfa1e..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/ConstructorDeclarationNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class ConstructorDeclarationNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/ConstructorDeclaratorNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/ConstructorDeclaratorNode.kt deleted file mode 100644 index 01aaaf4d5..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/ConstructorDeclaratorNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class ConstructorDeclaratorNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/ConstructorModifierNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/ConstructorModifierNode.kt deleted file mode 100644 index d1de5c80c..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/ConstructorModifierNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class ConstructorModifierNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/ContinueStatementNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/ContinueStatementNode.kt deleted file mode 100644 index 115223a0a..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/ContinueStatementNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class ContinueStatementNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/DefaultValueNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/DefaultValueNode.kt deleted file mode 100644 index e63be6a8c..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/DefaultValueNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class DefaultValueNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/DimExprNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/DimExprNode.kt deleted file mode 100644 index 22d51bf62..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/DimExprNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class DimExprNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/DimExprsNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/DimExprsNode.kt deleted file mode 100644 index ff24208c4..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/DimExprsNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class DimExprsNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/DimsNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/DimsNode.kt deleted file mode 100644 index a666d2e93..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/DimsNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class DimsNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/DoStatementNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/DoStatementNode.kt deleted file mode 100644 index 40aa07c7e..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/DoStatementNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class DoStatementNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/ElementValueArrayInitializerNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/ElementValueArrayInitializerNode.kt deleted file mode 100644 index 701becd9f..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/ElementValueArrayInitializerNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class ElementValueArrayInitializerNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/ElementValueListNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/ElementValueListNode.kt deleted file mode 100644 index 3dae2e432..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/ElementValueListNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class ElementValueListNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/ElementValueNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/ElementValueNode.kt deleted file mode 100644 index e9962da92..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/ElementValueNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class ElementValueNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/ElementValuePairListNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/ElementValuePairListNode.kt deleted file mode 100644 index d87a7c26c..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/ElementValuePairListNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class ElementValuePairListNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/ElementValuePairNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/ElementValuePairNode.kt deleted file mode 100644 index 2f2fd5d93..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/ElementValuePairNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class ElementValuePairNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/EmptyStatementNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/EmptyStatementNode.kt deleted file mode 100644 index 349fee518..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/EmptyStatementNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class EmptyStatementNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/EnhancedForStatementNoShortIfNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/EnhancedForStatementNoShortIfNode.kt deleted file mode 100644 index aca13e448..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/EnhancedForStatementNoShortIfNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class EnhancedForStatementNoShortIfNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/EnhancedForStatementNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/EnhancedForStatementNode.kt deleted file mode 100644 index 3f63d7ee2..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/EnhancedForStatementNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class EnhancedForStatementNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/EnumBodyDeclarationsNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/EnumBodyDeclarationsNode.kt deleted file mode 100644 index b420f7227..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/EnumBodyDeclarationsNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class EnumBodyDeclarationsNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/EnumBodyNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/EnumBodyNode.kt deleted file mode 100644 index 454caddea..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/EnumBodyNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class EnumBodyNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/EnumConstantListNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/EnumConstantListNode.kt deleted file mode 100644 index 3f7d1671f..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/EnumConstantListNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class EnumConstantListNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/EnumConstantModifierNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/EnumConstantModifierNode.kt deleted file mode 100644 index 5598360da..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/EnumConstantModifierNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class EnumConstantModifierNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/EnumConstantNameNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/EnumConstantNameNode.kt deleted file mode 100644 index 63e7d6364..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/EnumConstantNameNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class EnumConstantNameNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/EnumConstantNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/EnumConstantNode.kt deleted file mode 100644 index 2df87c23d..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/EnumConstantNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class EnumConstantNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/EnumDeclarationNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/EnumDeclarationNode.kt deleted file mode 100644 index 83d10b116..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/EnumDeclarationNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class EnumDeclarationNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/EqualityExpressionNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/EqualityExpressionNode.kt deleted file mode 100644 index 669c4d453..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/EqualityExpressionNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class EqualityExpressionNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/ExceptionTypeListNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/ExceptionTypeListNode.kt deleted file mode 100644 index 738efb3ce..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/ExceptionTypeListNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class ExceptionTypeListNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/ExceptionTypeNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/ExceptionTypeNode.kt deleted file mode 100644 index 41e372323..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/ExceptionTypeNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class ExceptionTypeNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/ExclusiveOrExpressionNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/ExclusiveOrExpressionNode.kt deleted file mode 100644 index ca5cd8a41..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/ExclusiveOrExpressionNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class ExclusiveOrExpressionNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/ExplicitConstructorInvocationNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/ExplicitConstructorInvocationNode.kt deleted file mode 100644 index b31e0cd6e..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/ExplicitConstructorInvocationNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class ExplicitConstructorInvocationNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/ExpressionNameNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/ExpressionNameNode.kt deleted file mode 100644 index ebda33bbf..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/ExpressionNameNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class ExpressionNameNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/ExpressionNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/ExpressionNode.kt deleted file mode 100644 index 940032f81..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/ExpressionNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class ExpressionNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/ExpressionStatementNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/ExpressionStatementNode.kt deleted file mode 100644 index 838a64934..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/ExpressionStatementNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class ExpressionStatementNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/ExtendsInterfacesNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/ExtendsInterfacesNode.kt deleted file mode 100644 index ea31ad4ee..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/ExtendsInterfacesNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class ExtendsInterfacesNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/FieldAccessNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/FieldAccessNode.kt deleted file mode 100644 index dbb01d625..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/FieldAccessNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class FieldAccessNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/FieldDeclarationNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/FieldDeclarationNode.kt deleted file mode 100644 index 67eb602f6..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/FieldDeclarationNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class FieldDeclarationNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/FieldModifierNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/FieldModifierNode.kt deleted file mode 100644 index 469807d6a..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/FieldModifierNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class FieldModifierNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/FinallyNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/FinallyNode.kt deleted file mode 100644 index 84cb69834..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/FinallyNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class FinallyNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/FloatingPointTypeNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/FloatingPointTypeNode.kt deleted file mode 100644 index 3eb98cbba..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/FloatingPointTypeNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class FloatingPointTypeNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/ForInitNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/ForInitNode.kt deleted file mode 100644 index dc4c6c092..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/ForInitNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class ForInitNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/ForStatementNoShortIfNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/ForStatementNoShortIfNode.kt deleted file mode 100644 index a07549fab..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/ForStatementNoShortIfNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class ForStatementNoShortIfNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/ForStatementNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/ForStatementNode.kt deleted file mode 100644 index 484d12d1f..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/ForStatementNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class ForStatementNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/ForUpdateNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/ForUpdateNode.kt deleted file mode 100644 index f64143ee9..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/ForUpdateNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class ForUpdateNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/FormalParameterListNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/FormalParameterListNode.kt deleted file mode 100644 index 8a5ddda55..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/FormalParameterListNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class FormalParameterListNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/FormalParameterNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/FormalParameterNode.kt deleted file mode 100644 index 05c97cf86..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/FormalParameterNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class FormalParameterNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/FormalParametersNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/FormalParametersNode.kt deleted file mode 100644 index 433403768..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/FormalParametersNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class FormalParametersNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/IdentifierNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/IdentifierNode.kt deleted file mode 100644 index c5d712b09..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/IdentifierNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class IdentifierNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/IfThenElseStatementNoShortIfNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/IfThenElseStatementNoShortIfNode.kt deleted file mode 100644 index 1da59045a..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/IfThenElseStatementNoShortIfNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class IfThenElseStatementNoShortIfNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/IfThenElseStatementNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/IfThenElseStatementNode.kt deleted file mode 100644 index 8edd3fb6a..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/IfThenElseStatementNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class IfThenElseStatementNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/IfThenStatementNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/IfThenStatementNode.kt deleted file mode 100644 index 955429e87..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/IfThenStatementNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class IfThenStatementNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/ImportDeclarationNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/ImportDeclarationNode.kt deleted file mode 100644 index 9500c16c8..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/ImportDeclarationNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class ImportDeclarationNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/InclusiveOrExpressionNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/InclusiveOrExpressionNode.kt deleted file mode 100644 index e84921a34..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/InclusiveOrExpressionNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class InclusiveOrExpressionNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/InferredFormalParameterListNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/InferredFormalParameterListNode.kt deleted file mode 100644 index 9dc006af3..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/InferredFormalParameterListNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class InferredFormalParameterListNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/InstanceInitializerNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/InstanceInitializerNode.kt deleted file mode 100644 index bf2d4ae42..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/InstanceInitializerNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class InstanceInitializerNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/IntegralTypeNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/IntegralTypeNode.kt deleted file mode 100644 index 6c79174e7..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/IntegralTypeNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class IntegralTypeNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/InterfaceBodyNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/InterfaceBodyNode.kt deleted file mode 100644 index a46117b66..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/InterfaceBodyNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class InterfaceBodyNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/InterfaceDeclarationNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/InterfaceDeclarationNode.kt deleted file mode 100644 index c15375ee6..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/InterfaceDeclarationNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class InterfaceDeclarationNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/InterfaceMemberDeclarationNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/InterfaceMemberDeclarationNode.kt deleted file mode 100644 index d10a7ca4a..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/InterfaceMemberDeclarationNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class InterfaceMemberDeclarationNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/InterfaceMethodDeclarationNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/InterfaceMethodDeclarationNode.kt deleted file mode 100644 index 2834da498..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/InterfaceMethodDeclarationNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class InterfaceMethodDeclarationNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/InterfaceMethodModifierNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/InterfaceMethodModifierNode.kt deleted file mode 100644 index 7b90d35b8..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/InterfaceMethodModifierNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class InterfaceMethodModifierNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/InterfaceModifierNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/InterfaceModifierNode.kt deleted file mode 100644 index 3bfcbbf62..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/InterfaceModifierNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class InterfaceModifierNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/InterfaceTypeListNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/InterfaceTypeListNode.kt deleted file mode 100644 index 1ff315e2d..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/InterfaceTypeListNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class InterfaceTypeListNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/InterfaceTypeNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/InterfaceTypeNode.kt deleted file mode 100644 index 2dc2c32c1..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/InterfaceTypeNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class InterfaceTypeNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/LabeledStatementNoShortIfNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/LabeledStatementNoShortIfNode.kt deleted file mode 100644 index f4327984c..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/LabeledStatementNoShortIfNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class LabeledStatementNoShortIfNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/LabeledStatementNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/LabeledStatementNode.kt deleted file mode 100644 index d9bd07aff..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/LabeledStatementNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class LabeledStatementNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/LambdaBodyNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/LambdaBodyNode.kt deleted file mode 100644 index 60c09bfce..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/LambdaBodyNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class LambdaBodyNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/LambdaExpressionNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/LambdaExpressionNode.kt deleted file mode 100644 index 91ad4adaa..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/LambdaExpressionNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class LambdaExpressionNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/LambdaParametersNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/LambdaParametersNode.kt deleted file mode 100644 index 36fe1452e..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/LambdaParametersNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class LambdaParametersNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/LastFormalParameterNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/LastFormalParameterNode.kt deleted file mode 100644 index 160268657..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/LastFormalParameterNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class LastFormalParameterNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/LeftHandSideNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/LeftHandSideNode.kt deleted file mode 100644 index 7885ff07c..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/LeftHandSideNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class LeftHandSideNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/LiteralNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/LiteralNode.kt deleted file mode 100644 index 14d24d739..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/LiteralNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class LiteralNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/LocalVariableDeclarationNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/LocalVariableDeclarationNode.kt deleted file mode 100644 index 13b8876f2..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/LocalVariableDeclarationNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class LocalVariableDeclarationNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/LocalVariableDeclarationStatementNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/LocalVariableDeclarationStatementNode.kt deleted file mode 100644 index c1a363f1c..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/LocalVariableDeclarationStatementNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class LocalVariableDeclarationStatementNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/MarkerAnnotationNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/MarkerAnnotationNode.kt deleted file mode 100644 index 19e6757fd..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/MarkerAnnotationNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class MarkerAnnotationNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/MethodBodyNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/MethodBodyNode.kt deleted file mode 100644 index 1174eb55a..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/MethodBodyNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class MethodBodyNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/MethodDeclarationNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/MethodDeclarationNode.kt deleted file mode 100644 index 4311a9247..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/MethodDeclarationNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class MethodDeclarationNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/MethodDeclaratorNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/MethodDeclaratorNode.kt deleted file mode 100644 index 88b15b184..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/MethodDeclaratorNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class MethodDeclaratorNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/MethodHeaderNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/MethodHeaderNode.kt deleted file mode 100644 index 1c637fa2c..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/MethodHeaderNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class MethodHeaderNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/MethodInvocationNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/MethodInvocationNode.kt deleted file mode 100644 index ee167325d..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/MethodInvocationNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class MethodInvocationNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/MethodModifierNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/MethodModifierNode.kt deleted file mode 100644 index 7b8aaa622..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/MethodModifierNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class MethodModifierNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/MethodNameNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/MethodNameNode.kt deleted file mode 100644 index 1fd8367d5..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/MethodNameNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class MethodNameNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/MethodReferenceNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/MethodReferenceNode.kt deleted file mode 100644 index 58ec328d8..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/MethodReferenceNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class MethodReferenceNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/MultiplicativeExpressionNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/MultiplicativeExpressionNode.kt deleted file mode 100644 index 60fb3b992..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/MultiplicativeExpressionNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class MultiplicativeExpressionNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/NormalAnnotationNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/NormalAnnotationNode.kt deleted file mode 100644 index 150f8acfb..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/NormalAnnotationNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class NormalAnnotationNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/NormalClassDeclarationNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/NormalClassDeclarationNode.kt deleted file mode 100644 index 507bc740c..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/NormalClassDeclarationNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class NormalClassDeclarationNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/NormalInterfaceDeclarationNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/NormalInterfaceDeclarationNode.kt deleted file mode 100644 index 4485a4502..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/NormalInterfaceDeclarationNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class NormalInterfaceDeclarationNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/NumericTypeNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/NumericTypeNode.kt deleted file mode 100644 index f1024a098..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/NumericTypeNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class NumericTypeNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/PackageDeclarationNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/PackageDeclarationNode.kt deleted file mode 100644 index e4d17f3d9..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/PackageDeclarationNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class PackageDeclarationNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/PackageModifierNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/PackageModifierNode.kt deleted file mode 100644 index c4c53b9dc..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/PackageModifierNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class PackageModifierNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/PackageNameNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/PackageNameNode.kt deleted file mode 100644 index eae277938..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/PackageNameNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class PackageNameNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/PackageOrTypeNameNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/PackageOrTypeNameNode.kt deleted file mode 100644 index f0038b29f..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/PackageOrTypeNameNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class PackageOrTypeNameNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/PostDecrementExpressionNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/PostDecrementExpressionNode.kt deleted file mode 100644 index 3a04bb185..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/PostDecrementExpressionNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class PostDecrementExpressionNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/PostIncrementExpressionNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/PostIncrementExpressionNode.kt deleted file mode 100644 index 7e0329142..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/PostIncrementExpressionNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class PostIncrementExpressionNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/PostfixExpressionNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/PostfixExpressionNode.kt deleted file mode 100644 index e5c6b303e..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/PostfixExpressionNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class PostfixExpressionNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/PreDecrementExpressionNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/PreDecrementExpressionNode.kt deleted file mode 100644 index 0cc31c6c0..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/PreDecrementExpressionNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class PreDecrementExpressionNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/PreIncrementExpressionNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/PreIncrementExpressionNode.kt deleted file mode 100644 index 3feccc98c..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/PreIncrementExpressionNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class PreIncrementExpressionNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/PrimaryNoNewArrayNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/PrimaryNoNewArrayNode.kt deleted file mode 100644 index d7d28757e..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/PrimaryNoNewArrayNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class PrimaryNoNewArrayNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/PrimaryNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/PrimaryNode.kt deleted file mode 100644 index 7b5139137..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/PrimaryNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class PrimaryNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/PrimitiveTypeNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/PrimitiveTypeNode.kt deleted file mode 100644 index 7ed2ae42b..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/PrimitiveTypeNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class PrimitiveTypeNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/ReceiverParameterNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/ReceiverParameterNode.kt deleted file mode 100644 index 211bf8113..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/ReceiverParameterNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class ReceiverParameterNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/ReferenceTypeNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/ReferenceTypeNode.kt deleted file mode 100644 index 0a6641f95..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/ReferenceTypeNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class ReferenceTypeNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/RelationalExpressionNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/RelationalExpressionNode.kt deleted file mode 100644 index f3923a551..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/RelationalExpressionNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class RelationalExpressionNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/ResourceListNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/ResourceListNode.kt deleted file mode 100644 index dc126a5b1..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/ResourceListNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class ResourceListNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/ResourceNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/ResourceNode.kt deleted file mode 100644 index 3cbf5da98..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/ResourceNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class ResourceNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/ResourceSpecificationNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/ResourceSpecificationNode.kt deleted file mode 100644 index ca07f616b..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/ResourceSpecificationNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class ResourceSpecificationNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/ResultNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/ResultNode.kt deleted file mode 100644 index af9bfbc77..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/ResultNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class ResultNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/ReturnStatementNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/ReturnStatementNode.kt deleted file mode 100644 index 02ce51c51..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/ReturnStatementNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class ReturnStatementNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/ShiftExpressionNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/ShiftExpressionNode.kt deleted file mode 100644 index f13b40256..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/ShiftExpressionNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class ShiftExpressionNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/SimpleTypeNameNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/SimpleTypeNameNode.kt deleted file mode 100644 index 3fa663977..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/SimpleTypeNameNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class SimpleTypeNameNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/SingleElementAnnotationNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/SingleElementAnnotationNode.kt deleted file mode 100644 index 2b688f399..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/SingleElementAnnotationNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class SingleElementAnnotationNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/SingleStaticImportDeclarationNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/SingleStaticImportDeclarationNode.kt deleted file mode 100644 index 32fb724bf..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/SingleStaticImportDeclarationNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class SingleStaticImportDeclarationNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/SingleTypeImportDeclarationNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/SingleTypeImportDeclarationNode.kt deleted file mode 100644 index e5865efad..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/SingleTypeImportDeclarationNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class SingleTypeImportDeclarationNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/StatementExpressionListNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/StatementExpressionListNode.kt deleted file mode 100644 index 898f471e5..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/StatementExpressionListNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class StatementExpressionListNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/StatementExpressionNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/StatementExpressionNode.kt deleted file mode 100644 index 205992200..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/StatementExpressionNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class StatementExpressionNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/StatementNoShortIfNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/StatementNoShortIfNode.kt deleted file mode 100644 index 12128b7f9..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/StatementNoShortIfNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class StatementNoShortIfNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/StatementNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/StatementNode.kt deleted file mode 100644 index 9300340ee..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/StatementNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class StatementNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/StatementWithoutTrailingSubstatementNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/StatementWithoutTrailingSubstatementNode.kt deleted file mode 100644 index aea92a033..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/StatementWithoutTrailingSubstatementNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class StatementWithoutTrailingSubstatementNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/StaticImportOnDemandDeclarationNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/StaticImportOnDemandDeclarationNode.kt deleted file mode 100644 index 8e20b5454..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/StaticImportOnDemandDeclarationNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class StaticImportOnDemandDeclarationNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/StaticInitializerNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/StaticInitializerNode.kt deleted file mode 100644 index effe06e97..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/StaticInitializerNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class StaticInitializerNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/SuperclassNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/SuperclassNode.kt deleted file mode 100644 index fb3e6dfde..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/SuperclassNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class SuperclassNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/SuperinterfacesNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/SuperinterfacesNode.kt deleted file mode 100644 index 144baad23..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/SuperinterfacesNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class SuperinterfacesNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/SwitchBlockNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/SwitchBlockNode.kt deleted file mode 100644 index 8bd22f917..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/SwitchBlockNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class SwitchBlockNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/SwitchBlockStatementGroupNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/SwitchBlockStatementGroupNode.kt deleted file mode 100644 index 3a8520d6b..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/SwitchBlockStatementGroupNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class SwitchBlockStatementGroupNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/SwitchLabelNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/SwitchLabelNode.kt deleted file mode 100644 index 400652ebc..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/SwitchLabelNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class SwitchLabelNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/SwitchLabelsNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/SwitchLabelsNode.kt deleted file mode 100644 index 27883b82a..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/SwitchLabelsNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class SwitchLabelsNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/SwitchStatementNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/SwitchStatementNode.kt deleted file mode 100644 index 99d6fc6d8..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/SwitchStatementNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class SwitchStatementNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/SynchronizedStatementNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/SynchronizedStatementNode.kt deleted file mode 100644 index 4101b1f70..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/SynchronizedStatementNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class SynchronizedStatementNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/ThrowStatementNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/ThrowStatementNode.kt deleted file mode 100644 index 6e1ab8e9b..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/ThrowStatementNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class ThrowStatementNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/ThrowsNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/ThrowsNode.kt deleted file mode 100644 index 40510a8f5..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/ThrowsNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class ThrowsNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/TryStatementNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/TryStatementNode.kt deleted file mode 100644 index 226610bbd..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/TryStatementNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class TryStatementNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/TryWithResourcesStatementNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/TryWithResourcesStatementNode.kt deleted file mode 100644 index 718d21dd7..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/TryWithResourcesStatementNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class TryWithResourcesStatementNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/TypeArgumentListNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/TypeArgumentListNode.kt deleted file mode 100644 index 80aaaf96a..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/TypeArgumentListNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class TypeArgumentListNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/TypeArgumentNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/TypeArgumentNode.kt deleted file mode 100644 index 07f514746..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/TypeArgumentNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class TypeArgumentNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/TypeArgumentsNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/TypeArgumentsNode.kt deleted file mode 100644 index ea44d42ea..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/TypeArgumentsNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class TypeArgumentsNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/TypeArgumentsOrDiamondNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/TypeArgumentsOrDiamondNode.kt deleted file mode 100644 index 577e6ffed..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/TypeArgumentsOrDiamondNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class TypeArgumentsOrDiamondNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/TypeBoundNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/TypeBoundNode.kt deleted file mode 100644 index 4fd1c0fe4..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/TypeBoundNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class TypeBoundNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/TypeDeclarationNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/TypeDeclarationNode.kt deleted file mode 100644 index 0eb038188..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/TypeDeclarationNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class TypeDeclarationNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/TypeImportOnDemandDeclarationNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/TypeImportOnDemandDeclarationNode.kt deleted file mode 100644 index 0817f34f2..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/TypeImportOnDemandDeclarationNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class TypeImportOnDemandDeclarationNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/TypeNameNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/TypeNameNode.kt deleted file mode 100644 index 389122be4..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/TypeNameNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class TypeNameNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/TypeNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/TypeNode.kt deleted file mode 100644 index 3c10a7bdf..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/TypeNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class TypeNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/TypeParameterListNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/TypeParameterListNode.kt deleted file mode 100644 index 6bfa42c40..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/TypeParameterListNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class TypeParameterListNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/TypeParameterModifierNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/TypeParameterModifierNode.kt deleted file mode 100644 index 617d7504b..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/TypeParameterModifierNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class TypeParameterModifierNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/TypeParameterNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/TypeParameterNode.kt deleted file mode 100644 index 1972f3d37..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/TypeParameterNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class TypeParameterNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/TypeParametersNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/TypeParametersNode.kt deleted file mode 100644 index 5ee6b192d..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/TypeParametersNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class TypeParametersNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/TypeVariableNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/TypeVariableNode.kt deleted file mode 100644 index 3964144ba..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/TypeVariableNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class TypeVariableNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/UnannArrayTypeNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/UnannArrayTypeNode.kt deleted file mode 100644 index c2278a181..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/UnannArrayTypeNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class UnannArrayTypeNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/UnannClassOrInterfaceTypeNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/UnannClassOrInterfaceTypeNode.kt deleted file mode 100644 index a7d417913..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/UnannClassOrInterfaceTypeNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class UnannClassOrInterfaceTypeNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/UnannClassTypeNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/UnannClassTypeNode.kt deleted file mode 100644 index a8683d364..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/UnannClassTypeNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class UnannClassTypeNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/UnannInterfaceTypeNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/UnannInterfaceTypeNode.kt deleted file mode 100644 index 88f78f1bd..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/UnannInterfaceTypeNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class UnannInterfaceTypeNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/UnannPrimitiveTypeNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/UnannPrimitiveTypeNode.kt deleted file mode 100644 index 79ce09411..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/UnannPrimitiveTypeNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class UnannPrimitiveTypeNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/UnannReferenceTypeNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/UnannReferenceTypeNode.kt deleted file mode 100644 index 775da4c51..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/UnannReferenceTypeNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class UnannReferenceTypeNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/UnannTypeNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/UnannTypeNode.kt deleted file mode 100644 index d168f97c8..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/UnannTypeNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class UnannTypeNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/UnannTypeVariableNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/UnannTypeVariableNode.kt deleted file mode 100644 index 756dc0a5b..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/UnannTypeVariableNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class UnannTypeVariableNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/UnaryExpressionNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/UnaryExpressionNode.kt deleted file mode 100644 index faa0c3d21..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/UnaryExpressionNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class UnaryExpressionNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/UnaryExpressionNotPlusMinusNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/UnaryExpressionNotPlusMinusNode.kt deleted file mode 100644 index 947450ced..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/UnaryExpressionNotPlusMinusNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class UnaryExpressionNotPlusMinusNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/UnqualifiedClassInstanceCreationExpressionNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/UnqualifiedClassInstanceCreationExpressionNode.kt deleted file mode 100644 index b04f84922..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/UnqualifiedClassInstanceCreationExpressionNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class UnqualifiedClassInstanceCreationExpressionNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/VariableDeclaratorIdNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/VariableDeclaratorIdNode.kt deleted file mode 100644 index 2725db344..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/VariableDeclaratorIdNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class VariableDeclaratorIdNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/VariableDeclaratorListNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/VariableDeclaratorListNode.kt deleted file mode 100644 index 6b78d37d5..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/VariableDeclaratorListNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class VariableDeclaratorListNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/VariableDeclaratorNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/VariableDeclaratorNode.kt deleted file mode 100644 index 9fc775a97..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/VariableDeclaratorNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class VariableDeclaratorNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/VariableInitializerListNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/VariableInitializerListNode.kt deleted file mode 100644 index 7c6e6022e..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/VariableInitializerListNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class VariableInitializerListNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/VariableInitializerNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/VariableInitializerNode.kt deleted file mode 100644 index 6d5151ceb..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/VariableInitializerNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class VariableInitializerNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/VariableModifierNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/VariableModifierNode.kt deleted file mode 100644 index 8df24b3d4..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/VariableModifierNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class VariableModifierNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/WhileStatementNoShortIfNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/WhileStatementNoShortIfNode.kt deleted file mode 100644 index d7693c538..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/WhileStatementNoShortIfNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class WhileStatementNoShortIfNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/WhileStatementNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/WhileStatementNode.kt deleted file mode 100644 index 02d819f26..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/WhileStatementNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class WhileStatementNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/WildcardBoundsNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/WildcardBoundsNode.kt deleted file mode 100644 index 2e48d514f..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/WildcardBoundsNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class WildcardBoundsNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/WildcardNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/WildcardNode.kt deleted file mode 100644 index 8ffa41a8c..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/WildcardNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class WildcardNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/nodes/classOrInterfaceTypeToInstantiateNode.kt b/benchmarks/src/main/kotlin/org/ucfs/nodes/classOrInterfaceTypeToInstantiateNode.kt deleted file mode 100644 index 06710e50d..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/nodes/classOrInterfaceTypeToInstantiateNode.kt +++ /dev/null @@ -1,10 +0,0 @@ -@file:Suppress("RedundantVisibilityModifier") - -package org.ucfs.nodes - -import kotlin.Int -import org.ucfs.ast.Node - -public class classOrInterfaceTypeToInstantiateNode : Node { - public constructor(parent: Node, offset: Int) : super(parent, offset) -} diff --git a/benchmarks/src/main/kotlin/org/ucfs/simple/SimpleGrammar.kt b/benchmarks/src/main/kotlin/org/ucfs/simple/SimpleGrammar.kt deleted file mode 100644 index 906b1b39b..000000000 --- a/benchmarks/src/main/kotlin/org/ucfs/simple/SimpleGrammar.kt +++ /dev/null @@ -1,20 +0,0 @@ -package org.ucfs.simple - -import org.ucfs.grammar.combinator.Grammar -import org.ucfs.grammar.combinator.regexp.* -import org.ucfs.rsm.symbol.Term - -class SimpleGrammar: Grammar() { - val a = Term("a") - val b = Term("b") - val c = Term("c") - val S by Nt().asStart() - init{ - //compilationUnit /= Option(packageDeclaration) * Many(importDeclaration) * Many(typeDeclaration) - //S /= Option(b) * (a * b or a * S * b) - //S /= a * b - S /= c - //S /= a * b - // S /= a * S * b or a * S or c - } -} \ No newline at end of file diff --git a/benchmarks/src/test/kotlin/AntlrBenchmark.kt b/benchmarks/src/test/kotlin/AntlrBenchmark.kt deleted file mode 100644 index 73259039c..000000000 --- a/benchmarks/src/test/kotlin/AntlrBenchmark.kt +++ /dev/null @@ -1,39 +0,0 @@ -import org.antlr.Java8Lexer -import org.antlr.Java8Parser -import org.antlr.v4.runtime.CharStreams -import org.antlr.v4.runtime.CommonTokenStream -import java.io.File - -fun main(args: Array) { - try { - AntlrBenchmark().parse(File(args[0]).readText()) - } catch (e: Throwable) { - println(e) - System.exit(1) - } -} - -class AntlrBenchmark : ParsingBenchmarks() { - - override fun getShortName(): String = "Antlr" - - @Override - override fun parse(text: String) { - var x = 30 - while (x-- > 0) { - val antlrParser = Java8Parser( - CommonTokenStream( - Java8Lexer( - CharStreams.fromString(text) - ) - ) - ) - try { - antlrParser.compilationUnit() - } catch (e: Exception) { - print(e) - } - } - } -} - diff --git a/benchmarks/src/test/kotlin/AntlrFastBenchmark.kt b/benchmarks/src/test/kotlin/AntlrFastBenchmark.kt deleted file mode 100644 index 8d14079a6..000000000 --- a/benchmarks/src/test/kotlin/AntlrFastBenchmark.kt +++ /dev/null @@ -1,80 +0,0 @@ -import org.antlr.Java8Lexer -import org.antlr.fast.JavaLexer -import org.antlr.fast.JavaParser -import org.antlr.v4.runtime.CharStreams -import org.antlr.v4.runtime.CommonTokenStream -import org.junit.jupiter.api.Disabled -import org.junit.jupiter.api.DynamicTest -import org.junit.jupiter.api.DynamicTest.dynamicTest -import org.junit.jupiter.api.TestFactory -import org.junit.jupiter.api.Timeout -import java.io.File -import java.nio.file.Files -import java.nio.file.Path - -fun main(args: Array) { - try { - AntlrFastBenchmark().parse(File(args[0]).readText()) - } catch (e: Throwable) { - println(e) - System.exit(1) - } -} - -class AntlrFastBenchmark : ParsingBenchmarks() { - - override fun getShortName(): String = "AntlrFast" - - fun main(args: Array) { - parse(File(args[0]).readText()) - } - - @Override - override fun parse(text: String) { - val antlrParser = - JavaParser( - CommonTokenStream( - JavaLexer( - CharStreams.fromString(text) - ) - ) - ) - try { - var compilationUnit = antlrParser.compilationUnit() - } catch (e: Exception) { - print(e) - } - } - - fun getTokenCount(text: String): Int { - val tokenStream = CommonTokenStream( - Java8Lexer( - CharStreams.fromString(text) - ) - ) - tokenStream.fill() - return tokenStream.getTokens().size - } - - var sum_count: Int = 0 - val fileName = "tokens_count.csv" - - @Disabled - @TestFactory - @Timeout(100) - fun getTokensCount(): Collection { - File(fileName).writeText("filename,tokens\n") - return getTests(getResource(resourceFolder.toString())) - } - - private fun getTests(folder: Path): Collection { - return Files.list(folder).sorted().map { file -> - dynamicTest(file.fileName.toString()) { - val source = file.toFile().readText() - val count = getTokenCount(source) - sum_count += count - File(fileName).appendText("${file.fileName},${count}\n") - } - }.toList() - } -} \ No newline at end of file diff --git a/benchmarks/src/test/kotlin/OfflineUcfsBenchmark.kt b/benchmarks/src/test/kotlin/OfflineUcfsBenchmark.kt deleted file mode 100644 index 298f0ec08..000000000 --- a/benchmarks/src/test/kotlin/OfflineUcfsBenchmark.kt +++ /dev/null @@ -1,26 +0,0 @@ -import org.ucfs.input.TerminalInputLabel -import java.io.File - -fun main(args: Array) { - try { - OfflineUcfsBenchmark().parse(File(args[0]).readText()) - } catch (e: Throwable) { - println(e) - System.exit(1) - } -} - -class OfflineUcfsBenchmark : ParsingBenchmarks() { - override fun getShortName(): String = "UcfsOff" - - fun main(args: Array) { - parse(File(args[0]).readText()) - } - - override fun parse(text: String) { - val parser = org.ucfs.Java8Parser() - parser.setInput(getTokenStream(text)) - parser.parse() - assert(parser.parse().first != null) - } -} \ No newline at end of file diff --git a/benchmarks/src/test/kotlin/OnlineUcfsBenchmark.kt b/benchmarks/src/test/kotlin/OnlineUcfsBenchmark.kt deleted file mode 100644 index f3647689c..000000000 --- a/benchmarks/src/test/kotlin/OnlineUcfsBenchmark.kt +++ /dev/null @@ -1,28 +0,0 @@ -import org.ucfs.Java8 -import org.ucfs.parser.Gll -import org.ucfs.sppf.writeSppfToDot -import java.io.File - -class OnlineUcfsBenchmark : ParsingBenchmarks() { - override fun getShortName(): String = "UcfsOn" - - override fun parse(text: String) { - val startState = Java8().rsm - val tokens = getTokenStream(text) - val gll = Gll.gll(startState, tokens) - assert(gll.parse().first != null) { "can't build sppf" } - } - - - fun parseOne(sourceCode: String) { - val startState = Java8().rsm - val tokens = getTokenStream(sourceCode) - val gll = Gll.gll(startState, tokens) - val sppf = gll.parse().first - assert(sppf != null) { "can't build sppf" } - writeSppfToDot(sppf!!, "sppf.dot") - } - - fun getSourceCode(path : String): String = - File(path).readText() -} \ No newline at end of file diff --git a/benchmarks/src/test/kotlin/ParsingBenchmarks.kt b/benchmarks/src/test/kotlin/ParsingBenchmarks.kt deleted file mode 100644 index c5ad685cf..000000000 --- a/benchmarks/src/test/kotlin/ParsingBenchmarks.kt +++ /dev/null @@ -1,115 +0,0 @@ -import org.junit.jupiter.api.* -import org.junit.jupiter.api.DynamicTest.dynamicTest -import java.io.File -import java.nio.file.Files -import java.nio.file.Path -import java.time.Duration.ofSeconds -import java.time.LocalDateTime -import java.time.format.DateTimeFormatter -import kotlin.io.path.name -import kotlin.math.max - -abstract class ParsingBenchmarks { - val version: String = LocalDateTime.now().format( - DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm") - ) - private val timePerTestCase: Long = 400 - private val repeatCount: Int = 10 - lateinit var file: File - - val datasetName = "junit-4-12" - //val datasetName = "rxjava-2-2-2" - - val resourceFolder: Path = Path.of("java", "correct", datasetName) - private lateinit var csvFileName: String - private val memoryMeasurement = "Mb" - private val memoryDivider: Long = 1024 * 1024 - - private fun initFolder(): DynamicTest { - val resultPath = Path.of("src", "test", "result", getShortName()) - return dynamicTest("initiation for ${getShortName()}") { - Files.createDirectories(resultPath) - csvFileName = "${getShortName()}_${resourceFolder.joinToString("_")}.csv" - file = File(resultPath.toString(), csvFileName) - file.createNewFile() - file.writeText("% Time benchmark for ${getShortName()} on dataset $resourceFolder at $version\n") - file.writeText("fileName,processing_tim_avg_${repeatCount}_times_millis,max_heap_size_mb$memoryMeasurement") - } - } - - - abstract fun getShortName(): String - - private fun getHeapSize(): Long = Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory() - - private fun getPrintableHeapSize(heapSize: Long? = null): String { - return String.format("%.2f", (heapSize ?: getHeapSize()) * 1.0 / memoryDivider) - .trimEnd('0').trimEnd('.') - } - - private fun getMeanTime(text: String): Pair { - var meanTimeResult = 0.0 - var maxMemoryUsage: Long = 0 - - for (i in 0..repeatCount) { - System.gc() - val startTime = System.currentTimeMillis() - parse(text) - meanTimeResult += System.currentTimeMillis() - startTime - maxMemoryUsage = max(maxMemoryUsage, getHeapSize()) - } - - meanTimeResult /= repeatCount - return Pair(meanTimeResult, maxMemoryUsage) - } - - private fun measureTimeWithTimeout(fileName: String, text: String) { - Assertions.assertTimeoutPreemptively(ofSeconds(timePerTestCase), { - try { - val result = getMeanTime(text) - report(fileName, result.first.toString(), getPrintableHeapSize(result.second)) - } catch (e: Exception) { - report(fileName, e.javaClass.name, getPrintableHeapSize()) - assert(false) { e.toString() } - } catch (e: OutOfMemoryError) { - System.gc() - report(fileName, e.javaClass.name, "OOM") - } - }, { - report(fileName, "timeout", getPrintableHeapSize()) - "$fileName failed with timeout" - }) - } - - private fun report(fileName: String, result: String, usedMemory: String = "not measured") { - val message = "$fileName,$result,$usedMemory" - println(message) - file.appendText("\n$message") - } - - abstract fun parse(text: String) - - fun getResource(resourceFolder: String): Path { - val res = ParsingBenchmarks::class.java.getResource(resourceFolder) - ?: throw RuntimeException("No resource '$resourceFolder'") - return Path.of(res.toURI()) - } - - @Disabled("Disable for running on CI") - @TestFactory - @Timeout(100) - fun timeTest(): Collection { - return getTests(getResource(resourceFolder.toString()), ::measureTimeWithTimeout) - } - - private fun getTests(folder: Path, run: (String, String) -> Unit): Collection { - return listOf(initFolder()) + Files.list(folder).sorted().map { file -> - dynamicTest(file.fileName.toString()) { - val source = file.toFile().readText() - run(file.name, source) - } - }.toList() - } - -} - diff --git a/benchmarks/src/test/kotlin/RecoveryOfflineUcfsBenchmark.kt b/benchmarks/src/test/kotlin/RecoveryOfflineUcfsBenchmark.kt deleted file mode 100644 index 66399eec2..000000000 --- a/benchmarks/src/test/kotlin/RecoveryOfflineUcfsBenchmark.kt +++ /dev/null @@ -1,12 +0,0 @@ -import org.ucfs.input.TerminalInputLabel -import kotlin.test.Ignore - -@Ignore -class RecoveryOfflineUcfsBenchmark : ParsingBenchmarks() { - override fun getShortName(): String = "RecUcfsOff" - override fun parse(text: String) { - val parser = org.ucfs.Java8ParserRecovery() - parser.setInput(getTokenStream(text)) - assert(parser.parse().first!= null){"can't build sppf"} - } -} \ No newline at end of file diff --git a/benchmarks/src/test/kotlin/RecoveryOnlineUcfsBenchmark.kt b/benchmarks/src/test/kotlin/RecoveryOnlineUcfsBenchmark.kt deleted file mode 100644 index 1818e35a1..000000000 --- a/benchmarks/src/test/kotlin/RecoveryOnlineUcfsBenchmark.kt +++ /dev/null @@ -1,17 +0,0 @@ -import org.ucfs.Java8 -import org.ucfs.parser.Gll -import kotlin.test.Ignore - -@Ignore -class RecoveryOnlineUcfsBenchmark : ParsingBenchmarks() { - - override fun getShortName(): String = "RecUcfsOn" - - - override fun parse(text: String) { - val startState = Java8().rsm - val tokens = getTokenStream(text) - val gll = Gll.gll(startState, tokens) - gll.parse() - } -} \ No newline at end of file diff --git a/benchmarks/src/test/kotlin/SimpleUcfsCorrect.kt b/benchmarks/src/test/kotlin/SimpleUcfsCorrect.kt deleted file mode 100644 index 601b0cc01..000000000 --- a/benchmarks/src/test/kotlin/SimpleUcfsCorrect.kt +++ /dev/null @@ -1,43 +0,0 @@ -import org.junit.jupiter.api.Test -import org.ucfs.input.IInputGraph -import org.ucfs.input.LinearInput -import org.ucfs.input.TerminalInputLabel -import org.ucfs.parser.Gll -import org.ucfs.rsm.symbol.Term -import org.ucfs.rsm.writeRsmToDot -import org.ucfs.simple.SimpleGrammar -import org.ucfs.sppf.writeSppfToDot -import kotlin.test.Ignore - -@Ignore -class SimpleUcfsCorrect { - val grammar = SimpleGrammar() - - @Test - fun parseOne() { - val startState = grammar.rsm - val tokens = getTokenStream(sourceCode) - val gll = Gll.gll(startState, tokens) - val sppf = gll.parse().first - writeRsmToDot(grammar.rsm, "simple_grammar.dot") - assert(sppf != null) - writeSppfToDot(sppf!!, "simple_beeb.dot") - } - - - fun getTokenStream(input: List>): IInputGraph { - val inputGraph = LinearInput() - var vertexId = 1 - - inputGraph.addVertex(vertexId) - inputGraph.addStartVertex(vertexId) - for (term in input) { - inputGraph.addEdge(vertexId, TerminalInputLabel(term), ++vertexId) - } - - return inputGraph - } - - val sourceCode: List> - get() = listOf(grammar.c, grammar.c) -} \ No newline at end of file diff --git a/benchmarks/src/test/plots.py b/benchmarks/src/test/plots.py deleted file mode 100644 index 3b0212b31..000000000 --- a/benchmarks/src/test/plots.py +++ /dev/null @@ -1,44 +0,0 @@ -import os -import csv -from matplotlib import pyplot as plt -from pathlib import Path - - -def get_datasets_files(folder: str) -> dict[str, list[str]]: - return { - - dataset_folder: [os.path.join(folder, dataset_folder, file) for file in os.listdir(os.path.join(folder, dataset_folder)) if file.endswith(".csv")] - for dataset_folder in os.listdir(folder) if os.path.isdir(os.path.join(folder, dataset_folder)) - } - - -def read_file_data(file: str, column: int) -> list[float]: - with open(file) as fin: - rdr = csv.DictReader(filter(lambda row: row[0] != "%", fin)) - return [float(list(line.values())[column]) for line in rdr] - - -def read_data(folder: str, column: int) -> dict[str, dict[str, list[float]]]: - datasets_files = get_datasets_files(folder) - return {dataset: {Path(file).stem: read_file_data(file, column) for file in files} for dataset, files in datasets_files.items()} - - -def draw_fig(folder: str, column: int, filename: str): - dict = read_data(folder, column) - tools = set(tool for tools_values in dict.values() for tool in tools_values.keys()) - all_datasets = {tool: [value for _, tools_values in dict.items() for value in tools_values.get(tool, [])] for tool in tools} - - result = {"All projects": all_datasets} - result.update(dict) - - fig, axs = plt.subplots(len(result)) - for (dataset, values), ax in zip(result.items(), axs): - ax.boxplot(values.values(), vert=False, widths=0.6) - ax.set_yticklabels(values.keys()) - ax.set_title(dataset, loc='right') - fig.tight_layout() - fig.savefig(filename) - - -draw_fig("results", 1, "time.png") -# draw_fig(2, "memory.png") diff --git a/benchmarks/src/test/resources/test_for_test/Wrong.java b/benchmarks/src/test/resources/test_for_test/Wrong.java deleted file mode 100644 index b8442a072..000000000 --- a/benchmarks/src/test/resources/test_for_test/Wrong.java +++ /dev/null @@ -1 +0,0 @@ -beeb boob \ No newline at end of file diff --git a/benchmarks/src/test/result/Antlr/20times_Antlr_java_correct_rxjava-2-2-2.csv b/benchmarks/src/test/result/Antlr/20times_Antlr_java_correct_rxjava-2-2-2.csv deleted file mode 100644 index f17d3bcd0..000000000 --- a/benchmarks/src/test/result/Antlr/20times_Antlr_java_correct_rxjava-2-2-2.csv +++ /dev/null @@ -1,507 +0,0 @@ -fileName,processing_tim_avg_20_times_millis,max_heap_size_mbMb -AbstractDirectTask.java,94.4,134.8 -AbstractDirectTaskTest.java,191.3,177.61 -AbstractFlowableWithUpstream.java,5.75,41.61 -AbstractFlowableWithUpstreamTest.java,42.95,175.24 -AbstractMaybeWithUpstream.java,0.95,16.07 -AbstractMaybeWithUpstreamTest.java,16.4,30.66 -AbstractObservableWithUpstream.java,1.3,15.97 -AbstractObservableWithUpstreamTest.java,15.2,30.62 -AbstractSchedulerConcurrencyTests.java,2352.1,380.14 -AbstractSchedulerTests.java,2569.55,355.58 -Action.java,0.3,55.17 -ActionDisposable.java,9.45,94.93 -AllTckTest.java,7.5,116.08 -AmbArrayTckTest.java,32.8,131.67 -AmbTckTest.java,63.1,123.31 -AnyTckTest.java,6.95,84.32 -AppendOnlyLinkedArrayList.java,38.0,91.03 -ArrayCompositeDisposable.java,41.2,215.99 -ArrayCompositeDisposableTest.java,153.05,149.6 -ArrayCompositeSubscription.java,25.3,83.13 -ArrayCompositeSubscriptionTest.java,121.05,95.36 -ArrayListSupplier.java,6.15,108.67 -AsyncProcessor.java,222.45,285.93 -AsyncProcessorAsPublisherTckTest.java,212.5,326.66 -AsyncProcessorTest.java,941.4,222.98 -AsyncSubject.java,184.6,144.77 -AsyncSubjectTest.java,908.0,233.79 -AsyncSubscription.java,40.15,138.44 -AsyncSubscriptionTest.java,182.3,160.75 -AtomicThrowable.java,7.35,84.64 -AtomicThrowableTest.java,5.75,73.67 -BackpressureEnumTest.java,12.7,79.67 -BackpressureHelper.java,46.3,118.64 -BackpressureHelperTest.java,182.55,173.06 -BackpressureKind.java,0.1,69.21 -BackpressureOverflowStrategy.java,0.05,69.2 -BackpressureStrategy.java,0.05,69.21 -BackpressureSupport.java,0.45,73.71 -BaseTck.java,21.55,140.64 -BaseTypeAnnotations.java,188.75,366.21 -BaseTypeParser.java,90.75,186.3 -BasicFuseableConditionalSubscriber.java,63.7,140.96 -BasicFuseableConditionalSubscriberTest.java,26.6,122.96 -BasicFuseableObserver.java,52.35,137.11 -BasicFuseableObserverTest.java,35.6,143.61 -BasicFuseableSubscriber.java,55.75,141.23 -BasicFuseableSubscriberTest.java,27.3,106.72 -BasicIntQueueDisposable.java,0.45,74.24 -BasicIntQueueSubscription.java,0.35,74.24 -BasicQueueDisposable.java,0.45,74.24 -BasicQueueDisposableTest.java,19.0,96.74 -BasicQueueSubscription.java,0.3,74.31 -BehaviorProcessor.java,383.2,208.38 -BehaviorProcessorAsPublisherTckTest.java,237.05,275.84 -BehaviorProcessorTest.java,1632.25,329.93 -BehaviorSubject.java,257.8,233.33 -BehaviorSubjectTest.java,1421.8,193.3 -Beta.java,0.05,84.14 -BiConsumer.java,0.35,84.15 -BiConsumerSingleObserver.java,57.45,179.15 -BiFunction.java,0.45,85.34 -BiPredicate.java,0.25,84.41 -BinaryFlatMapPerf.java,216.65,196.95 -BlockingBaseObserver.java,22.6,141.62 -BlockingBaseSubscriber.java,31.5,190.75 -BlockingFirstObserver.java,10.1,91.56 -BlockingFirstObserverTest.java,37.45,140.56 -BlockingFirstSubscriber.java,11.75,109.07 -BlockingFlowableIterable.java,85.55,186.04 -BlockingFlowableLatest.java,80.4,287.54 -BlockingFlowableLatestTest.java,553.15,285.04 -BlockingFlowableMostRecent.java,38.35,185.14 -BlockingFlowableMostRecentTest.java,209.75,257.4 -BlockingFlowableNext.java,76.6,285.76 -BlockingFlowableNextTest.java,1053.9,339.89 -BlockingFlowableToFutureTest.java,137.9,264.18 -BlockingFlowableToIteratorTest.java,216.05,236.51 -BlockingGetPerf.java,18.7,130.23 -BlockingHelper.java,27.5,271.22 -BlockingHelperTest.java,55.2,177.39 -BlockingIgnoringReceiver.java,0.35,106.42 -BlockingLastObserver.java,0.3,106.42 -BlockingLastSubscriber.java,0.35,106.43 -BlockingMultiObserver.java,55.3,242.93 -BlockingMultiObserverTest.java,189.65,147.08 -BlockingObservableIterable.java,86.65,253.54 -BlockingObservableLatest.java,67.75,261.35 -BlockingObservableLatestTest.java,519.65,310.04 -BlockingObservableMostRecent.java,31.1,145.65 -BlockingObservableMostRecentTest.java,191.65,150.04 -BlockingObservableNext.java,53.65,236.67 -BlockingObservableNextTest.java,870.15,371.83 -BlockingObservableToFutureTest.java,145.8,282.96 -BlockingObservableToIteratorTest.java,149.3,285.96 -BlockingObserver.java,62.7,187.96 -BlockingObserverTest.java,14.4,123.97 -BlockingPerf.java,23.4,130.47 -BlockingSubscriber.java,77.45,218.47 -BlockingSubscriberTest.java,94.85,263.52 -BooleanSubscription.java,6.2,121.69 -BooleanSupplier.java,0.25,108.23 -BoundedSubscriber.java,89.05,230.75 -BoundedSubscriberTest.java,518.6,269.08 -BufferBoundaryTckTest.java,12.45,216.74 -BufferExactSizeTckTest.java,6.35,124.73 -BufferUntilSubscriberTest.java,181.85,351.65 -Burst.java,36.05,204.19 -CacheTckTest.java,5.15,122.81 -CachedThreadSchedulerTest.java,185.5,313.06 -CallableAsyncPerf.java,123.75,296.56 -CallbackCompletableObserver.java,56.3,185.63 -CallbackCompletableObserverTest.java,5.5,124.14 -Cancellable.java,0.05,118.14 -CancellableDisposable.java,17.25,177.64 -CancellableDisposableTest.java,74.95,233.28 -CapturingUncaughtExceptionHandler.java,6.85,131.84 -CheckLocalVariablesInTests.java,175.3,352.64 -CheckReturnValue.java,0.0,122.22 -CollectTckTest.java,14.8,234.23 -CombineLatestArrayDelayErrorTckTest.java,49.5,229.93 -CombineLatestArrayTckTest.java,43.0,171.81 -CombineLatestIterableDelayErrorTckTest.java,79.0,272.09 -CombineLatestIterableTckTest.java,73.0,214.5 -Completable.java,946.7,366.44 -CompletableAmb.java,131.9,340.05 -CompletableAmbTest.java,506.2,308.1 -CompletableAndThenObservable.java,50.1,203.72 -CompletableAndThenObservableTest.java,131.15,351.85 -CompletableAndThenPublisher.java,71.7,227 -CompletableAndThenPublisherTckTest.java,13.3,181.04 -CompletableAndThenPublisherTest.java,103.2,242.14 -CompletableAndThenTest.java,161.05,308 -CompletableAwaitTest.java,32.4,306.28 -CompletableCache.java,96.3,271.93 -CompletableCacheTest.java,314.65,329.54 -CompletableConcat.java,175.6,356.34 -CompletableConcatArray.java,34.75,240.9 -CompletableConcatIterable.java,95.2,249.56 -CompletableConcatTest.java,1286.3,374.44 -CompletableConverter.java,0.2,142.69 -CompletableCreate.java,92.05,259.07 -CompletableCreateTest.java,1006.35,370 -CompletableDefer.java,29.35,182.5 -CompletableDelay.java,108.65,268.91 -CompletableDelayTest.java,178.25,362.35 -CompletableDetach.java,35.15,192.85 -CompletableDetachTest.java,209.0,396.44 -CompletableDisposeOn.java,45.6,203.44 -CompletableDisposeOnTest.java,125.95,345.44 -CompletableDoFinally.java,58.85,223.1 -CompletableDoFinallyTest.java,94.2,273.63 -CompletableDoOnEvent.java,55.3,243.33 -CompletableDoOnTest.java,100.6,337.18 -CompletableEmitter.java,0.45,148.85 -CompletableEmpty.java,5.75,154.85 -CompletableError.java,7.95,157.85 -CompletableErrorSupplier.java,24.55,183.35 -CompletableFromAction.java,31.05,206.37 -CompletableFromActionTest.java,133.75,319.45 -CompletableFromCallable.java,36.3,226.45 -CompletableFromCallableTest.java,229.35,248.9 -CompletableFromMaybeTest.java,43.9,207.9 -CompletableFromObservable.java,25.85,180.4 -CompletableFromObservableTest.java,43.8,207.4 -CompletableFromPublisher.java,38.9,199.9 -CompletableFromPublisherTest.java,106.85,289.92 -CompletableFromRunnable.java,30.1,185.99 -CompletableFromRunnableTest.java,133.25,317 -CompletableFromSingle.java,25.75,180.5 -CompletableFromSingleTest.java,33.1,193 -CompletableFromUnsafeSource.java,5.8,155.5 -CompletableHide.java,35.0,192 -CompletableHideTest.java,94.55,269.5 -CompletableLift.java,17.65,170 -CompletableLiftTest.java,19.45,172 -CompletableMerge.java,234.5,427.83 -CompletableMergeArray.java,61.1,257.83 -CompletableMergeDelayErrorArray.java,71.15,254.97 -CompletableMergeDelayErrorIterable.java,98.65,314.06 -CompletableMergeIterable.java,115.1,302.72 -CompletableMergeIterableTest.java,235.35,339.21 -CompletableMergeTest.java,1924.45,366.38 -CompletableNever.java,6.25,162.72 -CompletableObserveOn.java,78.15,254.72 -CompletableObserveOnTest.java,81.25,266.72 -CompletableObserver.java,0.25,156.76 -CompletableOnErrorComplete.java,51.9,285.25 -CompletableOnErrorXTest.java,8.75,183.56 -CompletableOnSubscribe.java,0.3,157.12 -CompletableOperator.java,0.25,157.13 -CompletablePeek.java,130.55,313.38 -CompletablePeekTest.java,40.05,206.88 -CompletableRepeatWhenTest.java,35.45,202.18 -CompletableResumeNext.java,71.75,259.37 -CompletableResumeNextTest.java,246.3,354.45 -CompletableRetryTest.java,246.15,318.94 -CompletableSource.java,0.25,160.95 -CompletableSubject.java,120.95,301.04 -CompletableSubjectTest.java,290.45,315.44 -CompletableSubscribeOn.java,49.0,221.55 -CompletableSubscribeOnTest.java,106.7,285.55 -CompletableSubscribeTest.java,12.65,177.05 -CompletableTakeUntilCompletable.java,117.05,305.56 -CompletableTakeUntilTest.java,315.35,301.41 -CompletableTest.java,java.lang.OutOfMemoryError,OOM -CompletableTimeout.java,126.1,364.3 -CompletableTimeoutTest.java,149.2,353.43 -CompletableTimer.java,51.85,243.43 -CompletableTimerTest.java,92.35,265.87 -CompletableToFlowable.java,6.4,176.86 -CompletableToFlowableTest.java,30.4,206.87 -CompletableToObservable.java,35.75,216.38 -CompletableToObservableTest.java,63.5,249.89 -CompletableToSingle.java,51.15,244.37 -CompletableTransformer.java,0.1,170.69 -CompletableUnsafeTest.java,128.25,323.86 -CompletableUsing.java,193.2,398.79 -CompletableUsingTest.java,1398.65,380.1 -CompositeDisposable.java,121.45,325.71 -CompositeDisposableTest.java,1581.75,401.03 -CompositeException.java,194.2,376.38 -CompositeExceptionTest.java,294.15,333.68 -ComputationScheduler.java,170.2,381.23 -ComputationSchedulerInternalTest.java,19.0,214.25 -ComputationSchedulerTests.java,560.6,380.18 -ConcatArrayEagerTckTest.java,65.1,291.09 -ConcatIterableEagerTckTest.java,33.6,232.69 -ConcatMapIterableTckTest.java,11.85,225.73 -ConcatMapMaybeTckTest.java,11.2,201.83 -ConcatMapSingleTckTest.java,11.0,201.82 -ConcatMapTckTest.java,11.3,201.83 -ConcatPublisherEagerTckTest.java,64.5,271.33 -ConcatPublisherTckTest.java,65.05,271.33 -ConcatTckTest.java,33.6,231.83 -ConcatWithCompletableTckTest.java,10.05,201.33 -ConcatWithMaybeEmptyTckTest.java,10.55,201.33 -ConcatWithMaybeTckTest.java,34.45,299.33 -ConcatWithSingleTckTest.java,32.5,230.7 -ConditionalSubscriber.java,0.4,188.71 -ConnectConsumer.java,0.35,190.71 -ConnectableFlowable.java,54.2,258.72 -ConnectableObservable.java,54.15,255.24 -Consumer.java,0.2,188.73 -ConsumerSingleObserver.java,50.55,250.23 -ConsumerSingleObserverTest.java,8.7,199.23 -ConverterTest.java,187.1,432.01 -CrashingIterable.java,0.95,201.5 -CrashingMappedIterable.java,6.25,213.59 -CreateTckTest.java,61.95,293.6 -DefaultIfEmptyTckTest.java,9.05,200.71 -DefaultObserver.java,13.65,219.22 -DefaultSubscriber.java,18.4,210.75 -DefaultSubscriberTest.java,22.55,226.24 -DeferTckTest.java,28.0,271.28 -DeferredScalarDisposable.java,32.95,266.01 -DeferredScalarObserver.java,14.85,213.28 -DeferredScalarObserverTest.java,878.35,342.2 -DeferredScalarSubscriber.java,29.1,227.84 -DeferredScalarSubscriberTest.java,1006.1,419.15 -DeferredScalarSubscription.java,50.15,383.52 -DeferredScalarSubscriptionTest.java,92.85,330.69 -DelaySubscriptionTckTest.java,8.85,206.77 -DelayTckTest.java,9.0,206.77 -Disposable.java,0.1,195.78 -DisposableCompletableObserver.java,15.45,212.78 -DisposableCompletableObserverTest.java,110.35,331.6 -DisposableContainer.java,0.1,196.1 -DisposableHelper.java,96.25,380.6 -DisposableHelperTest.java,138.85,372.13 -DisposableLambdaObserver.java,73.55,290.63 -DisposableLambdaObserverTest.java,76.3,285.86 -DisposableMaybeObserver.java,15.1,214.36 -DisposableMaybeObserverTest.java,116.85,352.37 -DisposableObserver.java,15.15,214.37 -DisposableObserverTest.java,118.4,345.87 -DisposableSingleObserver.java,14.8,214.38 -DisposableSingleObserverTest.java,116.8,343.88 -DisposableSubscriber.java,20.6,222.88 -DisposableSubscriberTest.java,109.1,333.38 -Disposables.java,36.6,242.89 -DisposablesTest.java,146.5,380 -DisposeOnCancel.java,5.6,203.5 -DisposeOnCancelTest.java,11.15,211.99 -DistinctTckTest.java,17.75,228.5 -DistinctUntilChangedTckTest.java,9.95,208.54 -DoAfterNextTckTest.java,10.9,210.54 -DoFinallyTckTest.java,9.35,208.54 -DoOnNextTckTest.java,10.65,210.54 -EachTypeFlatMapPerf.java,191.3,433.8 -ElementAtTckTest.java,3.85,201.8 -Emitter.java,0.3,197.8 -EmptyCompletableObserver.java,22.8,225.3 -EmptyCompletableObserverTest.java,2.3,199.8 -EmptyComponent.java,16.75,217.81 -EmptyComponentTest.java,81.75,300.34 -EmptyDisposable.java,71.7,294.35 -EmptyDisposableTest.java,13.5,214.91 -EmptySubscription.java,26.2,228.41 -EmptyTckTest.java,2.55,208.41 -EndConsumerHelper.java,88.1,304.29 -EndConsumerHelperTest.java,602.9,328.21 -ErrorMode.java,0.1,198.49 -ExceptionHelper.java,64.5,276.02 -ExceptionHelperTest.java,27.5,267.62 -Exceptions.java,15.6,267.33 -ExceptionsNullTest.java,0.25,199.55 -ExceptionsTest.java,887.0,383.24 -ExecutorScheduler.java,225.3,289.37 -ExecutorSchedulerDelayedRunnableTest.java,27.05,239.62 -ExecutorSchedulerTest.java,862.7,377.4 -Experimental.java,0.2,206.01 -FailOnBlockingTest.java,499.0,377.69 -FilterTckTest.java,11.35,259.03 -FirstTckTest.java,3.6,211.25 -FixLicenseHeaders.java,235.35,426.35 -FlatMapJustPerf.java,29.5,268.85 -FlatMapTckTest.java,10.75,224.42 -FlattenCrossMapPerf.java,42.9,265.42 -FlattenJustPerf.java,34.25,253.46 -FlattenRangePerf.java,35.25,255.46 -Flowable.java,6511.6,418.51 -FlowableAll.java,58.1,291.92 -FlowableAllSingle.java,74.35,310.95 -FlowableAllTest.java,943.5,358.27 -FlowableAmb.java,187.5,419.19 -FlowableAmbTest.java,1967.3,413.19 -FlowableAny.java,58.4,297.91 -FlowableAnySingle.java,74.6,318.91 -FlowableAnyTest.java,1027.45,379.4 -FlowableAsObservableTest.java,61.9,306.97 -FlowableAutoConnect.java,13.25,241.47 -FlowableAutoConnectTest.java,7.0,234.47 -FlowableBackpressureTests.java,2307.25,456.14 -FlowableBlockingSubscribe.java,103.3,365.97 -FlowableBlockingTest.java,1003.3,383.13 -FlowableBuffer.java,392.9,384.65 -FlowableBufferBoundary.java,350.15,437.5 -FlowableBufferBoundarySupplier.java,238.95,353.43 -FlowableBufferExactBoundary.java,152.7,425.23 -FlowableBufferTest.java,8450.2,405.58 -FlowableBufferTimed.java,572.0,386.48 -FlowableCache.java,217.05,424.3 -FlowableCacheTest.java,1158.15,406.54 -FlowableCastTest.java,90.05,371.92 -FlowableCollect.java,79.45,356.93 -FlowableCollectSingle.java,92.6,370.45 -FlowableCollectTest.java,819.1,472.45 -FlowableCombineLatest.java,java.lang.OutOfMemoryError,OOM -FlowableCombineLatestTest.java,5933.05,466.05 -FlowableCombineLatestTests.java,97.2,395.17 -FlowableConcatArray.java,104.95,415.88 -FlowableConcatDelayErrorTest.java,836.15,407.41 -FlowableConcatMap.java,666.6,407.16 -FlowableConcatMapCompletable.java,222.6,431.87 -FlowableConcatMapCompletablePerf.java,85.9,421.89 -FlowableConcatMapCompletableTest.java,863.1,417.04 -FlowableConcatMapEager.java,325.4,486.39 -FlowableConcatMapEagerPublisher.java,19.85,321.92 -FlowableConcatMapEagerTest.java,3288.55,418.93 -FlowableConcatMapMaybe.java,225.6,462.45 -FlowableConcatMapMaybeEmptyPerf.java,88.85,417.29 -FlowableConcatMapMaybePerf.java,85.55,417.29 -FlowableConcatMapMaybeTest.java,833.05,441.54 -FlowableConcatMapPublisher.java,33.0,349.68 -FlowableConcatMapSingle.java,200.05,431.38 -FlowableConcatMapSinglePerf.java,86.05,420.68 -FlowableConcatMapSingleTest.java,663.7,433.33 -FlowableConcatMapTest.java,77.0,409.02 -FlowableConcatTest.java,6562.15,503.72 -FlowableConcatTests.java,196.35,396.38 -FlowableConcatWithCompletable.java,63.6,419.81 -FlowableConcatWithCompletableTest.java,182.8,444.28 -FlowableConcatWithMaybe.java,46.8,394.93 -FlowableConcatWithMaybeTest.java,174.55,431.67 -FlowableConcatWithSingle.java,41.45,388.44 -FlowableConcatWithSingleTest.java,94.0,446.94 -FlowableConversionTest.java,448.4,433.08 -FlowableConverter.java,0.1,344.84 -FlowableCount.java,34.3,386.34 -FlowableCountSingle.java,44.7,399.34 -FlowableCountTest.java,358.75,406.91 -FlowableCovarianceTest.java,506.7,422.9 -FlowableCreate.java,299.0,467.23 -FlowableCreateTest.java,java.lang.OutOfMemoryError,OOM -FlowableDebounce.java,166.65,395.05 -FlowableDebounceTest.java,1811.8,479.46 -FlowableDebounceTimed.java,181.25,410.05 -FlowableDefaultIfEmptyTest.java,189.6,388.14 -FlowableDefer.java,30.05,390.51 -FlowableDeferTest.java,68.7,444.52 -FlowableDelay.java,119.65,395.56 -FlowableDelaySubscriptionOther.java,72.6,441.06 -FlowableDelaySubscriptionOtherTest.java,1190.1,484.99 -FlowableDelayTest.java,2524.4,489.08 -FlowableDematerialize.java,97.4,411.3 -FlowableDematerializeTest.java,353.5,430.17 -FlowableDetach.java,48.55,416.74 -FlowableDetachTest.java,347.45,418.15 -FlowableDistinct.java,142.4,437.05 -FlowableDistinctTest.java,539.15,431.08 -FlowableDistinctUntilChanged.java,98.35,402.4 -FlowableDistinctUntilChangedTest.java,988.2,435.81 -FlowableDoAfterNext.java,83.9,414.71 -FlowableDoAfterNextTest.java,301.1,409.67 -FlowableDoAfterTerminateTest.java,55.75,426.63 -FlowableDoFinally.java,168.45,420.76 -FlowableDoFinallyTest.java,1003.45,498.16 -FlowableDoOnEach.java,371.6,426.91 -FlowableDoOnEachTest.java,1722.1,453.34 -FlowableDoOnLifecycle.java,112.0,415.28 -FlowableDoOnLifecycleTest.java,348.15,466.81 -FlowableDoOnRequestTest.java,48.25,414.31 -FlowableDoOnSubscribeTest.java,158.3,419.02 -FlowableDoOnTest.java,51.05,427.31 -FlowableDoOnUnsubscribeTest.java,140.8,447.59 -FlowableElementAt.java,66.25,440.93 -FlowableElementAtMaybe.java,65.45,442.43 -FlowableElementAtSingle.java,80.25,378.08 -FlowableElementAtTest.java,973.85,471.76 -FlowableEmitter.java,0.4,363.63 -FlowableEmpty.java,6.15,370.13 -FlowableError.java,24.25,393.63 -FlowableErrorHandlingTests.java,95.8,417.38 -FlowableEventStream.java,85.55,431.89 -FlowableEventStreamTest.java,6.1,369.98 -FlowableFilter.java,85.2,386.77 -FlowableFilterTest.java,1457.25,489.92 -FlowableFirstTest.java,876.55,407.46 -FlowableFlatMap.java,java.lang.OutOfMemoryError,OOM -FlowableFlatMapCompletable.java,156.1,424.4 -FlowableFlatMapCompletableAsyncPerf.java,81.25,429.59 -FlowableFlatMapCompletableCompletable.java,158.25,419.43 -FlowableFlatMapCompletablePerf.java,90.15,403.19 -FlowableFlatMapCompletableSyncPerf.java,43.55,422.93 -FlowableFlatMapCompletableTest.java,1159394.1,463.75 -FlowableFlatMapMaybe.java,380.35,488.06 -FlowableFlatMapMaybeEmptyPerf.java,92.85,407.29 -FlowableFlatMapMaybePerf.java,94.25,407.34 -FlowableFlatMapMaybeTest.java,1142.95,498.59 -FlowableFlatMapPublisher.java,34.85,408.07 -FlowableFlatMapSingle.java,315.35,441.85 -FlowableFlatMapSinglePerf.java,89.8,408.99 -FlowableFlatMapSingleTest.java,1035.55,502.09 -FlowableFlatMapTest.java,java.lang.OutOfMemoryError,OOM -FlowableFlattenIterable.java,379.75,436.18 -FlowableFlattenIterableTest.java,2448.55,501.63 -FlowableForEachTest.java,78.9,413.12 -FlowableFromArray.java,139.9,447.69 -FlowableFromArrayTest.java,368.75,449.92 -FlowableFromCallable.java,50.8,439.92 -FlowableFromCallableTest.java,336.2,436.27 -FlowableFromFuture.java,39.35,424.76 -FlowableFromIterable.java,294.45,443.55 -FlowableFromIterableTest.java,1846.65,498.44 -FlowableFromObservable.java,36.4,424.12 -FlowableFromObservableTest.java,27.85,416.12 -FlowableFromPublisher.java,6.15,387.12 -FlowableFromSourceTest.java,1972.4,429.11 -FlowableFuseableTest.java,146.6,399.93 -FlowableGenerate.java,91.3,422.86 -FlowableGenerateTest.java,1334.8,491.57 -FlowableGroupBy.java,578.3,462.13 -FlowableGroupByTest.java,6408.9,500.69 -FlowableGroupByTests.java,233.45,466.62 -FlowableGroupJoin.java,java.lang.OutOfMemoryError,OOM -FlowableGroupJoinTest.java,2209.5,506.1 -FlowableHide.java,47.0,434.39 -FlowableHideTest.java,119.9,437.09 -FlowableIgnoreElements.java,42.45,422.71 -FlowableIgnoreElementsCompletable.java,49.1,428.7 -FlowableIgnoreElementsTest.java,675.95,502.8 -FlowableInternalHelper.java,156.7,487.32 -FlowableInternalHelperTest.java,11.0,425.34 -FlowableInterval.java,94.85,447.48 -FlowableIntervalRange.java,101.95,435.61 -FlowableIntervalRangeTest.java,259.2,466.54 -FlowableIntervalTest.java,106.3,445.65 -FlowableJoin.java,java.lang.OutOfMemoryError,OOM -FlowableJoinTest.java,1947.05,503.73 -FlowableJust.java,12.9,431.3 -FlowableLastMaybe.java,47.9,444.01 -FlowableLastSingle.java,63.7,426.4 -FlowableLastTest.java,1205.75,465.42 -FlowableLift.java,24.9,443.44 -FlowableLiftTest.java,23.3,443.45 -FlowableLimit.java,84.55,458.78 -FlowableLimitTest.java,326.55,449.61 -FlowableMap.java,134.15,435.71 -FlowableMapNotification.java,103.7,429.67 -FlowableMapNotificationTest.java,1047.3,486.86 -FlowableMapPublisher.java,13.75,435.8 -FlowableMapTest.java,2080.35,488.09 -FlowableMaterialize.java,64.9,492.13 -FlowableMaterializeTest.java,658.55,487.79 -FlowableMergeDelayErrorTest.java,4110.75,493.93 -FlowableMergeMaxConcurrentTest.java,java.lang.OutOfMemoryError,OOM -FlowableMergeTest.java,java.lang.OutOfMemoryError,OOM -FlowableMergeTests.java,191.05,476.53 -FlowableMergeWithCompletable.java,142.05,433.78 -FlowableMergeWithCompletableTest.java,167.75,451.01 -FlowableMergeWithMaybe.java,1975364.25,465.34 -FlowableMergeWithMaybeTest.java,719.0,480.64 -FlowableMergeWithSingle.java,240.55,461.62 -FlowableMergeWithSingleTest.java,706.55,473.46 -FlowableNever.java,7.35,438.33 -FlowableNotificationTest.java,276.35,505.99 \ No newline at end of file diff --git a/benchmarks/src/test/result/Antlr/Antlr_java_correct_junit-4-12.csv b/benchmarks/src/test/result/Antlr/Antlr_java_correct_junit-4-12.csv deleted file mode 100644 index 7805b8931..000000000 --- a/benchmarks/src/test/result/Antlr/Antlr_java_correct_junit-4-12.csv +++ /dev/null @@ -1,353 +0,0 @@ -fileName,processing_tim_avg_20_times_millis,max_heap_size_mbMb -ActiveTestSuite.java,63.95,95.47 -ActiveTestTest.java,68.25,139.97 -After.java,0.8,14.99 -AfterClass.java,0.35,11.06 -AllDefaultPossibilitiesBuilder.java,41.0,124.27 -AllMembersSupplier.java,363.15,177.13 -AllMembersSupplierTest.java,76.3,176.68 -AllTests.java,2.2,30.58 -AllTestsTest.java,35.8,121.35 -Annotatable.java,1.0,24.49 -AnnotatedBuilder.java,50.95,152.55 -AnnotatedBuilderTest.java,34.4,106.22 -AnnotatedDescriptionTest.java,19.5,106.8 -AnnotationTest.java,189.85,187.98 -AnnotationValidator.java,1.55,32.62 -AnnotationValidatorFactory.java,32.3,88.27 -AnnotationValidatorFactoryTest.java,37.55,98.47 -AnnotationsValidator.java,62.25,123.78 -AnnotationsValidatorTest.java,16.9,68.47 -ArrayComparisonFailure.java,61.15,63.91 -Assert.java,86.7,185.99 -AssertTest.java,25.25,83.27 -AssertionFailedError.java,1.15,35.32 -AssertionFailedErrorTest.java,10.65,40.83 -AssertionTest.java,132.7,299.74 -Assignments.java,116.2,208.1 -Assume.java,6.0,83.81 -AssumingInTheoriesTest.java,34.25,120.82 -AssumptionTest.java,105.85,123.53 -AssumptionViolatedException.java,42.7,102.32 -AssumptionViolatedExceptionTest.java,28.0,69.83 -BadlyFormedClassesTest.java,7.55,64.83 -BaseTestRunner.java,176.4,170.85 -BaseTestRunnerTest.java,20.15,75.93 -Before.java,0.15,50.45 -BeforeClass.java,0.25,50.45 -BlockJUnit4ClassRunner.java,212.85,241.18 -BlockJUnit4ClassRunnerOverrideTest.java,63.7,153.48 -BlockJUnit4ClassRunnerTest.java,7.95,90.96 -BlockJUnit4ClassRunnerWithParameters.java,156.35,232.66 -BlockJUnit4ClassRunnerWithParametersFactory.java,0.2,58.55 -BooleanSupplier.java,30.7,132.55 -Categories.java,145.7,331.74 -CategoriesAndParameterizedTest.java,37.35,137.78 -Category.java,0.2,62.18 -CategoryFilterFactory.java,14.65,134.68 -CategoryFilterFactoryTest.java,22.8,148.39 -CategoryTest.java,122.75,129.57 -CategoryValidator.java,31.5,115.17 -CategoryValidatorTest.java,7.7,88.83 -ClassLevelMethodsWithIgnoredTestsTest.java,23.8,83.82 -ClassRequest.java,3.4,136.82 -ClassRequestTest.java,0.35,65.2 -ClassRoadie.java,46.3,180.15 -ClassRule.java,0.3,68.57 -ClassRulesTest.java,61.3,136.9 -Classes.java,12.55,107.89 -CommandLineTest.java,63.45,141.71 -ComparisonCompactor.java,117.15,150.06 -ComparisonCompactorTest.java,2.0,69.43 -ComparisonCriteria.java,56.3,231.94 -ComparisonFailure.java,157.75,168.39 -ComparisonFailureTest.java,73.7,199.36 -Computer.java,6.25,133.35 -ConcurrentRunNotifierTest.java,276.35,343.92 -Correspondent.java,0.25,73.05 -CouldNotReadCoreException.java,0.2,73.05 -DataPoint.java,0.55,76.04 -DataPoints.java,0.35,73.09 -Describable.java,0.15,73.09 -Description.java,65.85,238.6 -DescriptionTest.java,115.7,209.48 -DisableOnDebug.java,9.15,137.99 -DisableOnDebugTest.java,55.4,143.2 -DoublePrecisionAssertTest.java,0.8,82.69 -EachTestNotifier.java,44.6,158.21 -Enclosed.java,30.05,112.18 -EnclosedTest.java,11.2,108.18 -EnumSupplier.java,38.6,138.26 -ErrorCollector.java,18.9,101.91 -ErrorReportingRunner.java,52.35,137.43 -ErrorReportingRunnerTest.java,1.2,105.43 -EventCollector.java,235.75,370.52 -ExactComparisonCriteria.java,8.95,89.47 -ExcludeCategories.java,2.45,100.47 -ExpectException.java,24.55,212.59 -ExpectedException.java,25.25,148.62 -ExpectedExceptionMatcherBuilder.java,23.0,142.25 -ExpectedExceptionTest.java,252.7,220.77 -ExpectedTest.java,19.55,106.67 -ExperimentalTests.java,0.2,83.76 -ExtensionTest.java,37.8,164.26 -ExternalResource.java,8.2,133.92 -ExternalResourceRuleTest.java,2.6,105.54 -Fail.java,0.35,88.65 -FailOnTimeout.java,122.4,271.7 -FailOnTimeoutTest.java,67.05,191.86 -FailedBefore.java,0.05,86.69 -FailedConstructionTest.java,25.5,123.69 -FailingDataPointMethods.java,0.55,86.7 -Failure.java,0.0,86.7 -FailureList.java,7.3,95.19 -Filter.java,49.7,293.5 -FilterFactories.java,18.15,115.85 -FilterFactoriesTest.java,98.0,211.15 -FilterFactory.java,3.7,112.65 -FilterFactoryParams.java,0.35,91.28 -FilterOptionIntegrationTest.java,81.5,197.54 -FilterRequest.java,32.15,155.53 -FilterTest.java,11.6,143.59 -Filterable.java,0.05,92.13 -FilterableTest.java,25.55,117.32 -FixMethodOrder.java,0.25,92.83 -FloatAssertTest.java,0.6,92.84 -ForwardCompatibilityPrintingTest.java,74.6,180.41 -ForwardCompatibilityTest.java,185.4,279.91 -FrameworkField.java,13.15,131.41 -FrameworkFieldTest.java,18.1,123.46 -FrameworkMember.java,10.5,115.48 -FrameworkMethod.java,101.25,250.12 -FrameworkMethodTest.java,17.85,115.94 -FromDataPoints.java,0.15,94.94 -Guesser.java,229.85,325.93 -GuesserQueue.java,17.6,147.45 -IMoney.java,0.5,98.03 -Ignore.java,0.25,98.04 -IgnoreClassTest.java,5.0,104.04 -IgnoredBuilder.java,2.25,100.04 -IgnoredClassRunner.java,12.0,112.54 -IncludeCategories.java,1.05,100.54 -InexactComparisonCriteria.java,72.65,172.47 -InheritedTestCase.java,0.15,98.47 -InheritedTestTest.java,5.1,104.47 -InitializationError.java,2.6,113.47 -InitializationErrorForwardCompatibilityTest.java,25.65,157.03 -InvokeMethod.java,6.1,104.71 -JUnit38ClassRunner.java,222.65,376.47 -JUnit38ClassRunnerTest.java,54.15,269.05 -JUnit38SortingTest.java,27.55,136.55 -JUnit3Builder.java,0.55,101.56 -JUnit4.java,0.25,101.56 -JUnit4Builder.java,0.45,101.57 -JUnit4ClassRunner.java,167.8,310.07 -JUnit4ClassRunnerTest.java,9.2,115.64 -JUnit4TestAdapter.java,54.1,194.14 -JUnit4TestAdapterCache.java,212.9,309.14 -JUnit4TestCaseFacade.java,0.55,104.53 -JUnitCommandLineParseResult.java,174.25,289.27 -JUnitCommandLineParseResultTest.java,138.0,281.24 -JUnitCore.java,88.7,218.84 -JUnitCoreReturnsCorrectExitCodeTest.java,9.25,169.33 -JUnitCoreTest.java,9.25,123.12 -JUnitMatchers.java,20.75,198.13 -JUnitSystem.java,0.1,109.44 -JavadocTest.java,12.1,125.94 -ListTest.java,91.75,254.45 -ListenerTest.java,43.75,187.06 -LoggingTestWatcher.java,26.5,140.15 -MainRunner.java,244.2,253.46 -MatcherTest.java,15.4,192.17 -MaxCore.java,127.9,326.76 -MaxHistory.java,132.3,273.63 -MaxStarterTest.java,294.3,317.95 -MethodCall.java,33.4,224.23 -MethodRoadie.java,157.7,345.25 -MethodRule.java,0.45,119.42 -MethodRulesTest.java,84.6,218.23 -MethodSorter.java,33.95,274.72 -MethodSorterTest.java,71.1,200.47 -MethodSorters.java,1.65,141.96 -MethodValidator.java,149.55,319.47 -Money.java,31.6,265.97 -MoneyBag.java,135.45,284.32 -MoneyTest.java,224.15,226.96 -MultiCategoryTest.java,31.6,169.17 -MultipleFailureException.java,0.15,124.18 -MultipleFailureExceptionTest.java,60.45,249.19 -NameRulesTest.java,7.9,134.26 -NoArgTestCaseTest.java,0.1,124.26 -NoGenericTypeParametersValidator.java,38.3,228.76 -NoTestCaseClass.java,0.05,124.47 -NoTestCases.java,0.1,124.47 -NoTestsRemainException.java,0.1,124.47 -NotPublicTestCase.java,0.05,124.48 -NotVoidTestCase.java,0.15,124.47 -NullBuilder.java,0.2,124.48 -ObjectContractTest.java,10.05,157.48 -OldTestClassAdaptingListenerTest.java,21.05,177.6 -OldTests.java,1.95,126.66 -OneTestCase.java,0.2,124.66 -OverrideTestCase.java,0.05,124.66 -ParallelClassTest.java,51.25,199.67 -ParallelComputer.java,109.4,336.19 -ParallelMethodTest.java,31.5,174.72 -ParameterSignature.java,77.15,271.75 -ParameterSignatureTest.java,53.3,198.47 -ParameterSupplier.java,0.15,128.48 -Parameterized.java,115.65,264.11 -ParameterizedAssertionError.java,39.1,222.2 -ParameterizedAssertionErrorTest.java,33.7,165.9 -ParameterizedNamesTest.java,37.1,254.9 -ParameterizedTestMethodTest.java,22.05,165.75 -ParameterizedTestTest.java,185.55,349.86 -ParametersRunnerFactory.java,0.25,132.35 -ParametersSuppliedBy.java,0.25,132.35 -ParentRunner.java,289.05,380.99 -ParentRunnerFilteringTest.java,71.5,325.14 -ParentRunnerTest.java,202.45,385.87 -PotentialAssignment.java,14.4,380.37 -PotentialAssignmentTest.java,19.0,172.01 -PrintableResult.java,7.55,164.54 -PrintableResultTest.java,57.85,262.99 -Protectable.java,0.15,138.54 -PublicClassValidator.java,4.85,162.04 -PublicClassValidatorTest.java,9.4,210.18 -RealSystem.java,6.05,147.27 -ReflectiveCallable.java,2.35,149.27 -ReguessableValue.java,0.2,138.79 -RepeatedTest.java,3.4,165.29 -RepeatedTestTest.java,45.15,218.88 -Request.java,12.05,161.01 -Result.java,126.4,301.87 -ResultMatchers.java,22.8,196.37 -ResultMatchersTest.java,3.9,146.05 -ResultPrinter.java,113.8,278.63 -ResultTest.java,47.95,298.63 -Rule.java,0.1,141.02 -RuleChain.java,16.35,172.53 -RuleChainTest.java,12.4,168.56 -RuleMemberValidator.java,155.0,327.26 -RuleMemberValidatorTest.java,152.5,340.31 -RunAfters.java,27.25,210.8 -RunBefores.java,10.75,154.48 -RunListener.java,0.6,141.99 -RunNotifier.java,110.5,302.51 -RunNotifierTest.java,164.15,353.36 -RunRules.java,9.3,155.86 -RunWith.java,0.4,142.88 -RunWithTest.java,19.75,169.88 -Runner.java,0.3,142.88 -RunnerBuilder.java,28.6,229.38 -RunnerBuilderStub.java,0.2,143.16 -RunnerScheduler.java,0.05,143.17 -RunnerSpy.java,0.75,143.17 -RunnerTest.java,31.85,187.17 -SimpleTest.java,0.5,146.18 -SingleMethodTest.java,79.65,306.2 -Sortable.java,0.2,143.55 -SortableTest.java,29.55,221.05 -Sorter.java,14.0,178.26 -SortingRequest.java,3.8,147.88 -SpecificDataPointsSupplier.java,40.1,202.88 -SpecificDataPointsSupplierTest.java,66.45,242.91 -StackFilterTest.java,96.65,264.95 -StacktracePrintingMatcher.java,39.75,195.45 -StacktracePrintingMatcherTest.java,3.65,184.97 -Statement.java,0.1,144.32 -StoppedByUserException.java,0.0,144.32 -Stopwatch.java,45.4,231.32 -StopwatchTest.java,37.3,287.39 -StringableObject.java,15.6,187.34 -Stub.java,0.1,144.97 -StubbedTheories.java,64.8,222.37 -StubbedTheoriesTest.java,5.05,149.87 -Sub.java,0.05,145.37 -Success.java,0.1,145.37 -SuccessfulWithDataPointFields.java,8.25,159.87 -Suite.java,30.2,223.51 -SuiteDescriptionTest.java,72.0,249.78 -SuiteMethod.java,18.7,244.31 -SuiteMethodBuilder.java,5.55,152.11 -SuiteMethodTest.java,35.3,192.12 -SuiteTest.java,55.55,221.13 -Super.java,0.05,146.12 -SynchronizedRunListener.java,40.35,196.62 -SynchronizedRunListenerTest.java,58.6,253.14 -SystemExitTest.java,17.2,234.28 -TempFolderRuleTest.java,132.0,304.32 -TemporaryFolder.java,35.45,251.32 -TemporaryFolderUsageTest.java,221.2,420.36 -Test.java,0.6,154.36 -TestCase.java,327.9,317.13 -TestCaseTest.java,49.55,249.48 -TestClass.java,42.25,284.16 -TestClassTest.java,51.0,218.99 -TestClassValidator.java,0.45,149.59 -TestDecorator.java,8.65,159.6 -TestDescriptionMethodNameTest.java,53.45,195.59 -TestDescriptionTest.java,16.65,199.64 -TestFailure.java,9.35,171.31 -TestImplementorTest.java,39.25,235.82 -TestListener.java,0.25,149.97 -TestListenerTest.java,36.3,209.97 -TestMethod.java,20.05,184.08 -TestMethodTest.java,20.15,180.61 -TestName.java,2.45,152.12 -TestResult.java,81.15,269.63 -TestRule.java,0.1,150.17 -TestRuleTest.java,194.8,400.47 -TestRunListener.java,0.35,150.45 -TestRunner.java,121.9,288.95 -TestSetup.java,7.9,162.94 -TestSuite.java,121.55,400.45 -TestSystem.java,0.4,154.46 -TestTimedOutException.java,16.25,186.45 -TestWatcher.java,57.9,249.42 -TestWatcherTest.java,21.85,198.47 -TestWatchman.java,7.5,199.52 -TestWatchmanTest.java,23.25,184.17 -TestWithParameters.java,14.2,192.67 -TestWithParametersTest.java,72.95,246.14 -TestedOn.java,0.3,156.14 -TestedOnSupplier.java,23.8,186.65 -TestedOnSupplierTest.java,8.65,166.66 -TextFeedbackTest.java,148.7,345.71 -TextListener.java,98.85,294.71 -TextListenerTest.java,51.2,249.78 -TextRunnerSingleMethodTest.java,25.45,217.49 -TextRunnerTest.java,45.35,319.15 -Theories.java,302.5,420.29 -TheoriesPerformanceTest.java,0.2,160.89 -Theory.java,0.3,160.89 -TheoryTestUtils.java,16.1,194.89 -ThreeTestCases.java,0.1,160.94 -ThrowableCauseMatcher.java,43.1,216.44 -ThrowableCauseMatcherTest.java,0.55,160.94 -ThrowableMessageMatcher.java,43.6,215.94 -Throwables.java,6.85,186.44 -Timeout.java,11.0,205.48 -TimeoutRuleTest.java,123.55,315.6 -TimeoutTest.java,168.2,368.17 -TypeMatchingBetweenMultiDataPointsMethod.java,0.8,162.67 -TypeSafeMatcher.java,15.4,279.17 -UnsuccessfulWithDataPointFields.java,15.05,216.06 -UseSuiteAsASuperclassTest.java,5.3,176.23 -UserStopTest.java,13.85,179.3 -ValidateWith.java,0.45,163.31 -ValidationError.java,21.1,185.81 -ValidationTest.java,5.4,169.81 -Verifier.java,5.65,169.31 -VerifierRuleTest.java,149.0,345.88 -Version.java,10.2,175.87 -WasRun.java,0.15,163.88 -WhenNoParametersMatch.java,3.4,185.38 -WithAutoGeneratedDataPoints.java,3.55,186.45 -WithDataPointMethod.java,10.95,209.63 -WithExtendedParameterSources.java,23.7,200.88 -WithNamedDataPoints.java,5.4,197.93 -WithOnlyTestAnnotations.java,10.75,185.07 -WithParameterSupplier.java,35.9,225.6 -WithUnresolvedGenericTypeVariablesOnTheoryParms.java,22.05,308.7 -package-info.java,0.0,165.24 \ No newline at end of file diff --git a/benchmarks/src/test/result/Antlr/Antlr_java_correct_rxjava-2-2-2.csv b/benchmarks/src/test/result/Antlr/Antlr_java_correct_rxjava-2-2-2.csv deleted file mode 100644 index c0780155b..000000000 --- a/benchmarks/src/test/result/Antlr/Antlr_java_correct_rxjava-2-2-2.csv +++ /dev/null @@ -1,1614 +0,0 @@ -fileName,processing_tim_avg_10_times_millis,max_heap_size_mbMb -AbstractDirectTask.java,126.1,200.93 -AbstractDirectTaskTest.java,205.8,159.83 -AbstractFlowableWithUpstream.java,8.2,41.59 -AbstractFlowableWithUpstreamTest.java,57.0,168.72 -AbstractMaybeWithUpstream.java,1.1,15.99 -AbstractMaybeWithUpstreamTest.java,17.3,30.61 -AbstractObservableWithUpstream.java,1.4,15.98 -AbstractObservableWithUpstreamTest.java,12.2,30.61 -AbstractSchedulerConcurrencyTests.java,2668.3,361.07 -AbstractSchedulerTests.java,2925.0,362.08 -Action.java,0.4,55.18 -ActionDisposable.java,13.0,94.95 -AllTckTest.java,10.9,116.09 -AmbArrayTckTest.java,36.6,89.35 -AmbTckTest.java,68.5,123.33 -AnyTckTest.java,10.3,84.34 -AppendOnlyLinkedArrayList.java,44.5,102.39 -ArrayCompositeDisposable.java,63.8,213.69 -ArrayCompositeDisposableTest.java,165.0,149.63 -ArrayCompositeSubscription.java,22.8,83.16 -ArrayCompositeSubscriptionTest.java,128.7,95.42 -ArrayListSupplier.java,6.8,108.7 -AsyncProcessor.java,270.4,280.51 -AsyncProcessorAsPublisherTckTest.java,270.8,238.4 -AsyncProcessorTest.java,1022.2,251.68 -AsyncSubject.java,188.0,149.92 -AsyncSubjectTest.java,955.7,234.29 -AsyncSubscription.java,43.5,138.43 -AsyncSubscriptionTest.java,189.6,168.84 -AtomicThrowable.java,6.1,84.49 -AtomicThrowableTest.java,5.9,73.69 -BackpressureEnumTest.java,10.2,79.69 -BackpressureHelper.java,54.0,134.22 -BackpressureHelperTest.java,203.6,172.83 -BackpressureKind.java,0.4,69.05 -BackpressureOverflowStrategy.java,0.3,69.23 -BackpressureStrategy.java,0.1,69.23 -BackpressureSupport.java,0.5,73.73 -BaseTck.java,23.7,154.78 -BaseTypeAnnotations.java,235.2,243.3 -BaseTypeParser.java,91.6,186.57 -BasicFuseableConditionalSubscriber.java,72.9,141.24 -BasicFuseableConditionalSubscriberTest.java,27.7,123.24 -BasicFuseableObserver.java,56.6,137.4 -BasicFuseableObserverTest.java,36.9,143.89 -BasicFuseableSubscriber.java,58.2,141.51 -BasicFuseableSubscriberTest.java,26.3,107.01 -BasicIntQueueDisposable.java,0.5,74.52 -BasicIntQueueSubscription.java,0.5,74.53 -BasicQueueDisposable.java,0.3,74.53 -BasicQueueDisposableTest.java,14.0,97.02 -BasicQueueSubscription.java,0.3,74.59 -BehaviorProcessor.java,445.8,252.28 -BehaviorProcessorAsPublisherTckTest.java,280.9,240.22 -BehaviorProcessorTest.java,1718.6,258.15 -BehaviorSubject.java,267.8,235.05 -BehaviorSubjectTest.java,1506.9,287.85 -Beta.java,0.3,84.43 -BiConsumer.java,0.3,84.43 -BiConsumerSingleObserver.java,58.3,179.43 -BiFunction.java,0.5,85.64 -BiPredicate.java,0.1,84.7 -BinaryFlatMapPerf.java,223.2,196.96 -BlockingBaseObserver.java,22.0,141.91 -BlockingBaseSubscriber.java,38.1,191.04 -BlockingFirstObserver.java,5.7,91.85 -BlockingFirstObserverTest.java,38.5,140.85 -BlockingFirstSubscriber.java,11.8,109.36 -BlockingFlowableIterable.java,93.9,186.33 -BlockingFlowableLatest.java,106.3,270.66 -BlockingFlowableLatestTest.java,566.3,280.44 -BlockingFlowableMostRecent.java,47.9,196.23 -BlockingFlowableMostRecentTest.java,210.3,218.29 -BlockingFlowableNext.java,107.9,290.05 -BlockingFlowableNextTest.java,1204.6,327.18 -BlockingFlowableToFutureTest.java,159.8,264.19 -BlockingFlowableToIteratorTest.java,238.0,245.36 -BlockingGetPerf.java,19.3,130.24 -BlockingHelper.java,35.5,270.74 -BlockingHelperTest.java,56.7,177.4 -BlockingIgnoringReceiver.java,0.3,106.43 -BlockingLastObserver.java,0.4,106.43 -BlockingLastSubscriber.java,0.1,106.43 -BlockingMultiObserver.java,61.8,242.94 -BlockingMultiObserverTest.java,189.4,159.73 -BlockingObservableIterable.java,89.5,294.47 -BlockingObservableLatest.java,69.8,261.36 -BlockingObservableLatestTest.java,560.0,305.09 -BlockingObservableMostRecent.java,32.7,145.6 -BlockingObservableMostRecentTest.java,203.5,144.58 -BlockingObservableNext.java,57.6,236.68 -BlockingObservableNextTest.java,924.7,332.1 -BlockingObservableToFutureTest.java,151.0,282.97 -BlockingObservableToIteratorTest.java,160.5,285.97 -BlockingObserver.java,66.6,187.97 -BlockingObserverTest.java,14.4,123.98 -BlockingPerf.java,19.5,130.48 -BlockingSubscriber.java,77.6,218.48 -BlockingSubscriberTest.java,98.6,263.53 -BooleanSubscription.java,6.4,121.69 -BooleanSupplier.java,0.0,108.24 -BoundedSubscriber.java,99.6,224.29 -BoundedSubscriberTest.java,583.4,319.52 -BufferBoundaryTckTest.java,15.8,216.76 -BufferExactSizeTckTest.java,6.5,124.74 -BufferUntilSubscriberTest.java,250.6,274.67 -Burst.java,39.4,204.21 -CacheTckTest.java,5.6,122.82 -CachedThreadSchedulerTest.java,201.3,313.07 -CallableAsyncPerf.java,126.9,296.57 -CallbackCompletableObserver.java,59.8,185.62 -CallbackCompletableObserverTest.java,4.9,124.14 -Cancellable.java,0.3,118.14 -CancellableDisposable.java,19.7,177.64 -CancellableDisposableTest.java,78.9,233.29 -CapturingUncaughtExceptionHandler.java,6.7,131.85 -CheckLocalVariablesInTests.java,243.2,360.12 -CheckReturnValue.java,0.1,122.23 -CollectTckTest.java,18.5,234.23 -CombineLatestArrayDelayErrorTckTest.java,62.4,231.78 -CombineLatestArrayTckTest.java,46.2,171.81 -CombineLatestIterableDelayErrorTckTest.java,89.9,273.77 -CombineLatestIterableTckTest.java,73.1,214.51 -Completable.java,1040.7,334.9 -CompletableAmb.java,158.7,262.38 -CompletableAmbTest.java,555.5,309.47 -CompletableAndThenObservable.java,54.0,203.77 -CompletableAndThenObservableTest.java,139.3,351.86 -CompletableAndThenPublisher.java,79.1,227.02 -CompletableAndThenPublisherTckTest.java,14.1,181.05 -CompletableAndThenPublisherTest.java,105.1,334.78 -CompletableAndThenTest.java,188.6,338.39 -CompletableAwaitTest.java,39.3,170.94 -CompletableCache.java,101.7,271.94 -CompletableCacheTest.java,334.9,300.88 -CompletableConcat.java,200.3,319.42 -CompletableConcatArray.java,37.2,240.92 -CompletableConcatIterable.java,100.7,249.57 -CompletableConcatTest.java,1321.5,382.15 -CompletableConverter.java,0.2,142.71 -CompletableCreate.java,94.8,241.54 -CompletableCreateTest.java,1054.5,406.96 -CompletableDefer.java,30.4,182.52 -CompletableDelay.java,111.6,268.93 -CompletableDelayTest.java,183.1,362.37 -CompletableDetach.java,36.5,192.87 -CompletableDetachTest.java,214.5,396.46 -CompletableDisposeOn.java,47.0,203.46 -CompletableDisposeOnTest.java,133.5,345.46 -CompletableDoFinally.java,54.6,223.12 -CompletableDoFinallyTest.java,93.8,273.65 -CompletableDoOnEvent.java,61.1,243.41 -CompletableDoOnTest.java,114.2,337.47 -CompletableEmitter.java,0.0,148.86 -CompletableEmpty.java,6.2,154.86 -CompletableError.java,8.0,157.86 -CompletableErrorSupplier.java,25.3,183.36 -CompletableFromAction.java,32.8,206.38 -CompletableFromActionTest.java,136.3,319.47 -CompletableFromCallable.java,40.0,226.46 -CompletableFromCallableTest.java,255.1,244.56 -CompletableFromMaybeTest.java,45.0,207.92 -CompletableFromObservable.java,26.6,180.42 -CompletableFromObservableTest.java,46.2,207.42 -CompletableFromPublisher.java,41.7,199.92 -CompletableFromPublisherTest.java,111.2,289.93 -CompletableFromRunnable.java,31.1,186.01 -CompletableFromRunnableTest.java,138.1,317.01 -CompletableFromSingle.java,26.7,180.51 -CompletableFromSingleTest.java,34.4,193.01 -CompletableFromUnsafeSource.java,6.3,155.51 -CompletableHide.java,36.4,192.01 -CompletableHideTest.java,99.0,269.51 -CompletableLift.java,18.3,170.02 -CompletableLiftTest.java,19.9,172.02 -CompletableMerge.java,264.9,260.05 -CompletableMergeArray.java,66.3,257.85 -CompletableMergeDelayErrorArray.java,73.2,254.98 -CompletableMergeDelayErrorIterable.java,102.0,314.07 -CompletableMergeIterable.java,117.9,302.73 -CompletableMergeIterableTest.java,257.9,341.51 -CompletableMergeTest.java,2102.5,398.73 -CompletableNever.java,6.3,162.73 -CompletableObserveOn.java,82.8,254.73 -CompletableObserveOnTest.java,93.7,197.95 -CompletableObserver.java,0.6,156.77 -CompletableOnErrorComplete.java,60.1,246.72 -CompletableOnErrorXTest.java,9.5,183.58 -CompletableOnSubscribe.java,0.2,157.14 -CompletableOperator.java,0.3,157.14 -CompletablePeek.java,142.5,329.27 -CompletablePeekTest.java,44.7,206.89 -CompletableRepeatWhenTest.java,46.6,191.88 -CompletableResumeNext.java,82.8,259.38 -CompletableResumeNextTest.java,321.7,372.47 -CompletableRetryTest.java,329.6,315.91 -CompletableSource.java,0.1,160.97 -CompletableSubject.java,127.6,301.06 -CompletableSubjectTest.java,308.3,323.28 -CompletableSubscribeOn.java,55.5,221.57 -CompletableSubscribeOnTest.java,117.3,202.14 -CompletableSubscribeTest.java,12.9,177.07 -CompletableTakeUntilCompletable.java,121.8,305.58 -CompletableTakeUntilTest.java,337.2,302.44 -CompletableTest.java,java.lang.OutOfMemoryError,OOM -CompletableTimeout.java,135.7,364.28 -CompletableTimeoutTest.java,158.8,353.42 -CompletableTimer.java,54.5,243.42 -CompletableTimerTest.java,104.6,265.85 -CompletableToFlowable.java,6.3,176.85 -CompletableToFlowableTest.java,31.1,206.86 -CompletableToObservable.java,36.3,216.36 -CompletableToObservableTest.java,65.0,249.88 -CompletableToSingle.java,56.0,244.83 -CompletableTransformer.java,0.4,170.68 -CompletableUnsafeTest.java,142.3,323.85 -CompletableUsing.java,217.1,398.77 -CompletableUsingTest.java,1567.4,385.62 -CompositeDisposable.java,131.3,325.67 -CompositeDisposableTest.java,1691.0,348.36 -CompositeException.java,237.5,376.34 -CompositeExceptionTest.java,350.1,337.86 -ComputationScheduler.java,203.6,380.58 -ComputationSchedulerInternalTest.java,19.3,214.23 -ComputationSchedulerTests.java,595.1,333.06 -ConcatArrayEagerTckTest.java,68.9,291.07 -ConcatIterableEagerTckTest.java,40.4,232.66 -ConcatMapIterableTckTest.java,13.6,225.7 -ConcatMapMaybeTckTest.java,11.3,201.8 -ConcatMapSingleTckTest.java,11.7,201.8 -ConcatMapTckTest.java,11.4,201.8 -ConcatPublisherEagerTckTest.java,70.3,271.3 -ConcatPublisherTckTest.java,67.3,271.3 -ConcatTckTest.java,35.7,231.8 -ConcatWithCompletableTckTest.java,11.5,201.3 -ConcatWithMaybeEmptyTckTest.java,10.6,201.3 -ConcatWithMaybeTckTest.java,41.0,299.3 -ConcatWithSingleTckTest.java,33.5,230.66 -ConditionalSubscriber.java,0.2,188.68 -ConnectConsumer.java,0.5,190.68 -ConnectableFlowable.java,55.4,258.69 -ConnectableObservable.java,58.1,255.2 -Consumer.java,0.2,188.7 -ConsumerSingleObserver.java,52.4,250.7 -ConsumerSingleObserverTest.java,9.0,199.2 -ConverterTest.java,199.3,431.98 -CrashingIterable.java,1.5,201.48 -CrashingMappedIterable.java,6.3,213.56 -CreateTckTest.java,68.2,293.68 -DefaultIfEmptyTckTest.java,9.4,200.69 -DefaultObserver.java,14.2,219.19 -DefaultSubscriber.java,19.6,210.72 -DefaultSubscriberTest.java,24.1,226.22 -DeferTckTest.java,30.9,271.25 -DeferredScalarDisposable.java,36.0,265.98 -DeferredScalarObserver.java,15.4,213.25 -DeferredScalarObserverTest.java,998.3,406.45 -DeferredScalarSubscriber.java,30.4,227.68 -DeferredScalarSubscriberTest.java,1108.2,383.4 -DeferredScalarSubscription.java,66.5,382.36 -DeferredScalarSubscriptionTest.java,96.1,330.52 -DelaySubscriptionTckTest.java,9.0,206.61 -DelayTckTest.java,9.4,206.61 -Disposable.java,0.1,195.62 -DisposableCompletableObserver.java,15.1,212.62 -DisposableCompletableObserverTest.java,129.5,331.44 -DisposableContainer.java,0.2,195.94 -DisposableHelper.java,114.7,381.94 -DisposableHelperTest.java,143.0,371.97 -DisposableLambdaObserver.java,75.2,290.47 -DisposableLambdaObserverTest.java,84.1,285.7 -DisposableMaybeObserver.java,15.4,214.2 -DisposableMaybeObserverTest.java,126.5,352.2 -DisposableObserver.java,16.1,214.21 -DisposableObserverTest.java,133.5,345.71 -DisposableSingleObserver.java,18.7,214.21 -DisposableSingleObserverTest.java,124.0,343.71 -DisposableSubscriber.java,21.9,222.72 -DisposableSubscriberTest.java,114.8,333.22 -Disposables.java,38.6,242.72 -DisposablesTest.java,157.5,379.84 -DisposeOnCancel.java,6.3,203.34 -DisposeOnCancelTest.java,11.3,211.34 -DistinctTckTest.java,18.5,228.34 -DistinctUntilChangedTckTest.java,9.2,208.38 -DoAfterNextTckTest.java,11.2,210.38 -DoFinallyTckTest.java,9.5,208.38 -DoOnNextTckTest.java,11.0,210.38 -EachTypeFlatMapPerf.java,220.0,433.64 -ElementAtTckTest.java,3.6,201.64 -Emitter.java,0.0,197.64 -EmptyCompletableObserver.java,23.5,225.14 -EmptyCompletableObserverTest.java,2.2,199.64 -EmptyComponent.java,17.6,217.64 -EmptyComponentTest.java,86.1,300.17 -EmptyDisposable.java,78.4,294.18 -EmptyDisposableTest.java,14.3,214.75 -EmptySubscription.java,27.7,228.25 -EmptyTckTest.java,3.2,208.24 -EndConsumerHelper.java,95.8,304.13 -EndConsumerHelperTest.java,646.3,329.04 -ErrorMode.java,0.1,198.33 -ExceptionHelper.java,76.5,276.4 -ExceptionHelperTest.java,29.5,267.45 -Exceptions.java,19.5,267.17 -ExceptionsNullTest.java,0.3,199.39 -ExceptionsTest.java,1017.3,383.82 -ExecutorScheduler.java,247.9,283.16 -ExecutorSchedulerDelayedRunnableTest.java,29.2,239.46 -ExecutorSchedulerTest.java,968.9,377.28 -Experimental.java,0.0,205.84 -FailOnBlockingTest.java,528.6,408.99 -FilterTckTest.java,12.7,258.89 -FirstTckTest.java,4.2,211.11 -FixLicenseHeaders.java,323.7,304.76 -FlatMapJustPerf.java,31.7,268.67 -FlatMapTckTest.java,11.8,224.24 -FlattenCrossMapPerf.java,46.5,265.24 -FlattenJustPerf.java,37.1,253.28 -FlattenRangePerf.java,37.8,255.28 -Flowable.java,6968.1,364.84 -FlowableAll.java,60.5,291.74 -FlowableAllSingle.java,77.2,310.77 -FlowableAllTest.java,986.3,350.24 -FlowableAmb.java,212.0,419.02 -FlowableAmbTest.java,2109.9,403.83 -FlowableAny.java,59.7,297.72 -FlowableAnySingle.java,76.5,318.72 -FlowableAnyTest.java,1064.9,331.52 -FlowableAsObservableTest.java,63.4,306.79 -FlowableAutoConnect.java,12.7,241.29 -FlowableAutoConnectTest.java,6.7,234.28 -FlowableBackpressureTests.java,2441.4,453.79 -FlowableBlockingSubscribe.java,111.7,360.99 -FlowableBlockingTest.java,1046.3,404.98 -FlowableBuffer.java,416.1,362.98 -FlowableBufferBoundary.java,378.4,435.69 -FlowableBufferBoundarySupplier.java,248.1,354.34 -FlowableBufferExactBoundary.java,157.0,425.08 -FlowableBufferTest.java,8761.4,405.7 -FlowableBufferTimed.java,595.5,419.63 -FlowableCache.java,245.1,425.33 -FlowableCacheTest.java,1212.4,370.8 -FlowableCastTest.java,91.9,371.79 -FlowableCollect.java,82.3,356.8 -FlowableCollectSingle.java,95.1,370.31 -FlowableCollectTest.java,902.4,473.66 -FlowableCombineLatest.java,java.lang.OutOfMemoryError,OOM -FlowableCombineLatestTest.java,6446.4,435.59 -FlowableCombineLatestTests.java,106.5,395.19 -FlowableConcatArray.java,133.1,424 -FlowableConcatDelayErrorTest.java,943.3,448.31 -FlowableConcatMap.java,806.7,435.43 -FlowableConcatMapCompletable.java,245.8,412.22 -FlowableConcatMapCompletablePerf.java,89.4,421.89 -FlowableConcatMapCompletableTest.java,945.4,422.81 -FlowableConcatMapEager.java,391.5,418.87 -FlowableConcatMapEagerPublisher.java,20.2,321.92 -FlowableConcatMapEagerTest.java,3595.7,433.83 -FlowableConcatMapMaybe.java,262.0,452.16 -FlowableConcatMapMaybeEmptyPerf.java,96.9,417.29 -FlowableConcatMapMaybePerf.java,89.3,417.29 -FlowableConcatMapMaybeTest.java,939.2,437.28 -FlowableConcatMapPublisher.java,34.6,349.64 -FlowableConcatMapSingle.java,210.5,430.89 -FlowableConcatMapSinglePerf.java,88.4,420.64 -FlowableConcatMapSingleTest.java,707.2,434.13 -FlowableConcatMapTest.java,80.7,408.99 -FlowableConcatTest.java,7398.4,484.9 -FlowableConcatTests.java,201.4,404.13 -FlowableConcatWithCompletable.java,65.7,419.61 -FlowableConcatWithCompletableTest.java,191.2,443.14 -FlowableConcatWithMaybe.java,47.4,394.73 -FlowableConcatWithMaybeTest.java,184.1,431 -FlowableConcatWithSingle.java,42.5,388.24 -FlowableConcatWithSingleTest.java,99.3,446.74 -FlowableConversionTest.java,611.5,420.58 -FlowableConverter.java,0.3,344.63 -FlowableCount.java,36.9,386.13 -FlowableCountSingle.java,47.8,399.13 -FlowableCountTest.java,394.3,419.76 -FlowableCovarianceTest.java,611.1,421.73 -FlowableCreate.java,320.1,468.75 -FlowableCreateTest.java,java.lang.OutOfMemoryError,OOM -FlowableDebounce.java,172.5,395.41 -FlowableDebounceTest.java,1978.1,477.1 -FlowableDebounceTimed.java,187.9,415.7 -FlowableDefaultIfEmptyTest.java,204.5,387.58 -FlowableDefer.java,31.3,390.39 -FlowableDeferTest.java,70.9,444.88 -FlowableDelay.java,129.3,395.53 -FlowableDelaySubscriptionOther.java,78.0,440.94 -FlowableDelaySubscriptionOtherTest.java,1290.3,450.87 -FlowableDelayTest.java,2734.4,488.45 -FlowableDematerialize.java,111.0,411.32 -FlowableDematerializeTest.java,389.8,430.49 -FlowableDetach.java,54.4,416.66 -FlowableDetachTest.java,371.0,419.21 -FlowableDistinct.java,154.6,437.02 -FlowableDistinctTest.java,578.4,429.54 -FlowableDistinctUntilChanged.java,104.7,417.39 -FlowableDistinctUntilChangedTest.java,1081.4,422.47 -FlowableDoAfterNext.java,96.0,420.01 -FlowableDoAfterNextTest.java,313.6,409.57 -FlowableDoAfterTerminateTest.java,60.8,426.56 -FlowableDoFinally.java,180.0,421.72 -FlowableDoFinallyTest.java,1094.1,498.67 -FlowableDoOnEach.java,444.9,438.37 -FlowableDoOnEachTest.java,1781.6,446.77 -FlowableDoOnLifecycle.java,116.1,422.56 -FlowableDoOnLifecycleTest.java,397.6,465.97 -FlowableDoOnRequestTest.java,53.4,414.17 -FlowableDoOnSubscribeTest.java,167.4,419.24 -FlowableDoOnTest.java,53.0,427.17 -FlowableDoOnUnsubscribeTest.java,147.2,447.39 -FlowableElementAt.java,71.3,440.79 -FlowableElementAtMaybe.java,67.1,442.29 -FlowableElementAtSingle.java,85.3,377.45 -FlowableElementAtTest.java,1114.5,472.03 -FlowableEmitter.java,0.5,363.49 -FlowableEmpty.java,6.7,369.99 -FlowableError.java,27.4,393.49 -FlowableErrorHandlingTests.java,105.6,419.97 -FlowableEventStream.java,94.1,433.96 -FlowableEventStreamTest.java,6.4,369.83 -FlowableFilter.java,90.5,387.34 -FlowableFilterTest.java,1583.9,492.23 -FlowableFirstTest.java,928.9,428.57 -FlowableFlatMap.java,java.lang.OutOfMemoryError,OOM -FlowableFlatMapCompletable.java,168.8,419.19 -FlowableFlatMapCompletableAsyncPerf.java,91.3,429.23 -FlowableFlatMapCompletableCompletable.java,178.0,419.82 -FlowableFlatMapCompletablePerf.java,94.7,403.11 -FlowableFlatMapCompletableSyncPerf.java,44.5,422.81 -FlowableFlatMapCompletableTest.java,1303.5,484.14 -FlowableFlatMapMaybe.java,392.0,488.39 -FlowableFlatMapMaybeEmptyPerf.java,92.5,407.55 -FlowableFlatMapMaybePerf.java,100.6,406.75 -FlowableFlatMapMaybeTest.java,1199.1,501.52 -FlowableFlatMapPublisher.java,38.8,407.93 -FlowableFlatMapSingle.java,333.1,441.22 -FlowableFlatMapSinglePerf.java,94.4,408.41 -FlowableFlatMapSingleTest.java,1144.4,495.56 -FlowableFlatMapTest.java,java.lang.OutOfMemoryError,OOM -FlowableFlattenIterable.java,435.2,439.45 -FlowableFlattenIterableTest.java,2736.5,503.56 -FlowableForEachTest.java,82.3,418.23 -FlowableFromArray.java,157.5,457.21 -FlowableFromArrayTest.java,377.6,450.28 -FlowableFromCallable.java,52.9,439.78 -FlowableFromCallableTest.java,346.2,435.44 -FlowableFromFuture.java,44.1,424.63 -FlowableFromIterable.java,301.9,425.81 -FlowableFromIterableTest.java,2016.0,475.02 -FlowableFromObservable.java,38.0,423.94 -FlowableFromObservableTest.java,30.0,415.94 -FlowableFromPublisher.java,6.1,386.94 -FlowableFromSourceTest.java,2054.1,429.35 -FlowableFuseableTest.java,164.9,400.83 -FlowableGenerate.java,96.3,425.21 -FlowableGenerateTest.java,1441.7,500.49 -FlowableGroupBy.java,714.8,452.13 -FlowableGroupByTest.java,7335.6,500.04 -FlowableGroupByTests.java,239.5,480.12 -FlowableGroupJoin.java,java.lang.OutOfMemoryError,OOM -FlowableGroupJoinTest.java,2659.1,500.38 -FlowableHide.java,48.6,434.18 -FlowableHideTest.java,124.3,436.85 -FlowableIgnoreElements.java,44.4,423.03 -FlowableIgnoreElementsCompletable.java,47.7,428.07 -FlowableIgnoreElementsTest.java,678.0,502.62 -FlowableInternalHelper.java,170.1,488.75 -FlowableInternalHelperTest.java,12.7,425.16 -FlowableInterval.java,108.7,447.27 -FlowableIntervalRange.java,104.6,435.44 -FlowableIntervalRangeTest.java,261.6,466.3 -FlowableIntervalTest.java,106.6,445.7 -FlowableJoin.java,java.lang.OutOfMemoryError,OOM -FlowableJoinTest.java,2113.7,497.37 -FlowableJust.java,13.5,431.11 -FlowableLastMaybe.java,50.0,443.91 -FlowableLastSingle.java,64.1,426.4 -FlowableLastTest.java,1342.1,465.55 -FlowableLift.java,26.9,443.26 -FlowableLiftTest.java,23.5,443.26 -FlowableLimit.java,94.0,459.38 -FlowableLimitTest.java,322.4,449.42 -FlowableMap.java,136.2,435.5 -FlowableMapNotification.java,105.3,427.89 -FlowableMapNotificationTest.java,1188.9,498.77 -FlowableMapPublisher.java,14.0,435.59 -FlowableMapTest.java,2272.0,490.71 -FlowableMaterialize.java,70.5,492.35 -FlowableMaterializeTest.java,735.4,491.27 -FlowableMergeDelayErrorTest.java,4357.2,493.74 -FlowableMergeMaxConcurrentTest.java,java.lang.OutOfMemoryError,OOM -FlowableMergeTest.java,java.lang.OutOfMemoryError,OOM -FlowableMergeTests.java,193.7,476.41 -FlowableMergeWithCompletable.java,144.7,433.58 -FlowableMergeWithCompletableTest.java,170.3,450.88 -FlowableMergeWithMaybe.java,258.9,465.26 -FlowableMergeWithMaybeTest.java,728.7,480.84 -FlowableMergeWithSingle.java,244.9,461.44 -FlowableMergeWithSingleTest.java,653.9,472.79 -FlowableNever.java,6.6,438.21 -FlowableNotificationTest.java,375.5,505.3 -FlowableNullTests.java,14871.3,497.28 -FlowableObserveOn.java,545.1,497.64 -FlowableObserveOnTest.java,6003.6,501.28 -FlowableOnBackpressureBuffer.java,268.2,462.82 -FlowableOnBackpressureBufferStrategy.java,224.0,464.96 -FlowableOnBackpressureBufferStrategyTest.java,802.1,498.66 -FlowableOnBackpressureBufferTest.java,525.0,483.9 -FlowableOnBackpressureDrop.java,108.0,489.5 -FlowableOnBackpressureDropTest.java,1006.7,494.02 -FlowableOnBackpressureError.java,70.5,446.59 -FlowableOnBackpressureErrorTest.java,157.7,497.47 -FlowableOnBackpressureLatest.java,103.1,463.83 -FlowableOnBackpressureLatestTest.java,452.6,486.36 -FlowableOnErrorNext.java,85.5,466.07 -FlowableOnErrorResumeNextViaFlowableTest.java,613.5,492.22 -FlowableOnErrorResumeNextViaFunctionTest.java,1256.0,501.11 -FlowableOnErrorReturn.java,61.4,463.59 -FlowableOnErrorReturnTest.java,764.1,487.83 -FlowableOnExceptionResumeNextViaFlowableTest.java,java.lang.OutOfMemoryError,OOM -FlowableOnSubscribe.java,0.4,445.48 -FlowableOperator.java,1.1,445.97 -FlowableProcessor.java,5.0,452 -FlowableProcessorTest.java,20.9,470 -FlowablePublish.java,java.lang.OutOfMemoryError,OOM -FlowablePublishFunctionTest.java,java.lang.OutOfMemoryError,OOM -FlowablePublishMulticast.java,java.lang.OutOfMemoryError,OOM -FlowablePublishMulticastTest.java,340.5,493.87 -FlowablePublishTest.java,java.lang.OutOfMemoryError,OOM -FlowableRange.java,122.9,496.66 -FlowableRangeLong.java,118.5,480.9 -FlowableRangeLongTest.java,1291.5,504.02 -FlowableRangeTest.java,1193.9,500.86 -FlowableReduce.java,94.7,478.29 -FlowableReduceMaybe.java,113.9,467.61 -FlowableReduceSeedSingle.java,106.9,478.53 -FlowableReduceTest.java,1909.1,495.41 -FlowableReduceTests.java,184.0,477.08 -FlowableReduceWithSingle.java,43.8,450.4 -FlowableReduceWithSingleTest.java,86.0,486.87 -FlowableRefCount.java,java.lang.OutOfMemoryError,OOM -FlowableRefCountTest.java,java.lang.OutOfMemoryError,OOM -FlowableRepeat.java,52.9,468.12 -FlowableRepeatTest.java,902.8,480.75 -FlowableRepeatUntil.java,66.2,473.54 -FlowableRepeatWhen.java,170.0,469.65 -FlowableReplay.java,java.lang.OutOfMemoryError,OOM -FlowableReplayTest.java,java.lang.OutOfMemoryError,OOM -FlowableRetryBiPredicate.java,92.8,478.47 -FlowableRetryPredicate.java,82.0,472.95 -FlowableRetryTest.java,java.lang.OutOfMemoryError,OOM -FlowableRetryWhen.java,62.3,472.97 -FlowableRetryWithPredicateTest.java,2051.8,501.54 -FlowableSamplePublisher.java,259.1,489.62 -FlowableSampleTest.java,2153.0,486.74 -FlowableSampleTimed.java,173.1,494.62 -FlowableScalarXMap.java,209.3,489.71 -FlowableScalarXMapTest.java,896.6,496.39 -FlowableScan.java,112.1,476.95 -FlowableScanSeed.java,226.2,501.85 -FlowableScanTest.java,java.lang.OutOfMemoryError,OOM -FlowableSequenceEqual.java,java.lang.OutOfMemoryError,OOM -FlowableSequenceEqualSingle.java,563.9,501.6 -FlowableSequenceEqualTest.java,8412.8,500.29 -FlowableSerializeTest.java,java.lang.OutOfMemoryError,OOM -FlowableSerialized.java,12.4,475.66 -FlowableSingle.java,88.3,490.49 -FlowableSingleMaybe.java,85.1,480.45 -FlowableSingleSingle.java,94.9,468.71 -FlowableSingleTest.java,2529.3,490.38 -FlowableSkip.java,60.5,484.94 -FlowableSkipLast.java,73.0,486.42 -FlowableSkipLastTest.java,471.0,504.18 -FlowableSkipLastTimed.java,150.4,492.24 -FlowableSkipLastTimedTest.java,689.2,494.27 -FlowableSkipTest.java,450.7,500.43 -FlowableSkipTimedTest.java,429.7,475.41 -FlowableSkipUntil.java,141.9,482.33 -FlowableSkipUntilTest.java,1072.5,487.09 -FlowableSkipWhile.java,93.3,487.54 -FlowableSkipWhileTest.java,658.7,499.82 -FlowableStartWithTests.java,56.6,480.05 -FlowableSubscribeOn.java,140.1,495.85 -FlowableSubscribeOnTest.java,java.lang.OutOfMemoryError,OOM -FlowableSubscriber.java,0.2,465.75 -FlowableSubscriberTest.java,4307.2,504.89 -FlowableSwitchIfEmpty.java,46.3,488.15 -FlowableSwitchIfEmptyTest.java,java.lang.OutOfMemoryError,OOM -FlowableSwitchMap.java,java.lang.OutOfMemoryError,OOM -FlowableSwitchMapCompletable.java,242.7,489.56 -FlowableSwitchMapCompletablePerf.java,305.2,482.71 -FlowableSwitchMapCompletableTest.java,1754.9,497.63 -FlowableSwitchMapMaybe.java,282.4,494.6 -FlowableSwitchMapMaybeEmptyPerf.java,317.8,495.54 -FlowableSwitchMapMaybePerf.java,323.1,489.29 -FlowableSwitchMapMaybeTest.java,java.lang.OutOfMemoryError,OOM -FlowableSwitchMapSingle.java,224.2,474.72 -FlowableSwitchMapSinglePerf.java,325.7,489.92 -FlowableSwitchMapSingleTest.java,3423.0,498 -FlowableSwitchTest.java,java.lang.OutOfMemoryError,OOM -FlowableTake.java,93.7,487.65 -FlowableTakeLast.java,356.3,481.54 -FlowableTakeLastOne.java,42.9,495.39 -FlowableTakeLastOneTest.java,396.3,503.99 -FlowableTakeLastTest.java,1278.4,500.8 -FlowableTakeLastTimed.java,java.lang.OutOfMemoryError,OOM -FlowableTakeLastTimedTest.java,1492.1,499.26 -FlowableTakePublisher.java,14.2,487.97 -FlowableTakeTest.java,java.lang.OutOfMemoryError,OOM -FlowableTakeTimedTest.java,294.8,482.7 -FlowableTakeUntil.java,164.6,487.85 -FlowableTakeUntilPredicate.java,82.8,490.59 -FlowableTakeUntilPredicateTest.java,975.7,498.71 -FlowableTakeUntilTest.java,1422.0,499.96 -FlowableTakeWhile.java,85.6,490.6 -FlowableTakeWhileTest.java,1731.5,494.02 -FlowableTests.java,java.lang.OutOfMemoryError,OOM -FlowableThrottleFirstTest.java,1931.1,502.87 -FlowableThrottleFirstTimed.java,480.1,503.15 -FlowableThrottleLastTests.java,133.5,477.76 -FlowableThrottleLatest.java,440.7,499.22 -FlowableThrottleLatestTest.java,1018.7,500.82 -FlowableThrottleWithTimeoutTests.java,147.7,482.03 -FlowableTimeInterval.java,96.8,495.27 -FlowableTimeIntervalTest.java,697.9,500.24 -FlowableTimeout.java,459.5,491.74 -FlowableTimeoutTests.java,java.lang.OutOfMemoryError,OOM -FlowableTimeoutTimed.java,936.2,500.76 -FlowableTimeoutWithSelectorTest.java,java.lang.OutOfMemoryError,OOM -FlowableTimer.java,58.0,492.99 -FlowableTimerTest.java,2765.4,501.36 -FlowableTimestampTest.java,491.4,499.56 -FlowableToCompletableTest.java,134.0,482.78 -FlowableToFutureTest.java,341.4,491.69 -FlowableToList.java,75.7,486.99 -FlowableToListSingle.java,95.6,493.32 -FlowableToListTest.java,4865.7,501.72 -FlowableToMapTest.java,1449.0,499 -FlowableToMultimapTest.java,7716.6,505.03 -FlowableToSingleTest.java,128.6,501.5 -FlowableToSortedListTest.java,2830.1,498.03 -FlowableTransformer.java,0.5,477.59 -FlowableUnsubscribeOn.java,74.2,492.32 -FlowableUnsubscribeOnTest.java,java.lang.OutOfMemoryError,OOM -FlowableUsing.java,500.2,497.72 -FlowableUsingTest.java,java.lang.OutOfMemoryError,OOM -FlowableWindow.java,java.lang.OutOfMemoryError,OOM -FlowableWindowBoundary.java,404.1,502.27 -FlowableWindowBoundarySelector.java,java.lang.OutOfMemoryError,OOM -FlowableWindowBoundarySupplier.java,java.lang.OutOfMemoryError,OOM -FlowableWindowTests.java,613.1,500.78 -FlowableWindowTimed.java,java.lang.OutOfMemoryError,OOM -FlowableWindowWithFlowableTest.java,java.lang.OutOfMemoryError,OOM -FlowableWindowWithSizeTest.java,java.lang.OutOfMemoryError,OOM -FlowableWindowWithStartEndFlowableTest.java,java.lang.OutOfMemoryError,OOM -FlowableWindowWithTimeTest.java,10591.8,500.5 -FlowableWithLatestFrom.java,251.6,503.84 -FlowableWithLatestFromMany.java,java.lang.OutOfMemoryError,OOM -FlowableWithLatestFromTest.java,java.lang.OutOfMemoryError,OOM -FlowableZip.java,java.lang.OutOfMemoryError,OOM -FlowableZipCompletionTest.java,598.5,501.62 -FlowableZipIterable.java,551.8,501.08 -FlowableZipIterableTest.java,java.lang.OutOfMemoryError,OOM -FlowableZipTest.java,java.lang.OutOfMemoryError,OOM -FlowableZipTests.java,java.lang.OutOfMemoryError,OOM -ForEachWhileObserver.java,196.6,501.09 -ForEachWhileSubscriber.java,254.9,501.01 -FromArrayTckTest.java,6.0,494.75 -FromCallableTckTest.java,12.5,498.26 -FromFutureTckTest.java,8.3,499.26 -FromIterableTckTest.java,6.1,491.78 -Function.java,0.1,485.78 -Function3.java,0.1,485.79 -Function4.java,0.5,485.79 -Function5.java,0.7,485.79 -Function6.java,0.4,485.79 -Function7.java,0.6,485.79 -Function8.java,0.6,485.79 -Function9.java,0.6,485.79 -Functions.java,java.lang.OutOfMemoryError,OOM -FunctionsTest.java,1647.7,504.29 -FuseToFlowable.java,0.4,486.67 -FuseToMaybe.java,0.2,486.67 -FuseToObservable.java,0.4,486.67 -FutureDisposable.java,8.5,502.17 -FutureDisposableTest.java,63.5,501.47 -FutureObserver.java,java.lang.OutOfMemoryError,OOM -FutureObserverTest.java,3492.8,501.79 -FutureSingleObserver.java,225.0,494.43 -FutureSingleObserverTest.java,749.8,503.24 -FutureSubscriber.java,93.9,500.51 -FutureSubscriberTest.java,1857.9,500.97 -GenerateTckTest.java,java.lang.OutOfMemoryError,OOM -GroupByTckTest.java,31.7,501.39 -GroupedFlowable.java,0.5,487.9 -GroupedObservable.java,0.6,487.9 -HalfSerializer.java,567.7,500.99 -HalfSerializerObserverTest.java,3615.5,503.31 -HalfSerializerSubscriberTest.java,3117.0,505.42 -HasUpstreamCompletableSource.java,0.3,488.46 -HasUpstreamMaybeSource.java,0.4,488.46 -HasUpstreamObservableSource.java,0.3,488.46 -HasUpstreamPublisher.java,0.2,488.46 -HasUpstreamSingleSource.java,0.0,488.46 -HashMapSupplier.java,2.2,490.46 -HideTckTest.java,9.6,499.48 -IgnoreElementsTckTest.java,3.8,492.48 -ImmediateThinScheduler.java,22.3,498.32 -ImmediateThinSchedulerTest.java,821.5,505.72 -InnerQueuedObserver.java,115.4,502.33 -InnerQueuedObserverSupport.java,0.7,488.64 -InnerQueuedSubscriber.java,130.2,504.25 -InnerQueuedSubscriberSupport.java,0.6,488.74 -InnerQueuedSubscriberTest.java,517.5,501.43 -InputWithIncrementingInteger.java,42.6,493.22 -InstantPeriodicTask.java,440.1,503.58 -InstantPeriodicTaskTest.java,1584.4,498.39 -IntFunction.java,0.3,489.34 -InternalWrongNaming.java,java.lang.OutOfMemoryError,OOM -IntervalRangeTckTest.java,7.5,495.53 -IntervalTckTest.java,5.3,494.54 -IoScheduler.java,1129.3,502.09 -IsEmptyTckTest.java,4.6,493.68 -JavadocFindUnescapedAngleBrackets.java,java.lang.OutOfMemoryError,OOM -JavadocForAnnotations.java,java.lang.OutOfMemoryError,OOM -JavadocWording.java,java.lang.OutOfMemoryError,OOM -JustAsyncPerf.java,401.6,500.55 -JustTckTest.java,2.7,492.41 -LambdaConsumerIntrospection.java,0.1,490.41 -LambdaObserver.java,388.2,505.49 -LambdaObserverTest.java,java.lang.OutOfMemoryError,OOM -LambdaSubscriber.java,297.4,502.04 -LambdaSubscriberTest.java,java.lang.OutOfMemoryError,OOM -LastTckTest.java,4.7,494.58 -LatchedSingleObserver.java,25.6,501.77 -LimitTckTest.java,10.2,501.58 -LinkedArrayList.java,23.3,503.84 -ListAddBiConsumer.java,7.5,498.13 -ListCompositeDisposable.java,java.lang.OutOfMemoryError,OOM -ListCompositeDisposableTest.java,3204.7,502.58 -LongConsumer.java,0.0,490.78 -MapTckTest.java,14.9,500.7 -Maybe.java,java.lang.OutOfMemoryError,OOM -MaybeAmb.java,893.7,501.48 -MaybeAmbTest.java,6298.5,500.85 -MaybeCache.java,java.lang.OutOfMemoryError,OOM -MaybeCacheTest.java,java.lang.OutOfMemoryError,OOM -MaybeCallbackObserver.java,389.8,504.03 -MaybeCallbackObserverTest.java,2052.3,499.4 -MaybeConcatArray.java,384.5,502.04 -MaybeConcatArrayDelayError.java,java.lang.OutOfMemoryError,OOM -MaybeConcatArrayTest.java,java.lang.OutOfMemoryError,OOM -MaybeConcatIterable.java,1165.4,503.41 -MaybeConcatIterableTest.java,java.lang.OutOfMemoryError,OOM -MaybeConcatPublisherTest.java,1752.7,504.85 -MaybeContains.java,826.8,499.05 -MaybeContainsTest.java,java.lang.OutOfMemoryError,OOM -MaybeConverter.java,0.5,492.22 -MaybeCount.java,270.2,501.3 -MaybeCountTest.java,2430.5,508.8 -MaybeCreate.java,java.lang.OutOfMemoryError,OOM -MaybeCreateTest.java,java.lang.OutOfMemoryError,OOM -MaybeDefer.java,334.0,501.33 -MaybeDelay.java,1156.1,497.69 -MaybeDelayOtherPublisher.java,1243.0,503.53 -MaybeDelayOtherTest.java,java.lang.OutOfMemoryError,OOM -MaybeDelaySubscriptionOtherPublisher.java,1025.0,500.7 -MaybeDelaySubscriptionTest.java,java.lang.OutOfMemoryError,OOM -MaybeDelayTest.java,3088.6,496.83 -MaybeDelayWithCompletable.java,1090.6,500.54 -MaybeDetach.java,433.5,500.59 -MaybeDetachTest.java,5198.5,501 -MaybeDoAfterSuccess.java,681.7,500.6 -MaybeDoAfterSuccessTest.java,2856.7,509.37 -MaybeDoFinally.java,618.8,500.5 -MaybeDoFinallyTest.java,java.lang.OutOfMemoryError,OOM -MaybeDoOnEvent.java,1093.0,500.88 -MaybeDoOnEventTest.java,java.lang.OutOfMemoryError,OOM -MaybeEmitter.java,0.5,493.14 -MaybeEmpty.java,6.0,499.14 -MaybeEmptyTest.java,4.5,498.64 -MaybeEqualSingle.java,1864.2,503.47 -MaybeEqualTest.java,java.lang.OutOfMemoryError,OOM -MaybeError.java,556.5,498.25 -MaybeErrorCallable.java,747.1,503.3 -MaybeErrorTest.java,207.7,503.71 -MaybeFilter.java,502.5,499.45 -MaybeFilterSingle.java,459.6,502 -MaybeFilterSingleTest.java,java.lang.OutOfMemoryError,OOM -MaybeFlatMapBiSelector.java,java.lang.OutOfMemoryError,OOM -MaybeFlatMapBiSelectorTest.java,java.lang.OutOfMemoryError,OOM -MaybeFlatMapCompletable.java,630.5,504.64 -MaybeFlatMapCompletableTest.java,java.lang.OutOfMemoryError,OOM -MaybeFlatMapIterableFlowable.java,2081.2,507.38 -MaybeFlatMapIterableFlowableTest.java,java.lang.OutOfMemoryError,OOM -MaybeFlatMapIterableObservable.java,1067.9,504.8 -MaybeFlatMapIterableObservableTest.java,java.lang.OutOfMemoryError,OOM -MaybeFlatMapNotification.java,2868.8,504.12 -MaybeFlatMapNotificationTest.java,java.lang.OutOfMemoryError,OOM -MaybeFlatMapObservable.java,726.4,504.7 -MaybeFlatMapObservableTest.java,java.lang.OutOfMemoryError,OOM -MaybeFlatMapPublisher.java,1508.0,502.71 -MaybeFlatMapPublisherTckTest.java,59.2,503.93 -MaybeFlatMapPublisherTest.java,java.lang.OutOfMemoryError,OOM -MaybeFlatMapSingle.java,2357.7,503.86 -MaybeFlatMapSingleElement.java,2054.7,502.36 -MaybeFlatMapSingleElementTest.java,java.lang.OutOfMemoryError,OOM -MaybeFlatMapSingleTest.java,java.lang.OutOfMemoryError,OOM -MaybeFlatten.java,1834.7,504.65 -MaybeFlattenTest.java,java.lang.OutOfMemoryError,OOM -MaybeFromAction.java,java.lang.OutOfMemoryError,OOM -MaybeFromActionTest.java,4571.2,503.05 -MaybeFromCallable.java,723.0,502.1 -MaybeFromCallableTest.java,java.lang.OutOfMemoryError,OOM -MaybeFromCompletable.java,532.8,504.11 -MaybeFromCompletableTest.java,java.lang.OutOfMemoryError,OOM -MaybeFromFuture.java,java.lang.OutOfMemoryError,OOM -MaybeFromFutureTest.java,312.5,502.47 -MaybeFromRunnable.java,207.2,505.3 -MaybeFromRunnableTest.java,java.lang.OutOfMemoryError,OOM -MaybeFromSingle.java,462.9,504.66 -MaybeFromSingleTest.java,java.lang.OutOfMemoryError,OOM -MaybeHide.java,365.0,502.06 -MaybeHideTest.java,java.lang.OutOfMemoryError,OOM -MaybeIgnoreElement.java,571.5,502.99 -MaybeIgnoreElementCompletable.java,657.9,503.58 -MaybeIgnoreElementTest.java,java.lang.OutOfMemoryError,OOM -MaybeIsEmpty.java,599.9,503.81 -MaybeIsEmptySingle.java,536.2,503.27 -MaybeIsEmptySingleTest.java,42.2,500.57 -MaybeIsEmptyTest.java,java.lang.OutOfMemoryError,OOM -MaybeJust.java,580.4,501.52 -MaybeJustTest.java,4.0,500.57 -MaybeLift.java,535.7,505.42 -MaybeMap.java,1350.0,502.98 -MaybeMapTest.java,java.lang.OutOfMemoryError,OOM -MaybeMergeArray.java,java.lang.OutOfMemoryError,OOM -MaybeMergeArrayTest.java,java.lang.OutOfMemoryError,OOM -MaybeMergeTest.java,java.lang.OutOfMemoryError,OOM -MaybeMergeWithTest.java,9.6,500.28 -MaybeNever.java,6.5,503.32 -MaybeNo2Dot0Since.java,java.lang.OutOfMemoryError,OOM -MaybeObserveOn.java,4687.9,503.51 -MaybeObserver.java,0.3,496.98 -MaybeOfTypeTest.java,java.lang.OutOfMemoryError,OOM -MaybeOnErrorComplete.java,1580.5,505.15 -MaybeOnErrorNext.java,2932.3,503.7 -MaybeOnErrorReturn.java,1647.2,504.9 -MaybeOnErrorXTest.java,java.lang.OutOfMemoryError,OOM -MaybeOnSubscribe.java,0.0,496.98 -MaybeOperator.java,0.7,496.98 -MaybePeek.java,2243.6,503.93 -MaybePeekTest.java,java.lang.OutOfMemoryError,OOM -MaybeRetryTest.java,java.lang.OutOfMemoryError,OOM -MaybeSource.java,0.6,497.11 -MaybeSubject.java,2070.9,504.63 -MaybeSubjectTest.java,java.lang.OutOfMemoryError,OOM -MaybeSubscribeOn.java,3306.6,502.54 -MaybeSubscribeOnTest.java,java.lang.OutOfMemoryError,OOM -MaybeSwitchIfEmpty.java,3044.1,501.62 -MaybeSwitchIfEmptySingle.java,2753.8,501.61 -MaybeSwitchIfEmptySingleTest.java,java.lang.OutOfMemoryError,OOM -MaybeSwitchIfEmptyTest.java,java.lang.OutOfMemoryError,OOM -MaybeTakeUntilMaybe.java,1926.8,502.05 -MaybeTakeUntilPublisher.java,2674.5,502.99 -MaybeTakeUntilPublisherTest.java,java.lang.OutOfMemoryError,OOM -MaybeTakeUntilTest.java,java.lang.OutOfMemoryError,OOM -MaybeTest.java,java.lang.OutOfMemoryError,OOM -MaybeTimeoutMaybe.java,4328.2,504.42 -MaybeTimeoutPublisher.java,3180.6,502.28 -MaybeTimeoutPublisherTest.java,java.lang.OutOfMemoryError,OOM -MaybeTimeoutTest.java,java.lang.OutOfMemoryError,OOM -MaybeTimer.java,2371.5,503.56 -MaybeTimerTest.java,java.lang.OutOfMemoryError,OOM -MaybeToCompletableTest.java,java.lang.OutOfMemoryError,OOM -MaybeToFlowable.java,1121.1,505.43 -MaybeToFlowableTest.java,java.lang.OutOfMemoryError,OOM -MaybeToObservable.java,796.8,505.87 -MaybeToObservableTest.java,java.lang.OutOfMemoryError,OOM -MaybeToPublisher.java,2.2,499.75 -MaybeToSingle.java,2002.0,504.33 -MaybeToSingleTest.java,java.lang.OutOfMemoryError,OOM -MaybeTransformer.java,0.3,497.78 -MaybeUnsafeCreate.java,9.5,504.23 -MaybeUnsubscribeOn.java,1994.8,503.59 -MaybeUnsubscribeOnTest.java,java.lang.OutOfMemoryError,OOM -MaybeUsing.java,12051.8,504.6 -MaybeUsingTest.java,java.lang.OutOfMemoryError,OOM -MaybeZipArray.java,7442.2,503.45 -MaybeZipArrayTest.java,java.lang.OutOfMemoryError,OOM -MaybeZipIterable.java,java.lang.OutOfMemoryError,OOM -MaybeZipIterableTest.java,java.lang.OutOfMemoryError,OOM -MemoryPerf.java,java.lang.OutOfMemoryError,OOM -MergeIterableTckTest.java,java.lang.OutOfMemoryError,OOM -MergePublisherTckTest.java,java.lang.OutOfMemoryError,OOM -MergeTckTest.java,java.lang.OutOfMemoryError,OOM -MergeWithCompletableTckTest.java,7.3,500.36 -MergeWithMaybeEmptyTckTest.java,7.3,500.34 -MergeWithMaybeTckTest.java,62.7,500.66 -MergeWithSingleTckTest.java,106.1,503.25 -MergerBiFunction.java,java.lang.OutOfMemoryError,OOM -MergerBiFunctionTest.java,java.lang.OutOfMemoryError,OOM -MiscUtilTest.java,java.lang.OutOfMemoryError,OOM -MissingBackpressureException.java,0.0,499.24 -MpscLinkedQueue.java,java.lang.OutOfMemoryError,OOM -MulticastProcessor.java,java.lang.OutOfMemoryError,OOM -MulticastProcessorAsPublisherTckTest.java,java.lang.OutOfMemoryError,OOM -MulticastProcessorRefCountedTckTest.java,734.3,505.04 -MulticastProcessorTckTest.java,789.2,505 -MulticastProcessorTest.java,java.lang.OutOfMemoryError,OOM -NewLinesBeforeAnnotation.java,java.lang.OutOfMemoryError,OOM -NewThreadScheduler.java,java.lang.OutOfMemoryError,OOM -NewThreadSchedulerTest.java,4349.2,509.11 -NewThreadWorker.java,java.lang.OutOfMemoryError,OOM -NoAnonymousInnerClassesTest.java,java.lang.OutOfMemoryError,OOM -NonBlockingThread.java,0.1,499.83 -NonNull.java,1.2,501.7 -Notification.java,java.lang.OutOfMemoryError,OOM -NotificationLite.java,java.lang.OutOfMemoryError,OOM -NotificationLiteTest.java,2354.0,504.71 -NotificationTest.java,1383.9,504.53 -Nullable.java,0.1,500.37 -ObjectHelper.java,java.lang.OutOfMemoryError,OOM -ObjectHelperTest.java,2571.2,505.49 -Observable.java,java.lang.OutOfMemoryError,OOM -ObservableAll.java,3710.7,504.57 -ObservableAllSingle.java,3366.2,505.51 -ObservableAllTest.java,java.lang.OutOfMemoryError,OOM -ObservableAmb.java,11890.3,504.02 -ObservableAmbTest.java,java.lang.OutOfMemoryError,OOM -ObservableAny.java,6825.9,505.11 -ObservableAnySingle.java,6485.8,502.34 -ObservableAnyTest.java,java.lang.OutOfMemoryError,OOM -ObservableAutoConnect.java,758.3,504.16 -ObservableAutoConnectTest.java,15.9,501.76 -ObservableBlockingSubscribe.java,5538.6,502.67 -ObservableBlockingTest.java,java.lang.OutOfMemoryError,OOM -ObservableBuffer.java,17041.9,505.17 -ObservableBufferBoundary.java,34160.5,504.92 -ObservableBufferBoundarySupplier.java,java.lang.OutOfMemoryError,OOM -ObservableBufferExactBoundary.java,java.lang.OutOfMemoryError,OOM -ObservableBufferTest.java,java.lang.OutOfMemoryError,OOM -ObservableBufferTimed.java,java.lang.OutOfMemoryError,OOM -ObservableBufferUntilSubscriberTest.java,java.lang.OutOfMemoryError,OOM -ObservableCache.java,11909.6,504.41 -ObservableCacheTest.java,java.lang.OutOfMemoryError,OOM -ObservableCastTest.java,2397.4,504.26 -ObservableCollect.java,6875.6,508.02 -ObservableCollectSingle.java,5169.1,508.11 -ObservableCollectTest.java,java.lang.OutOfMemoryError,OOM -ObservableCombineLatest.java,java.lang.OutOfMemoryError,OOM -ObservableCombineLatestTest.java,java.lang.OutOfMemoryError,OOM -ObservableCombineLatestTests.java,java.lang.OutOfMemoryError,OOM -ObservableConcatMap.java,java.lang.OutOfMemoryError,OOM -ObservableConcatMapCompletable.java,java.lang.OutOfMemoryError,OOM -ObservableConcatMapCompletablePerf.java,java.lang.OutOfMemoryError,OOM -ObservableConcatMapCompletableTest.java,java.lang.OutOfMemoryError,OOM -ObservableConcatMapEager.java,java.lang.OutOfMemoryError,OOM -ObservableConcatMapEagerTest.java,java.lang.OutOfMemoryError,OOM -ObservableConcatMapMaybe.java,8121.5,507.8 -ObservableConcatMapMaybeEmptyPerf.java,java.lang.OutOfMemoryError,OOM -ObservableConcatMapMaybePerf.java,java.lang.OutOfMemoryError,OOM -ObservableConcatMapMaybeTest.java,java.lang.OutOfMemoryError,OOM -ObservableConcatMapSingle.java,14625.1,510.07 -ObservableConcatMapSinglePerf.java,java.lang.OutOfMemoryError,OOM -ObservableConcatMapSingleTest.java,java.lang.OutOfMemoryError,OOM -ObservableConcatMapTest.java,java.lang.OutOfMemoryError,OOM -ObservableConcatTest.java,java.lang.OutOfMemoryError,OOM -ObservableConcatTests.java,java.lang.OutOfMemoryError,OOM -ObservableConcatWithCompletable.java,5323.7,508.32 -ObservableConcatWithCompletableTest.java,java.lang.OutOfMemoryError,OOM -ObservableConcatWithMaybe.java,6341.0,505.91 -ObservableConcatWithMaybeTest.java,java.lang.OutOfMemoryError,OOM -ObservableConcatWithSingle.java,3299.8,506.54 -ObservableConcatWithSingleTest.java,java.lang.OutOfMemoryError,OOM -ObservableConverter.java,0.5,501.93 -ObservableCount.java,2857.5,507.02 -ObservableCountSingle.java,1212.4,509.47 -ObservableCountTest.java,java.lang.OutOfMemoryError,OOM -ObservableCovarianceTest.java,java.lang.OutOfMemoryError,OOM -ObservableCreate.java,java.lang.OutOfMemoryError,OOM -ObservableCreateTest.java,java.lang.OutOfMemoryError,OOM -ObservableDebounce.java,java.lang.OutOfMemoryError,OOM -ObservableDebounceTest.java,java.lang.OutOfMemoryError,OOM -ObservableDebounceTimed.java,java.lang.OutOfMemoryError,OOM -ObservableDefaultIfEmptyTest.java,java.lang.OutOfMemoryError,OOM -ObservableDefer.java,1694.1,505.92 -ObservableDeferTest.java,1006.8,507.74 -ObservableDelay.java,java.lang.OutOfMemoryError,OOM -ObservableDelaySubscriptionOther.java,2760.9,509.36 -ObservableDelaySubscriptionOtherTest.java,java.lang.OutOfMemoryError,OOM -ObservableDelayTest.java,java.lang.OutOfMemoryError,OOM -ObservableDematerialize.java,java.lang.OutOfMemoryError,OOM -ObservableDematerializeTest.java,java.lang.OutOfMemoryError,OOM -ObservableDetach.java,1830.1,509.98 -ObservableDetachTest.java,java.lang.OutOfMemoryError,OOM -ObservableDistinct.java,java.lang.OutOfMemoryError,OOM -ObservableDistinctTest.java,java.lang.OutOfMemoryError,OOM -ObservableDistinctUntilChanged.java,java.lang.OutOfMemoryError,OOM -ObservableDistinctUntilChangedTest.java,java.lang.OutOfMemoryError,OOM -ObservableDoAfterNext.java,1865.3,507.71 -ObservableDoAfterNextTest.java,3664.9,508.51 -ObservableDoFinally.java,2005.9,508.9 -ObservableDoFinallyTest.java,java.lang.OutOfMemoryError,OOM -ObservableDoOnEach.java,9242.6,506.86 -ObservableDoOnEachTest.java,java.lang.OutOfMemoryError,OOM -ObservableDoOnLifecycle.java,711.2,510.01 -ObservableDoOnSubscribeTest.java,java.lang.OutOfMemoryError,OOM -ObservableDoOnTest.java,10075.0,503.58 -ObservableDoOnUnsubscribeTest.java,2907752.8,504.36 -ObservableElementAt.java,4739.5,507.69 -ObservableElementAtMaybe.java,3078.6,508.16 -ObservableElementAtSingle.java,2935.7,510.73 -ObservableElementAtTest.java,java.lang.OutOfMemoryError,OOM -ObservableEmitter.java,0.6,502.48 -ObservableEmpty.java,487.8,506.65 -ObservableError.java,2049.6,509.3 -ObservableErrorHandlingTests.java,3350.6,508.6 -ObservableEventStream.java,3847.6,509.41 -ObservableFilter.java,1231.2,509.15 -ObservableFilterTest.java,java.lang.OutOfMemoryError,OOM -ObservableFinallyTest.java,1452.5,506.33 -ObservableFirstTest.java,38280.5,505.9 -ObservableFlatMap.java,java.lang.OutOfMemoryError,OOM -ObservableFlatMapCompletable.java,6862.6,507.61 -ObservableFlatMapCompletableCompletable.java,5126.0,507.73 -ObservableFlatMapCompletablePerf.java,java.lang.OutOfMemoryError,OOM -ObservableFlatMapCompletableTest.java,java.lang.OutOfMemoryError,OOM -ObservableFlatMapMaybe.java,java.lang.OutOfMemoryError,OOM -ObservableFlatMapMaybeEmptyPerf.java,java.lang.OutOfMemoryError,OOM -ObservableFlatMapMaybePerf.java,java.lang.OutOfMemoryError,OOM -ObservableFlatMapMaybeTest.java,java.lang.OutOfMemoryError,OOM -ObservableFlatMapPerf.java,3230.2,510.81 -ObservableFlatMapSingle.java,7193.6,508.82 -ObservableFlatMapSinglePerf.java,java.lang.OutOfMemoryError,OOM -ObservableFlatMapSingleTest.java,java.lang.OutOfMemoryError,OOM -ObservableFlatMapTest.java,java.lang.OutOfMemoryError,OOM -ObservableFlattenIterable.java,java.lang.OutOfMemoryError,OOM -ObservableFlattenIterableTest.java,java.lang.OutOfMemoryError,OOM -ObservableForEachTest.java,java.lang.OutOfMemoryError,OOM -ObservableFromArray.java,java.lang.OutOfMemoryError,OOM -ObservableFromCallable.java,4230.9,504.35 -ObservableFromCallableTest.java,java.lang.OutOfMemoryError,OOM -ObservableFromFuture.java,java.lang.OutOfMemoryError,OOM -ObservableFromIterable.java,10272.0,505.31 -ObservableFromIterableTest.java,java.lang.OutOfMemoryError,OOM -ObservableFromPublisher.java,1758.4,510.18 -ObservableFromTest.java,java.lang.OutOfMemoryError,OOM -ObservableFromUnsafeSource.java,533.2,506.63 -ObservableFuseableTest.java,5058.6,505.22 -ObservableGenerate.java,2440.3,508.01 -ObservableGenerateTest.java,java.lang.OutOfMemoryError,OOM -ObservableGroupBy.java,java.lang.OutOfMemoryError,OOM -ObservableGroupByTest.java,java.lang.OutOfMemoryError,OOM -ObservableGroupByTests.java,java.lang.OutOfMemoryError,OOM -ObservableGroupJoin.java,java.lang.OutOfMemoryError,OOM -ObservableGroupJoinTest.java,java.lang.OutOfMemoryError,OOM -ObservableHide.java,1757.8,507.34 -ObservableHideTest.java,java.lang.OutOfMemoryError,OOM -ObservableIgnoreElements.java,1209.4,510.04 -ObservableIgnoreElementsCompletable.java,1329.7,509.96 -ObservableIgnoreElementsTest.java,java.lang.OutOfMemoryError,OOM -ObservableInternalHelper.java,java.lang.OutOfMemoryError,OOM -ObservableInternalHelperTest.java,543.5,509.62 -ObservableInterval.java,1858.9,510.76 -ObservableIntervalRange.java,2015.5,510.79 -ObservableIntervalRangeTest.java,java.lang.OutOfMemoryError,OOM -ObservableIntervalTest.java,java.lang.OutOfMemoryError,OOM -ObservableJoin.java,java.lang.OutOfMemoryError,OOM -ObservableJoinTest.java,java.lang.OutOfMemoryError,OOM -ObservableJust.java,223.8,507.26 -ObservableLastMaybe.java,1279.7,508.25 -ObservableLastSingle.java,java.lang.OutOfMemoryError,OOM -ObservableLastTest.java,java.lang.OutOfMemoryError,OOM -ObservableLift.java,1452.4,508.51 -ObservableLiftTest.java,10.0,509.29 -ObservableMap.java,java.lang.OutOfMemoryError,OOM -ObservableMapNotification.java,java.lang.OutOfMemoryError,OOM -ObservableMapNotificationTest.java,java.lang.OutOfMemoryError,OOM -ObservableMapTest.java,java.lang.OutOfMemoryError,OOM -ObservableMaterialize.java,java.lang.OutOfMemoryError,OOM -ObservableMaterializeTest.java,java.lang.OutOfMemoryError,OOM -ObservableMergeDelayErrorTest.java,java.lang.OutOfMemoryError,OOM -ObservableMergeMaxConcurrentTest.java,java.lang.OutOfMemoryError,OOM -ObservableMergeTest.java,java.lang.OutOfMemoryError,OOM -ObservableMergeTests.java,java.lang.OutOfMemoryError,OOM -ObservableMergeWithCompletable.java,5270.8,508.94 -ObservableMergeWithCompletableTest.java,java.lang.OutOfMemoryError,OOM -ObservableMergeWithMaybe.java,java.lang.OutOfMemoryError,OOM -ObservableMergeWithMaybeTest.java,java.lang.OutOfMemoryError,OOM -ObservableMergeWithSingle.java,java.lang.OutOfMemoryError,OOM -ObservableMergeWithSingleTest.java,java.lang.OutOfMemoryError,OOM -ObservableMulticastTest.java,0.0,504.03 -ObservableNever.java,392.1,507.54 -ObservableNullTests.java,java.lang.OutOfMemoryError,OOM -ObservableObserveOn.java,java.lang.OutOfMemoryError,OOM -ObservableObserveOnTest.java,java.lang.OutOfMemoryError,OOM -ObservableOnErrorNext.java,java.lang.OutOfMemoryError,OOM -ObservableOnErrorResumeNextViaFunctionTest.java,java.lang.OutOfMemoryError,OOM -ObservableOnErrorResumeNextViaObservableTest.java,java.lang.OutOfMemoryError,OOM -ObservableOnErrorReturn.java,java.lang.OutOfMemoryError,OOM -ObservableOnErrorReturnTest.java,java.lang.OutOfMemoryError,OOM -ObservableOnExceptionResumeNextViaObservableTest.java,java.lang.OutOfMemoryError,OOM -ObservableOnSubscribe.java,0.2,504.3 -ObservableOperator.java,0.5,504.3 -ObservablePublish.java,java.lang.OutOfMemoryError,OOM -ObservablePublishSelector.java,java.lang.OutOfMemoryError,OOM -ObservablePublishTest.java,java.lang.OutOfMemoryError,OOM -ObservableQueueDrain.java,0.5,504.33 -ObservableRange.java,java.lang.OutOfMemoryError,OOM -ObservableRangeLong.java,775.6,509.91 -ObservableRangeLongTest.java,java.lang.OutOfMemoryError,OOM -ObservableRangeTest.java,java.lang.OutOfMemoryError,OOM -ObservableRedoTest.java,java.lang.OutOfMemoryError,OOM -ObservableReduceMaybe.java,java.lang.OutOfMemoryError,OOM -ObservableReduceSeedSingle.java,java.lang.OutOfMemoryError,OOM -ObservableReduceTest.java,java.lang.OutOfMemoryError,OOM -ObservableReduceTests.java,java.lang.OutOfMemoryError,OOM -ObservableReduceWithSingle.java,java.lang.OutOfMemoryError,OOM -ObservableRefCount.java,java.lang.OutOfMemoryError,OOM -ObservableRefCountTest.java,java.lang.OutOfMemoryError,OOM -ObservableRepeat.java,1454.0,508.3 -ObservableRepeatTest.java,java.lang.OutOfMemoryError,OOM -ObservableRepeatUntil.java,1642.5,510.16 -ObservableRepeatWhen.java,java.lang.OutOfMemoryError,OOM -ObservableReplay.java,java.lang.OutOfMemoryError,OOM -ObservableReplayTest.java,java.lang.OutOfMemoryError,OOM -ObservableResourceWrapperTest.java,2373.5,508.84 -ObservableRetryBiPredicate.java,java.lang.OutOfMemoryError,OOM -ObservableRetryPredicate.java,java.lang.OutOfMemoryError,OOM -ObservableRetryTest.java,java.lang.OutOfMemoryError,OOM -ObservableRetryWhen.java,java.lang.OutOfMemoryError,OOM -ObservableRetryWithPredicateTest.java,java.lang.OutOfMemoryError,OOM -ObservableSampleTest.java,java.lang.OutOfMemoryError,OOM -ObservableSampleTimed.java,java.lang.OutOfMemoryError,OOM -ObservableSampleWithObservable.java,java.lang.OutOfMemoryError,OOM -ObservableScalarXMap.java,java.lang.OutOfMemoryError,OOM -ObservableScalarXMapTest.java,java.lang.OutOfMemoryError,OOM -ObservableScan.java,java.lang.OutOfMemoryError,OOM -ObservableScanSeed.java,java.lang.OutOfMemoryError,OOM -ObservableScanTest.java,java.lang.OutOfMemoryError,OOM -ObservableScanTests.java,java.lang.OutOfMemoryError,OOM -ObservableSequenceEqual.java,java.lang.OutOfMemoryError,OOM -ObservableSequenceEqualSingle.java,java.lang.OutOfMemoryError,OOM -ObservableSequenceEqualTest.java,java.lang.OutOfMemoryError,OOM -ObservableSerializeTest.java,java.lang.OutOfMemoryError,OOM -ObservableSerialized.java,java.lang.OutOfMemoryError,OOM -ObservableSingleMaybe.java,java.lang.OutOfMemoryError,OOM -ObservableSingleSingle.java,java.lang.OutOfMemoryError,OOM -ObservableSingleTest.java,java.lang.OutOfMemoryError,OOM -ObservableSkip.java,java.lang.OutOfMemoryError,OOM -ObservableSkipLast.java,java.lang.OutOfMemoryError,OOM -ObservableSkipLastTest.java,java.lang.OutOfMemoryError,OOM -ObservableSkipLastTimed.java,java.lang.OutOfMemoryError,OOM -ObservableSkipLastTimedTest.java,java.lang.OutOfMemoryError,OOM -ObservableSkipTest.java,java.lang.OutOfMemoryError,OOM -ObservableSkipTimedTest.java,java.lang.OutOfMemoryError,OOM -ObservableSkipUntil.java,java.lang.OutOfMemoryError,OOM -ObservableSkipUntilTest.java,java.lang.OutOfMemoryError,OOM -ObservableSkipWhile.java,java.lang.OutOfMemoryError,OOM -ObservableSkipWhileTest.java,java.lang.OutOfMemoryError,OOM -ObservableSource.java,0.3,505.48 -ObservableStartWithTests.java,1995.5,510.35 -ObservableSubscribeOn.java,java.lang.OutOfMemoryError,OOM -ObservableSubscribeOnTest.java,java.lang.OutOfMemoryError,OOM -ObservableSubscriberTest.java,java.lang.OutOfMemoryError,OOM -ObservableSwitchIfEmpty.java,1978.2,508.18 -ObservableSwitchIfEmptyTest.java,java.lang.OutOfMemoryError,OOM -ObservableSwitchMap.java,java.lang.OutOfMemoryError,OOM -ObservableSwitchMapCompletable.java,java.lang.OutOfMemoryError,OOM -ObservableSwitchMapCompletablePerf.java,java.lang.OutOfMemoryError,OOM -ObservableSwitchMapCompletableTest.java,java.lang.OutOfMemoryError,OOM -ObservableSwitchMapMaybe.java,java.lang.OutOfMemoryError,OOM -ObservableSwitchMapMaybeEmptyPerf.java,java.lang.OutOfMemoryError,OOM -ObservableSwitchMapMaybePerf.java,java.lang.OutOfMemoryError,OOM -ObservableSwitchMapMaybeTest.java,java.lang.OutOfMemoryError,OOM -ObservableSwitchMapSingle.java,java.lang.OutOfMemoryError,OOM -ObservableSwitchMapSinglePerf.java,java.lang.OutOfMemoryError,OOM -ObservableSwitchMapSingleTest.java,java.lang.OutOfMemoryError,OOM -ObservableSwitchTest.java,java.lang.OutOfMemoryError,OOM -ObservableTake.java,java.lang.OutOfMemoryError,OOM -ObservableTakeLast.java,java.lang.OutOfMemoryError,OOM -ObservableTakeLastOne.java,java.lang.OutOfMemoryError,OOM -ObservableTakeLastOneTest.java,java.lang.OutOfMemoryError,OOM -ObservableTakeLastTest.java,java.lang.OutOfMemoryError,OOM -ObservableTakeLastTimed.java,java.lang.OutOfMemoryError,OOM -ObservableTakeLastTimedTest.java,java.lang.OutOfMemoryError,OOM -ObservableTakeTest.java,java.lang.OutOfMemoryError,OOM -ObservableTakeTimedTest.java,java.lang.OutOfMemoryError,OOM -ObservableTakeUntil.java,java.lang.OutOfMemoryError,OOM -ObservableTakeUntilPredicate.java,java.lang.OutOfMemoryError,OOM -ObservableTakeUntilPredicateTest.java,java.lang.OutOfMemoryError,OOM -ObservableTakeUntilTest.java,java.lang.OutOfMemoryError,OOM -ObservableTakeWhile.java,java.lang.OutOfMemoryError,OOM -ObservableTakeWhileTest.java,java.lang.OutOfMemoryError,OOM -ObservableTest.java,java.lang.OutOfMemoryError,OOM -ObservableThrottleFirstTest.java,java.lang.OutOfMemoryError,OOM -ObservableThrottleFirstTimed.java,java.lang.OutOfMemoryError,OOM -ObservableThrottleLastTests.java,8176.0,508.7 -ObservableThrottleLatest.java,java.lang.OutOfMemoryError,OOM -ObservableThrottleLatestTest.java,java.lang.OutOfMemoryError,OOM -ObservableThrottleWithTimeoutTests.java,8403.4,509.5 -ObservableTimeInterval.java,java.lang.OutOfMemoryError,OOM -ObservableTimeIntervalTest.java,java.lang.OutOfMemoryError,OOM -ObservableTimeout.java,java.lang.OutOfMemoryError,OOM -ObservableTimeoutTests.java,java.lang.OutOfMemoryError,OOM -ObservableTimeoutTimed.java,java.lang.OutOfMemoryError,OOM -ObservableTimeoutWithSelectorTest.java,java.lang.OutOfMemoryError,OOM -ObservableTimer.java,2684.9,510.18 -ObservableTimerTest.java,java.lang.OutOfMemoryError,OOM -ObservableTimestampTest.java,java.lang.OutOfMemoryError,OOM -ObservableToFlowabeTestSync.java,java.lang.OutOfMemoryError,OOM -ObservableToFutureTest.java,java.lang.OutOfMemoryError,OOM -ObservableToList.java,java.lang.OutOfMemoryError,OOM -ObservableToListSingle.java,java.lang.OutOfMemoryError,OOM -ObservableToListTest.java,java.lang.OutOfMemoryError,OOM -ObservableToMapTest.java,java.lang.OutOfMemoryError,OOM -ObservableToMultimapTest.java,java.lang.OutOfMemoryError,OOM -ObservableToSortedListTest.java,java.lang.OutOfMemoryError,OOM -ObservableToXTest.java,3783.3,510.68 -ObservableTransformer.java,0.3,506.26 -ObservableUnsubscribeOn.java,java.lang.OutOfMemoryError,OOM -ObservableUnsubscribeOnTest.java,java.lang.OutOfMemoryError,OOM -ObservableUsing.java,java.lang.OutOfMemoryError,OOM -ObservableUsingTest.java,java.lang.OutOfMemoryError,OOM -ObservableWindow.java,java.lang.OutOfMemoryError,OOM -ObservableWindowBoundary.java,java.lang.OutOfMemoryError,OOM -ObservableWindowBoundarySelector.java,java.lang.OutOfMemoryError,OOM -ObservableWindowBoundarySupplier.java,java.lang.OutOfMemoryError,OOM -ObservableWindowTests.java,java.lang.OutOfMemoryError,OOM -ObservableWindowTimed.java,java.lang.OutOfMemoryError,OOM -ObservableWindowWithObservableTest.java,java.lang.OutOfMemoryError,OOM -ObservableWindowWithSizeTest.java,java.lang.OutOfMemoryError,OOM -ObservableWindowWithStartEndObservableTest.java,java.lang.OutOfMemoryError,OOM -ObservableWindowWithTimeTest.java,java.lang.OutOfMemoryError,OOM -ObservableWithLatestFrom.java,java.lang.OutOfMemoryError,OOM -ObservableWithLatestFromMany.java,java.lang.OutOfMemoryError,OOM -ObservableWithLatestFromTest.java,java.lang.OutOfMemoryError,OOM -ObservableZip.java,java.lang.OutOfMemoryError,OOM -ObservableZipCompletionTest.java,java.lang.OutOfMemoryError,OOM -ObservableZipIterable.java,java.lang.OutOfMemoryError,OOM -ObservableZipIterableTest.java,java.lang.OutOfMemoryError,OOM -ObservableZipTest.java,java.lang.OutOfMemoryError,OOM -ObservableZipTests.java,java.lang.OutOfMemoryError,OOM -ObserveOnTckTest.java,java.lang.OutOfMemoryError,OOM -Observer.java,0.4,506.79 -ObserverFusion.java,java.lang.OutOfMemoryError,OOM -ObserverResourceWrapper.java,java.lang.OutOfMemoryError,OOM -OnBackpressureBufferTckTest.java,java.lang.OutOfMemoryError,OOM -OnErrorNotImplementedException.java,java.lang.OutOfMemoryError,OOM -OnErrorNotImplementedExceptionTest.java,java.lang.OutOfMemoryError,OOM -OnErrorResumeNextTckTest.java,java.lang.OutOfMemoryError,OOM -OnErrorReturnItemTckTest.java,java.lang.OutOfMemoryError,OOM -OnNextValueTest.java,java.lang.OutOfMemoryError,OOM -OpenHashSet.java,java.lang.OutOfMemoryError,OOM -OpenHashSetTest.java,561.1,510.1 -OperatorFlatMapPerf.java,java.lang.OutOfMemoryError,OOM -OperatorMergePerf.java,java.lang.OutOfMemoryError,OOM -OperatorsAreFinal.java,java.lang.OutOfMemoryError,OOM -ParallelCollect.java,java.lang.OutOfMemoryError,OOM -ParallelCollectTest.java,java.lang.OutOfMemoryError,OOM -ParallelConcatMap.java,java.lang.OutOfMemoryError,OOM -ParallelDoOnNextTry.java,java.lang.OutOfMemoryError,OOM -ParallelDoOnNextTryTest.java,java.lang.OutOfMemoryError,OOM -ParallelFailureHandling.java,1.0,510.34 -ParallelFilter.java,java.lang.OutOfMemoryError,OOM -ParallelFilterTest.java,java.lang.OutOfMemoryError,OOM -ParallelFilterTry.java,java.lang.OutOfMemoryError,OOM -ParallelFilterTryTest.java,java.lang.OutOfMemoryError,OOM -ParallelFlatMap.java,java.lang.OutOfMemoryError,OOM -ParallelFlowable.java,java.lang.OutOfMemoryError,OOM -ParallelFlowableConverter.java,0.7,507.32 -ParallelFlowableTest.java,java.lang.OutOfMemoryError,OOM -ParallelFromArray.java,551.0,510.67 -ParallelFromPublisher.java,java.lang.OutOfMemoryError,OOM -ParallelFromPublisherTest.java,java.lang.OutOfMemoryError,OOM -ParallelInvalid.java,java.lang.OutOfMemoryError,OOM -ParallelJoin.java,java.lang.OutOfMemoryError,OOM -ParallelJoinTest.java,java.lang.OutOfMemoryError,OOM -ParallelMap.java,java.lang.OutOfMemoryError,OOM -ParallelMapTest.java,java.lang.OutOfMemoryError,OOM -ParallelMapTry.java,java.lang.OutOfMemoryError,OOM -ParallelMapTryTest.java,java.lang.OutOfMemoryError,OOM -ParallelPeek.java,java.lang.OutOfMemoryError,OOM -ParallelPeekTest.java,java.lang.OutOfMemoryError,OOM -ParallelPerf.java,java.lang.OutOfMemoryError,OOM -ParallelReduce.java,java.lang.OutOfMemoryError,OOM -ParallelReduceFull.java,java.lang.OutOfMemoryError,OOM -ParallelReduceFullTest.java,java.lang.OutOfMemoryError,OOM -ParallelReduceTest.java,java.lang.OutOfMemoryError,OOM -ParallelRunOn.java,java.lang.OutOfMemoryError,OOM -ParallelRunOnTest.java,java.lang.OutOfMemoryError,OOM -ParallelSortedJoin.java,java.lang.OutOfMemoryError,OOM -ParallelSortedJoinTest.java,java.lang.OutOfMemoryError,OOM -ParallelTransformer.java,0.3,507.89 -ParamValidationCheckerTest.java,java.lang.OutOfMemoryError,OOM -PerfAsyncConsumer.java,java.lang.OutOfMemoryError,OOM -PerfBoundedSubscriber.java,java.lang.OutOfMemoryError,OOM -PerfConsumer.java,java.lang.OutOfMemoryError,OOM -PerfInteropConsumer.java,java.lang.OutOfMemoryError,OOM -PerfObserver.java,java.lang.OutOfMemoryError,OOM -PerfSubscriber.java,java.lang.OutOfMemoryError,OOM -Pow2.java,java.lang.OutOfMemoryError,OOM -Predicate.java,0.0,507.93 -ProtocolViolationException.java,0.2,507.93 -PublicFinalMethods.java,java.lang.OutOfMemoryError,OOM -PublishProcessor.java,java.lang.OutOfMemoryError,OOM -PublishProcessorAsPublisherTckTest.java,java.lang.OutOfMemoryError,OOM -PublishProcessorPerf.java,java.lang.OutOfMemoryError,OOM -PublishProcessorTest.java,java.lang.OutOfMemoryError,OOM -PublishSelectorTckTest.java,java.lang.OutOfMemoryError,OOM -PublishSubject.java,java.lang.OutOfMemoryError,OOM -PublishSubjectTest.java,java.lang.OutOfMemoryError,OOM -PublishTckTest.java,java.lang.OutOfMemoryError,OOM -QueueDisposable.java,0.1,507.98 -QueueDrain.java,0.4,507.99 -QueueDrainHelper.java,java.lang.OutOfMemoryError,OOM -QueueDrainHelperTest.java,java.lang.OutOfMemoryError,OOM -QueueDrainObserver.java,java.lang.OutOfMemoryError,OOM -QueueDrainObserverTest.java,java.lang.OutOfMemoryError,OOM -QueueDrainSubscriber.java,java.lang.OutOfMemoryError,OOM -QueueDrainSubscriberTest.java,java.lang.OutOfMemoryError,OOM -QueueFuseable.java,0.4,508.2 -QueueSubscription.java,0.2,508.2 -QueueSubscriptionTest.java,java.lang.OutOfMemoryError,OOM -RangePerf.java,java.lang.OutOfMemoryError,OOM -RangeTckTest.java,java.lang.OutOfMemoryError,OOM -RebatchRequestsTckTest.java,java.lang.OutOfMemoryError,OOM -ReducePerf.java,java.lang.OutOfMemoryError,OOM -ReduceTckTest.java,390.9,510.53 -ReduceWithTckTest.java,java.lang.OutOfMemoryError,OOM -RefCountProcessor.java,java.lang.OutOfMemoryError,OOM -ReferenceDisposable.java,java.lang.OutOfMemoryError,OOM -RepeatTckTest.java,2.6,510.29 -ReplayProcessor.java,java.lang.OutOfMemoryError,OOM -ReplayProcessorBoundedConcurrencyTest.java,java.lang.OutOfMemoryError,OOM -ReplayProcessorConcurrencyTest.java,java.lang.OutOfMemoryError,OOM -ReplayProcessorSizeBoundAsPublisherTckTest.java,java.lang.OutOfMemoryError,OOM -ReplayProcessorTest.java,java.lang.OutOfMemoryError,OOM -ReplayProcessorTimeBoundAsPublisherTckTest.java,java.lang.OutOfMemoryError,OOM -ReplayProcessorUnboundedAsPublisherTckTest.java,java.lang.OutOfMemoryError,OOM -ReplaySelectorTckTest.java,java.lang.OutOfMemoryError,OOM -ReplaySubject.java,java.lang.OutOfMemoryError,OOM -ReplaySubjectBoundedConcurrencyTest.java,java.lang.OutOfMemoryError,OOM -ReplaySubjectConcurrencyTest.java,java.lang.OutOfMemoryError,OOM -ReplaySubjectTest.java,java.lang.OutOfMemoryError,OOM -ReplayTckTest.java,java.lang.OutOfMemoryError,OOM -ResettableConnectable.java,0.0,508.67 -ResourceCompletableObserver.java,java.lang.OutOfMemoryError,OOM -ResourceCompletableObserverTest.java,java.lang.OutOfMemoryError,OOM -ResourceMaybeObserver.java,java.lang.OutOfMemoryError,OOM -ResourceMaybeObserverTest.java,java.lang.OutOfMemoryError,OOM -ResourceObserver.java,java.lang.OutOfMemoryError,OOM -ResourceObserverTest.java,java.lang.OutOfMemoryError,OOM -ResourceSingleObserver.java,java.lang.OutOfMemoryError,OOM -ResourceSingleObserverTest.java,java.lang.OutOfMemoryError,OOM -ResourceSubscriber.java,java.lang.OutOfMemoryError,OOM -ResourceSubscriberTest.java,java.lang.OutOfMemoryError,OOM -ResumeSingleObserver.java,java.lang.OutOfMemoryError,OOM -Retry.java,java.lang.OutOfMemoryError,OOM -RetryTckTest.java,java.lang.OutOfMemoryError,OOM -RunnableDisposable.java,java.lang.OutOfMemoryError,OOM -RxJavaPlugins.java,java.lang.OutOfMemoryError,OOM -RxJavaPluginsTest.java,java.lang.OutOfMemoryError,OOM -RxThreadFactory.java,java.lang.OutOfMemoryError,OOM -RxThreadFactoryTest.java,728.3,510.06 -RxVsStreamPerf.java,java.lang.OutOfMemoryError,OOM -SafeObserver.java,java.lang.OutOfMemoryError,OOM -SafeObserverTest.java,java.lang.OutOfMemoryError,OOM -SafeSubscriber.java,java.lang.OutOfMemoryError,OOM -SafeSubscriberTest.java,java.lang.OutOfMemoryError,OOM -SafeSubscriberWithPluginTest.java,java.lang.OutOfMemoryError,OOM -ScalarCallable.java,0.5,508.78 -ScalarSubscription.java,java.lang.OutOfMemoryError,OOM -ScalarSubscriptionTest.java,java.lang.OutOfMemoryError,OOM -ScalarXMapZHelper.java,java.lang.OutOfMemoryError,OOM -ScalarXMapZHelperTest.java,java.lang.OutOfMemoryError,OOM -ScanTckTest.java,java.lang.OutOfMemoryError,OOM -ScheduledDirectPeriodicTask.java,java.lang.OutOfMemoryError,OOM -ScheduledDirectPeriodicTaskTest.java,java.lang.OutOfMemoryError,OOM -ScheduledDirectTask.java,java.lang.OutOfMemoryError,OOM -ScheduledRunnable.java,java.lang.OutOfMemoryError,OOM -ScheduledRunnableTest.java,java.lang.OutOfMemoryError,OOM -Scheduler.java,java.lang.OutOfMemoryError,OOM -SchedulerLifecycleTest.java,java.lang.OutOfMemoryError,OOM -SchedulerMultiWorkerSupport.java,0.5,508.94 -SchedulerMultiWorkerSupportTest.java,java.lang.OutOfMemoryError,OOM -SchedulerPoolFactory.java,java.lang.OutOfMemoryError,OOM -SchedulerPoolFactoryTest.java,java.lang.OutOfMemoryError,OOM -SchedulerRunnableIntrospection.java,0.1,508.94 -SchedulerSupport.java,java.lang.OutOfMemoryError,OOM -SchedulerTest.java,java.lang.OutOfMemoryError,OOM -SchedulerTestHelper.java,java.lang.OutOfMemoryError,OOM -SchedulerWhen.java,java.lang.OutOfMemoryError,OOM -SchedulerWhenTest.java,java.lang.OutOfMemoryError,OOM -SchedulerWorkerTest.java,java.lang.OutOfMemoryError,OOM -Schedulers.java,java.lang.OutOfMemoryError,OOM -SequenceEqualTckTest.java,java.lang.OutOfMemoryError,OOM -SequentialDisposable.java,java.lang.OutOfMemoryError,OOM -SequentialDisposableTest.java,java.lang.OutOfMemoryError,OOM -SerialDisposable.java,java.lang.OutOfMemoryError,OOM -SerialDisposableTests.java,java.lang.OutOfMemoryError,OOM -SerializedObserver.java,java.lang.OutOfMemoryError,OOM -SerializedObserverTest.java,java.lang.OutOfMemoryError,OOM -SerializedProcessor.java,java.lang.OutOfMemoryError,OOM -SerializedProcessorTest.java,java.lang.OutOfMemoryError,OOM -SerializedSubject.java,java.lang.OutOfMemoryError,OOM -SerializedSubjectTest.java,java.lang.OutOfMemoryError,OOM -SerializedSubscriber.java,java.lang.OutOfMemoryError,OOM -SerializedSubscriberTest.java,java.lang.OutOfMemoryError,OOM -ShareTckTest.java,java.lang.OutOfMemoryError,OOM -SimplePlainQueue.java,0.3,509.22 -SimpleQueue.java,0.1,509.23 -SimpleQueueTest.java,java.lang.OutOfMemoryError,OOM -Single.java,java.lang.OutOfMemoryError,OOM -SingleAmb.java,java.lang.OutOfMemoryError,OOM -SingleAmbTest.java,java.lang.OutOfMemoryError,OOM -SingleCache.java,java.lang.OutOfMemoryError,OOM -SingleCacheTest.java,java.lang.OutOfMemoryError,OOM -SingleConcatPublisherTest.java,java.lang.OutOfMemoryError,OOM -SingleConcatTest.java,java.lang.OutOfMemoryError,OOM -SingleContains.java,java.lang.OutOfMemoryError,OOM -SingleContainstTest.java,java.lang.OutOfMemoryError,OOM -SingleConverter.java,0.1,509.37 -SingleCreate.java,java.lang.OutOfMemoryError,OOM -SingleCreateTest.java,java.lang.OutOfMemoryError,OOM -SingleDefer.java,java.lang.OutOfMemoryError,OOM -SingleDeferTest.java,java.lang.OutOfMemoryError,OOM -SingleDelay.java,java.lang.OutOfMemoryError,OOM -SingleDelayTest.java,java.lang.OutOfMemoryError,OOM -SingleDelayWithCompletable.java,java.lang.OutOfMemoryError,OOM -SingleDelayWithObservable.java,java.lang.OutOfMemoryError,OOM -SingleDelayWithPublisher.java,java.lang.OutOfMemoryError,OOM -SingleDelayWithSingle.java,java.lang.OutOfMemoryError,OOM -SingleDetach.java,java.lang.OutOfMemoryError,OOM -SingleDetachTest.java,java.lang.OutOfMemoryError,OOM -SingleDoAfterSuccess.java,java.lang.OutOfMemoryError,OOM -SingleDoAfterSuccessTest.java,java.lang.OutOfMemoryError,OOM -SingleDoAfterTerminate.java,java.lang.OutOfMemoryError,OOM -SingleDoAfterTerminateTest.java,java.lang.OutOfMemoryError,OOM -SingleDoFinally.java,java.lang.OutOfMemoryError,OOM -SingleDoFinallyTest.java,java.lang.OutOfMemoryError,OOM -SingleDoOnDispose.java,java.lang.OutOfMemoryError,OOM -SingleDoOnError.java,java.lang.OutOfMemoryError,OOM -SingleDoOnEvent.java,java.lang.OutOfMemoryError,OOM -SingleDoOnSubscribe.java,java.lang.OutOfMemoryError,OOM -SingleDoOnSuccess.java,java.lang.OutOfMemoryError,OOM -SingleDoOnTest.java,java.lang.OutOfMemoryError,OOM -SingleEmitter.java,0.5,509.44 -SingleEquals.java,java.lang.OutOfMemoryError,OOM -SingleEqualsTest.java,java.lang.OutOfMemoryError,OOM -SingleError.java,java.lang.OutOfMemoryError,OOM -SingleErrorTest.java,java.lang.OutOfMemoryError,OOM -SingleFlatMap.java,java.lang.OutOfMemoryError,OOM -SingleFlatMapCompletable.java,java.lang.OutOfMemoryError,OOM -SingleFlatMapCompletableTest.java,java.lang.OutOfMemoryError,OOM -SingleFlatMapFlowableTckTest.java,java.lang.OutOfMemoryError,OOM -SingleFlatMapIterableFlowable.java,java.lang.OutOfMemoryError,OOM -SingleFlatMapIterableFlowableTest.java,java.lang.OutOfMemoryError,OOM -SingleFlatMapIterableObservable.java,java.lang.OutOfMemoryError,OOM -SingleFlatMapIterableObservableTest.java,java.lang.OutOfMemoryError,OOM -SingleFlatMapMaybe.java,java.lang.OutOfMemoryError,OOM -SingleFlatMapMaybeTest.java,java.lang.OutOfMemoryError,OOM -SingleFlatMapObservable.java,java.lang.OutOfMemoryError,OOM -SingleFlatMapObservableTest.java,java.lang.OutOfMemoryError,OOM -SingleFlatMapPublisher.java,java.lang.OutOfMemoryError,OOM -SingleFlatMapTest.java,java.lang.OutOfMemoryError,OOM -SingleFromCallable.java,java.lang.OutOfMemoryError,OOM -SingleFromCallableTest.java,java.lang.OutOfMemoryError,OOM -SingleFromPublisher.java,java.lang.OutOfMemoryError,OOM -SingleFromPublisherTest.java,java.lang.OutOfMemoryError,OOM -SingleFromTest.java,java.lang.OutOfMemoryError,OOM -SingleFromUnsafeSource.java,java.lang.OutOfMemoryError,OOM -SingleHide.java,java.lang.OutOfMemoryError,OOM -SingleHideTest.java,java.lang.OutOfMemoryError,OOM -SingleInternalHelper.java,java.lang.OutOfMemoryError,OOM -SingleInternalHelperTest.java,java.lang.OutOfMemoryError,OOM -SingleJust.java,java.lang.OutOfMemoryError,OOM -SingleLift.java,java.lang.OutOfMemoryError,OOM -SingleLiftTest.java,java.lang.OutOfMemoryError,OOM -SingleMap.java,java.lang.OutOfMemoryError,OOM -SingleMapTest.java,java.lang.OutOfMemoryError,OOM -SingleMergeTest.java,java.lang.OutOfMemoryError,OOM -SingleMiscTest.java,java.lang.OutOfMemoryError,OOM -SingleNever.java,java.lang.OutOfMemoryError,OOM -SingleNullTests.java,java.lang.OutOfMemoryError,OOM -SingleObserveOn.java,java.lang.OutOfMemoryError,OOM -SingleObserveOnTest.java,java.lang.OutOfMemoryError,OOM -SingleObserver.java,0.4,509.65 -SingleOnErrorReturn.java,java.lang.OutOfMemoryError,OOM -SingleOnErrorXTest.java,java.lang.OutOfMemoryError,OOM -SingleOnSubscribe.java,0.3,509.65 -SingleOperator.java,0.5,509.65 -SinglePostCompleteSubscriber.java,java.lang.OutOfMemoryError,OOM -SinglePostCompleteSubscriberTest.java,java.lang.OutOfMemoryError,OOM -SingleResumeNext.java,java.lang.OutOfMemoryError,OOM -SingleRetryTest.java,java.lang.OutOfMemoryError,OOM -SingleScheduler.java,java.lang.OutOfMemoryError,OOM -SingleSchedulerTest.java,java.lang.OutOfMemoryError,OOM -SingleSource.java,0.3,509.77 -SingleSubject.java,java.lang.OutOfMemoryError,OOM -SingleSubjectTest.java,java.lang.OutOfMemoryError,OOM -SingleSubscribeOn.java,java.lang.OutOfMemoryError,OOM -SingleSubscribeOnTest.java,java.lang.OutOfMemoryError,OOM -SingleSubscribeTest.java,java.lang.OutOfMemoryError,OOM -SingleTakeUntil.java,java.lang.OutOfMemoryError,OOM -SingleTakeUntilTest.java,java.lang.OutOfMemoryError,OOM -SingleTckTest.java,java.lang.OutOfMemoryError,OOM -SingleTest.java,java.lang.OutOfMemoryError,OOM -SingleTimeout.java,java.lang.OutOfMemoryError,OOM -SingleTimeoutTest.java,java.lang.OutOfMemoryError,OOM -SingleTimer.java,java.lang.OutOfMemoryError,OOM -SingleTimerTest.java,java.lang.OutOfMemoryError,OOM -SingleToFlowable.java,java.lang.OutOfMemoryError,OOM -SingleToFlowableTest.java,java.lang.OutOfMemoryError,OOM -SingleToObservable.java,java.lang.OutOfMemoryError,OOM -SingleToObservableTest.java,java.lang.OutOfMemoryError,OOM -SingleTransformer.java,0.4,509.76 -SingleUnsubscribeOn.java,java.lang.OutOfMemoryError,OOM -SingleUnsubscribeOnTest.java,java.lang.OutOfMemoryError,OOM -SingleUsing.java,java.lang.OutOfMemoryError,OOM -SingleUsingTest.java,java.lang.OutOfMemoryError,OOM -SingleZipArray.java,java.lang.OutOfMemoryError,OOM -SingleZipArrayTest.java,java.lang.OutOfMemoryError,OOM -SingleZipIterable.java,java.lang.OutOfMemoryError,OOM -SingleZipIterableTest.java,java.lang.OutOfMemoryError,OOM -SingleZipTest.java,java.lang.OutOfMemoryError,OOM -SkipLastTckTest.java,java.lang.OutOfMemoryError,OOM -SkipTckTest.java,java.lang.OutOfMemoryError,OOM -SkipUntilTckTest.java,java.lang.OutOfMemoryError,OOM -SkipWhileTckTest.java,java.lang.OutOfMemoryError,OOM -SortedTckTest.java,java.lang.OutOfMemoryError,OOM -SorterFunction.java,java.lang.OutOfMemoryError,OOM -SpscArrayQueue.java,java.lang.OutOfMemoryError,OOM -SpscLinkedArrayQueue.java,java.lang.OutOfMemoryError,OOM -StrictPerf.java,java.lang.OutOfMemoryError,OOM -StrictSubscriber.java,java.lang.OutOfMemoryError,OOM -StrictSubscriberTest.java,java.lang.OutOfMemoryError,OOM -Subject.java,java.lang.OutOfMemoryError,OOM -SubjectTest.java,java.lang.OutOfMemoryError,OOM -SubscribeOnTckTest.java,java.lang.OutOfMemoryError,OOM -SubscribeWithTest.java,java.lang.OutOfMemoryError,OOM -SubscriberCompletableObserver.java,java.lang.OutOfMemoryError,OOM -SubscriberFusion.java,java.lang.OutOfMemoryError,OOM -SubscriberResourceWrapper.java,java.lang.OutOfMemoryError,OOM -SubscriberResourceWrapperTest.java,java.lang.OutOfMemoryError,OOM -SubscriptionArbiter.java,java.lang.OutOfMemoryError,OOM -SubscriptionArbiterTest.java,java.lang.OutOfMemoryError,OOM -SubscriptionDisposable.java,java.lang.OutOfMemoryError,OOM -SubscriptionHelper.java,java.lang.OutOfMemoryError,OOM -SubscriptionHelperTest.java,java.lang.OutOfMemoryError,OOM -SuppressAnimalSniffer.java,16.3,510.06 -SwitchIfEmptyTckTest.java,java.lang.OutOfMemoryError,OOM -SwitchMapDelayErrorTckTest.java,java.lang.OutOfMemoryError,OOM -SwitchMapTckTest.java,java.lang.OutOfMemoryError,OOM -SwitchOnNextTckTest.java,java.lang.OutOfMemoryError,OOM -TakeLastTckTest.java,java.lang.OutOfMemoryError,OOM -TakeTckTest.java,java.lang.OutOfMemoryError,OOM -TakeUntilPerf.java,java.lang.OutOfMemoryError,OOM -TakeUntilTckTest.java,java.lang.OutOfMemoryError,OOM -TakeWhileTckTest.java,java.lang.OutOfMemoryError,OOM -TestException.java,0.3,510.13 -TestHelper.java,java.lang.OutOfMemoryError,OOM -TestObserver.java,java.lang.OutOfMemoryError,OOM -TestObserverTest.java,java.lang.OutOfMemoryError,OOM -TestScheduler.java,java.lang.OutOfMemoryError,OOM -TestSchedulerTest.java,java.lang.OutOfMemoryError,OOM -TestSubscriber.java,java.lang.OutOfMemoryError,OOM -TestSubscriberTest.java,java.lang.OutOfMemoryError,OOM -TestingHelper.java,java.lang.OutOfMemoryError,OOM -TextualAorAn.java,java.lang.OutOfMemoryError,OOM -TimeIntervalTckTest.java,java.lang.OutOfMemoryError,OOM -Timed.java,java.lang.OutOfMemoryError,OOM -TimedTest.java,java.lang.OutOfMemoryError,OOM -TimeoutTckTest.java,java.lang.OutOfMemoryError,OOM -TimerTckTest.java,java.lang.OutOfMemoryError,OOM -TimestampTckTest.java,java.lang.OutOfMemoryError,OOM -ToFlowablePerf.java,java.lang.OutOfMemoryError,OOM -ToListTckTest.java,java.lang.OutOfMemoryError,OOM -ToMapTckTest.java,java.lang.OutOfMemoryError,OOM -ToMultimapTckTest.java,java.lang.OutOfMemoryError,OOM -ToSortedListTckTest.java,java.lang.OutOfMemoryError,OOM -TooManyEmptyNewLines.java,java.lang.OutOfMemoryError,OOM -TrampolineScheduler.java,java.lang.OutOfMemoryError,OOM -TrampolineSchedulerInternalTest.java,java.lang.OutOfMemoryError,OOM -TrampolineSchedulerTest.java,java.lang.OutOfMemoryError,OOM -TransformerTest.java,java.lang.OutOfMemoryError,OOM -UndeliverableException.java,java.lang.OutOfMemoryError,OOM -UnicastProcessor.java,java.lang.OutOfMemoryError,OOM -UnicastProcessorAsPublisherTckTest.java,java.lang.OutOfMemoryError,OOM -UnicastProcessorTckTest.java,java.lang.OutOfMemoryError,OOM -UnicastProcessorTest.java,java.lang.OutOfMemoryError,OOM -UnicastSubject.java,java.lang.OutOfMemoryError,OOM -UnicastSubjectTest.java,java.lang.OutOfMemoryError,OOM -UnsubscribeOnTckTest.java,java.lang.OutOfMemoryError,OOM -UsingTckTest.java,java.lang.OutOfMemoryError,OOM -VolatileSizeArrayList.java,java.lang.OutOfMemoryError,OOM -VolatileSizeArrayListTest.java,java.lang.OutOfMemoryError,OOM -WindowBoundaryTckTest.java,java.lang.OutOfMemoryError,OOM -WindowExactSizeTckTest.java,java.lang.OutOfMemoryError,OOM -WithLatestFromTckTest.java,java.lang.OutOfMemoryError,OOM -XFlatMapTest.java,java.lang.OutOfMemoryError,OOM -XMapYPerf.java,java.lang.OutOfMemoryError,OOM -ZipIterableTckTest.java,java.lang.OutOfMemoryError,OOM -ZipTckTest.java,java.lang.OutOfMemoryError,OOM -ZipWithIterableTckTest.java,java.lang.OutOfMemoryError,OOM -ZipWithTckTest.java,java.lang.OutOfMemoryError,OOM -package-info.java,0.1,510.07 \ No newline at end of file diff --git a/benchmarks/src/test/result/AntlrFast/AntlrFast_java_correct_junit-4-12.csv b/benchmarks/src/test/result/AntlrFast/AntlrFast_java_correct_junit-4-12.csv deleted file mode 100644 index 8cd89e01a..000000000 --- a/benchmarks/src/test/result/AntlrFast/AntlrFast_java_correct_junit-4-12.csv +++ /dev/null @@ -1,353 +0,0 @@ -fileName,processing_tim_avg_20_times_millis,max_heap_size_mbMb -ActiveTestSuite.java,7.5,17.28 -ActiveTestTest.java,3.05,7.73 -After.java,1.0,7.52 -AfterClass.java,0.85,7.31 -AllDefaultPossibilitiesBuilder.java,4.25,11.67 -AllMembersSupplier.java,7.9,11.14 -AllMembersSupplierTest.java,10.8,15.89 -AllTests.java,2.0,8.55 -AllTestsTest.java,3.0,10.23 -Annotatable.java,0.6,9.04 -AnnotatedBuilder.java,1.5,8.85 -AnnotatedBuilderTest.java,1.85,8.87 -AnnotatedDescriptionTest.java,2.05,9.12 -AnnotationTest.java,11.45,14.9 -AnnotationValidator.java,0.4,8.19 -AnnotationValidatorFactory.java,0.95,9.93 -AnnotationValidatorFactoryTest.java,1.75,8.99 -AnnotationsValidator.java,3.95,11.97 -AnnotationsValidatorTest.java,3.15,10 -ArrayComparisonFailure.java,0.7,8.58 -Assert.java,5.1,11.1 -AssertTest.java,0.95,8.64 -AssertionFailedError.java,0.55,8.39 -AssertionFailedErrorTest.java,0.4,8.4 -AssertionTest.java,13.5,19.87 -Assignments.java,5.6,12.89 -Assume.java,1.25,10.46 -AssumingInTheoriesTest.java,0.75,8.79 -AssumptionTest.java,5.85,11.02 -AssumptionViolatedException.java,1.15,8.8 -AssumptionViolatedExceptionTest.java,3.1,11.26 -BadlyFormedClassesTest.java,1.15,8.9 -BaseTestRunner.java,7.2,11.89 -BaseTestRunnerTest.java,0.65,8.93 -Before.java,0.35,8.69 -BeforeClass.java,0.4,8.69 -BlockJUnit4ClassRunner.java,6.45,19.16 -BlockJUnit4ClassRunnerOverrideTest.java,1.35,9.66 -BlockJUnit4ClassRunnerTest.java,1.4,9.44 -BlockJUnit4ClassRunnerWithParameters.java,5.85,19.95 -BlockJUnit4ClassRunnerWithParametersFactory.java,0.3,9.4 -BooleanSupplier.java,0.2,9.41 -Categories.java,3.45,11.66 -CategoriesAndParameterizedTest.java,3.05,11.44 -Category.java,0.3,9.49 -CategoryFilterFactory.java,0.35,9.49 -CategoryFilterFactoryTest.java,1.1,9.78 -CategoryTest.java,10.9,16.49 -CategoryValidator.java,1.0,10.22 -CategoryValidatorTest.java,4.6,12.23 -ClassLevelMethodsWithIgnoredTestsTest.java,3.1,11.01 -ClassRequest.java,1.1,9.79 -ClassRequestTest.java,0.2,9.57 -ClassRoadie.java,2.2,10.57 -ClassRule.java,0.3,9.58 -ClassRulesTest.java,4.25,11.36 -Classes.java,0.25,9.58 -CommandLineTest.java,1.6,10.02 -ComparisonCompactor.java,5.3,12.36 -ComparisonCompactorTest.java,1.65,10.04 -ComparisonCriteria.java,2.0,10.59 -ComparisonFailure.java,4.3,12.26 -ComparisonFailureTest.java,1.0,9.82 -Computer.java,0.45,9.6 -ConcurrentRunNotifierTest.java,2.05,10.38 -Correspondent.java,0.15,9.6 -CouldNotReadCoreException.java,0.1,9.6 -DataPoint.java,0.25,9.61 -DataPoints.java,0.5,9.62 -Describable.java,0.55,10.05 -Description.java,2.85,11.62 -DescriptionTest.java,4.6,11.66 -DisableOnDebug.java,0.9,11.1 -DisableOnDebugTest.java,2.1,10.96 -DoublePrecisionAssertTest.java,0.5,9.99 -EachTestNotifier.java,0.4,9.77 -Enclosed.java,0.8,9.99 -EnclosedTest.java,1.55,10.21 -EnumSupplier.java,1.2,10.21 -ErrorCollector.java,0.75,12.99 -ErrorReportingRunner.java,2.2,11.92 -ErrorReportingRunnerTest.java,0.5,10.17 -EventCollector.java,4.5,16.96 -ExactComparisonCriteria.java,0.45,10.25 -ExcludeCategories.java,0.85,10.25 -ExpectException.java,1.55,10.91 -ExpectedException.java,1.1,10.71 -ExpectedExceptionMatcherBuilder.java,0.95,10.7 -ExpectedExceptionTest.java,6.05,12.94 -ExpectedTest.java,3.05,11.49 -ExperimentalTests.java,0.2,10.27 -ExtensionTest.java,1.9,10.93 -ExternalResource.java,0.55,10.28 -ExternalResourceRuleTest.java,0.9,10.5 -Fail.java,0.3,10.28 -FailOnTimeout.java,5.3,12.5 -FailOnTimeoutTest.java,2.75,11.29 -FailedBefore.java,0.15,10.29 -FailedConstructionTest.java,0.5,10.29 -FailingDataPointMethods.java,3.6,12.29 -Failure.java,0.5,10.3 -FailureList.java,0.35,10.3 -Filter.java,1.5,10.96 -FilterFactories.java,1.0,10.74 -FilterFactoriesTest.java,2.3,11.08 -FilterFactory.java,0.4,10.3 -FilterFactoryParams.java,0.4,10.3 -FilterOptionIntegrationTest.java,3.65,11.74 -FilterRequest.java,0.45,10.3 -FilterTest.java,1.05,10.52 -Filterable.java,0.2,10.3 -FilterableTest.java,1.4,10.74 -FixMethodOrder.java,0.4,10.29 -FloatAssertTest.java,0.6,10.49 -ForwardCompatibilityPrintingTest.java,1.45,10.69 -ForwardCompatibilityTest.java,4.0,12.53 -FrameworkField.java,1.15,10.89 -FrameworkFieldTest.java,1.2,10.71 -FrameworkMember.java,0.65,10.71 -FrameworkMethod.java,5.25,14.93 -FrameworkMethodTest.java,1.1,10.82 -FromDataPoints.java,0.25,10.44 -Guesser.java,3.5,12.62 -GuesserQueue.java,1.1,11.67 -IMoney.java,0.45,10.52 -Ignore.java,0.35,10.52 -IgnoreClassTest.java,0.65,10.72 -IgnoredBuilder.java,0.15,10.52 -IgnoredClassRunner.java,0.4,10.54 -IncludeCategories.java,0.75,10.72 -InexactComparisonCriteria.java,0.55,10.52 -InheritedTestCase.java,0.15,10.52 -InheritedTestTest.java,0.9,10.72 -InitializationError.java,0.55,10.53 -InitializationErrorForwardCompatibilityTest.java,1.7,11.13 -InvokeMethod.java,0.4,10.53 -JUnit38ClassRunner.java,3.15,11.73 -JUnit38ClassRunnerTest.java,2.65,11.73 -JUnit38SortingTest.java,2.3,11.33 -JUnit3Builder.java,0.2,10.53 -JUnit4.java,0.15,10.53 -JUnit4Builder.java,0.1,10.53 -JUnit4ClassRunner.java,3.15,12.94 -JUnit4ClassRunnerTest.java,1.25,10.98 -JUnit4TestAdapter.java,1.45,11.18 -JUnit4TestAdapterCache.java,1.4,11.19 -JUnit4TestCaseFacade.java,0.3,10.58 -JUnitCommandLineParseResult.java,4.35,12.19 -JUnitCommandLineParseResultTest.java,5.15,12.59 -JUnitCore.java,1.15,10.79 -JUnitCoreReturnsCorrectExitCodeTest.java,0.85,10.79 -JUnitCoreTest.java,0.35,10.59 -JUnitMatchers.java,1.2,12.39 -JUnitSystem.java,0.5,10.86 -JavadocTest.java,1.4,11.12 -ListTest.java,3.9,12.66 -ListenerTest.java,0.85,10.88 -LoggingTestWatcher.java,0.6,10.88 -MainRunner.java,3.35,13.09 -MatcherTest.java,0.9,10.89 -MaxCore.java,2.95,18.09 -MaxHistory.java,2.4,12.27 -MaxStarterTest.java,5.65,16.1 -MethodCall.java,1.8,11.91 -MethodRoadie.java,5.7,15.29 -MethodRule.java,0.2,11.16 -MethodRulesTest.java,5.8,15.34 -MethodSorter.java,1.8,12.14 -MethodSorterTest.java,9.6,17.87 -MethodSorters.java,0.35,11.21 -MethodValidator.java,4.55,13.7 -Money.java,1.9,11.88 -MoneyBag.java,2.55,12.52 -MoneyTest.java,5.0,14.17 -MultiCategoryTest.java,6.5,14.35 -MultipleFailureException.java,0.2,11.17 -MultipleFailureExceptionTest.java,3.35,12.71 -NameRulesTest.java,0.95,11.59 -NoArgTestCaseTest.java,0.15,11.17 -NoGenericTypeParametersValidator.java,1.4,16.17 -NoTestCaseClass.java,0.3,11.44 -NoTestCases.java,0.35,11.45 -NoTestsRemainException.java,0.25,11.44 -NotPublicTestCase.java,0.15,11.45 -NotVoidTestCase.java,0.15,11.45 -NullBuilder.java,0.2,11.45 -ObjectContractTest.java,1.15,11.81 -OldTestClassAdaptingListenerTest.java,0.5,11.45 -OldTests.java,0.3,11.46 -OneTestCase.java,0.35,11.46 -OverrideTestCase.java,0.2,11.46 -ParallelClassTest.java,1.95,12.18 -ParallelComputer.java,1.0,11.82 -ParallelMethodTest.java,1.4,12.01 -ParameterSignature.java,2.6,13.83 -ParameterSignatureTest.java,7.5,17.54 -ParameterSupplier.java,0.05,11.67 -Parameterized.java,4.45,15.23 -ParameterizedAssertionError.java,1.7,15.87 -ParameterizedAssertionErrorTest.java,1.85,12.6 -ParameterizedNamesTest.java,1.2,12.24 -ParameterizedTestMethodTest.java,4.0,14.07 -ParameterizedTestTest.java,14.0,17.72 -ParametersRunnerFactory.java,0.2,11.89 -ParametersSuppliedBy.java,0.2,11.89 -ParentRunner.java,9.8,19.44 -ParentRunnerFilteringTest.java,4.45,13.98 -ParentRunnerTest.java,4.05,14.17 -PotentialAssignment.java,0.95,12.16 -PotentialAssignmentTest.java,1.25,12.34 -PrintableResult.java,0.75,11.98 -PrintableResultTest.java,1.05,12.34 -Protectable.java,0.65,12.02 -PublicClassValidator.java,0.65,11.98 -PublicClassValidatorTest.java,2.45,12.98 -RealSystem.java,0.5,11.98 -ReflectiveCallable.java,0.15,11.99 -ReguessableValue.java,0.25,11.99 -RepeatedTest.java,0.7,12.17 -RepeatedTestTest.java,0.65,12.17 -Request.java,0.65,12.35 -Result.java,3.85,14.72 -ResultMatchers.java,1.0,12.18 -ResultMatchersTest.java,0.55,12 -ResultPrinter.java,2.4,12.82 -ResultTest.java,1.7,12.73 -Rule.java,0.25,12.01 -RuleChain.java,1.7,12.55 -RuleChainTest.java,2.25,13 -RuleMemberValidator.java,3.1,17.19 -RuleMemberValidatorTest.java,5.5,14.74 -RunAfters.java,1.3,12.56 -RunBefores.java,0.55,12.2 -RunListener.java,0.55,12.2 -RunNotifier.java,3.8,15.38 -RunNotifierTest.java,2.45,13.12 -RunRules.java,0.7,12.48 -RunWith.java,0.5,12.3 -RunWithTest.java,1.65,12.85 -Runner.java,0.2,12.31 -RunnerBuilder.java,1.5,12.85 -RunnerBuilderStub.java,0.35,12.31 -RunnerScheduler.java,0.2,12.31 -RunnerSpy.java,0.8,12.31 -RunnerTest.java,1.35,12.85 -SimpleTest.java,0.7,12.49 -SingleMethodTest.java,4.4,14.31 -Sortable.java,0.1,12.31 -SortableTest.java,3.4,13.85 -Sorter.java,0.4,12.31 -SortingRequest.java,0.35,12.31 -SpecificDataPointsSupplier.java,6.8,15.68 -SpecificDataPointsSupplierTest.java,10.0,20.04 -StackFilterTest.java,1.15,12.69 -StacktracePrintingMatcher.java,1.05,12.91 -StacktracePrintingMatcherTest.java,0.8,12.53 -Statement.java,0.15,12.35 -StoppedByUserException.java,0.15,12.35 -Stopwatch.java,1.65,13.07 -StopwatchTest.java,4.2,14.53 -StringableObject.java,0.95,12.54 -Stub.java,0.05,12.36 -StubbedTheories.java,1.0,12.54 -StubbedTheoriesTest.java,0.35,12.36 -Sub.java,0.0,12.36 -Success.java,0.25,12.36 -SuccessfulWithDataPointFields.java,3.25,14.08 -Suite.java,1.45,12.91 -SuiteDescriptionTest.java,1.0,12.55 -SuiteMethod.java,0.9,12.73 -SuiteMethodBuilder.java,0.3,12.37 -SuiteMethodTest.java,2.0,13.19 -SuiteTest.java,4.35,14.37 -Super.java,0.2,12.38 -SynchronizedRunListener.java,1.2,12.74 -SynchronizedRunListenerTest.java,4.65,14.92 -SystemExitTest.java,1.3,12.74 -TempFolderRuleTest.java,3.25,14.92 -TemporaryFolder.java,1.5,13.11 -TemporaryFolderUsageTest.java,2.9,14.93 -Test.java,0.4,12.39 -TestCase.java,6.55,15.22 -TestCaseTest.java,3.0,13.75 -TestClass.java,3.5,14.57 -TestClassTest.java,6.65,16.58 -TestClassValidator.java,0.55,12.58 -TestDecorator.java,0.6,12.42 -TestDescriptionMethodNameTest.java,0.4,12.42 -TestDescriptionTest.java,0.5,12.6 -TestFailure.java,0.85,12.6 -TestImplementorTest.java,0.6,12.6 -TestListener.java,0.5,12.6 -TestListenerTest.java,1.4,12.96 -TestMethod.java,1.75,13.15 -TestMethodTest.java,6.5,16.55 -TestName.java,0.75,12.43 -TestResult.java,2.05,13.25 -TestRule.java,0.1,12.43 -TestRuleTest.java,14.75,20.62 -TestRunListener.java,0.8,12.79 -TestRunner.java,3.35,13.97 -TestSetup.java,0.55,12.43 -TestSuite.java,7.1,15.8 -TestSystem.java,0.6,12.43 -TestTimedOutException.java,0.35,12.43 -TestWatcher.java,1.8,15.98 -TestWatcherTest.java,3.15,13.96 -TestWatchman.java,0.55,12.6 -TestWatchmanTest.java,1.4,12.96 -TestWithParameters.java,2.75,14.14 -TestWithParametersTest.java,3.15,13.98 -TestedOn.java,0.35,12.63 -TestedOnSupplier.java,1.1,12.99 -TestedOnSupplierTest.java,2.3,13.45 -TextFeedbackTest.java,1.95,13.36 -TextListener.java,3.35,14.18 -TextListenerTest.java,1.35,13 -TextRunnerSingleMethodTest.java,0.65,12.64 -TextRunnerTest.java,1.4,13 -Theories.java,8.2,17.76 -TheoriesPerformanceTest.java,0.6,13.3 -Theory.java,0.2,13.12 -TheoryTestUtils.java,0.35,13.12 -ThreeTestCases.java,0.2,13.12 -ThrowableCauseMatcher.java,0.7,13.3 -ThrowableCauseMatcherTest.java,0.5,13.12 -ThrowableMessageMatcher.java,0.55,13.3 -Throwables.java,0.35,13.1 -Timeout.java,1.65,13.75 -TimeoutRuleTest.java,2.6,14.27 -TimeoutTest.java,6.0,16.75 -TypeMatchingBetweenMultiDataPointsMethod.java,1.4,13.49 -TypeSafeMatcher.java,1.75,13.95 -UnsuccessfulWithDataPointFields.java,4.3,15.28 -UseSuiteAsASuperclassTest.java,0.75,13.32 -UserStopTest.java,1.35,13.6 -ValidateWith.java,0.1,13.12 -ValidationError.java,0.25,13.14 -ValidationTest.java,0.9,13.44 -Verifier.java,0.4,13.12 -VerifierRuleTest.java,3.0,14.28 -Version.java,0.3,13.14 -WasRun.java,0.25,13.14 -WhenNoParametersMatch.java,0.95,13.45 -WithAutoGeneratedDataPoints.java,1.25,13.61 -WithDataPointMethod.java,1.95,14.13 -WithExtendedParameterSources.java,4.4,15.46 -WithNamedDataPoints.java,2.5,14.45 -WithOnlyTestAnnotations.java,2.45,14.13 -WithParameterSupplier.java,4.35,15.78 -WithUnresolvedGenericTypeVariablesOnTheoryParms.java,4.1,15.63 -package-info.java,0.0,13.18 \ No newline at end of file diff --git a/benchmarks/src/test/result/AntlrFast/AntlrFast_java_correct_rxjava-2-2-2.csv b/benchmarks/src/test/result/AntlrFast/AntlrFast_java_correct_rxjava-2-2-2.csv deleted file mode 100644 index 94438ea1f..000000000 --- a/benchmarks/src/test/result/AntlrFast/AntlrFast_java_correct_rxjava-2-2-2.csv +++ /dev/null @@ -1,1614 +0,0 @@ -fileName,processing_tim_avg_10_times_millis,max_heap_size_mbMb -AbstractDirectTask.java,15.6,19.81 -AbstractDirectTaskTest.java,35.5,18.84 -AbstractFlowableWithUpstream.java,2.6,11.19 -AbstractFlowableWithUpstreamTest.java,2.4,9.77 -AbstractMaybeWithUpstream.java,0.6,8.21 -AbstractMaybeWithUpstreamTest.java,1.6,8.77 -AbstractObservableWithUpstream.java,0.7,8.21 -AbstractObservableWithUpstreamTest.java,2.2,8.77 -AbstractSchedulerConcurrencyTests.java,14.0,19.01 -AbstractSchedulerTests.java,28.1,16.83 -Action.java,0.5,9.23 -ActionDisposable.java,0.7,9.58 -AllTckTest.java,0.7,9.18 -AmbArrayTckTest.java,0.4,9.18 -AmbTckTest.java,0.5,9.18 -AnyTckTest.java,0.7,9.18 -AppendOnlyLinkedArrayList.java,3.7,11.14 -ArrayCompositeDisposable.java,1.1,9.89 -ArrayCompositeDisposableTest.java,2.0,9.89 -ArrayCompositeSubscription.java,2.1,9.89 -ArrayCompositeSubscriptionTest.java,1.6,9.89 -ArrayListSupplier.java,1.5,11.85 -AsyncProcessor.java,4.9,22.67 -AsyncProcessorAsPublisherTckTest.java,1.0,10.28 -AsyncProcessorTest.java,21.1,29.08 -AsyncSubject.java,5.9,12.68 -AsyncSubjectTest.java,16.8,29.49 -AsyncSubscription.java,1.2,10.49 -AsyncSubscriptionTest.java,2.2,11.08 -AtomicThrowable.java,0.3,10.09 -AtomicThrowableTest.java,0.4,10.09 -BackpressureEnumTest.java,0.7,10.09 -BackpressureHelper.java,1.9,11.08 -BackpressureHelperTest.java,4.7,12.11 -BackpressureKind.java,0.2,10.12 -BackpressureOverflowStrategy.java,0.3,10.12 -BackpressureStrategy.java,0.0,10.12 -BackpressureSupport.java,0.6,10.12 -BaseTck.java,2.2,10.73 -BaseTypeAnnotations.java,5.0,13.14 -BaseTypeParser.java,11.1,15.15 -BasicFuseableConditionalSubscriber.java,3.2,11.56 -BasicFuseableConditionalSubscriberTest.java,3.8,15.59 -BasicFuseableObserver.java,1.9,11.36 -BasicFuseableObserverTest.java,2.6,12.35 -BasicFuseableSubscriber.java,2.2,11.01 -BasicFuseableSubscriberTest.java,0.7,10.55 -BasicIntQueueDisposable.java,0.5,10.42 -BasicIntQueueSubscription.java,0.5,10.42 -BasicQueueDisposable.java,0.4,10.42 -BasicQueueDisposableTest.java,2.1,11.01 -BasicQueueSubscription.java,0.6,10.43 -BehaviorProcessor.java,8.2,17.43 -BehaviorProcessorAsPublisherTckTest.java,0.9,10.87 -BehaviorProcessorTest.java,29.2,22.95 -BehaviorSubject.java,10.4,16.56 -BehaviorSubjectTest.java,27.0,16.42 -Beta.java,0.1,10.52 -BiConsumer.java,0.2,10.53 -BiConsumerSingleObserver.java,0.9,10.95 -BiFunction.java,0.4,10.55 -BiPredicate.java,0.4,10.56 -BinaryFlatMapPerf.java,13.2,23.98 -BlockingBaseObserver.java,0.9,10.56 -BlockingBaseSubscriber.java,0.9,10.95 -BlockingFirstObserver.java,0.0,10.56 -BlockingFirstObserverTest.java,0.7,10.95 -BlockingFirstSubscriber.java,0.7,10.55 -BlockingFlowableIterable.java,3.1,12.55 -BlockingFlowableLatest.java,2.3,13.95 -BlockingFlowableLatestTest.java,14.5,26.05 -BlockingFlowableMostRecent.java,3.6,12.68 -BlockingFlowableMostRecentTest.java,4.8,15.71 -BlockingFlowableNext.java,4.3,17.72 -BlockingFlowableNextTest.java,13.0,29.97 -BlockingFlowableToFutureTest.java,12.2,21.21 -BlockingFlowableToIteratorTest.java,11.1,23.63 -BlockingGetPerf.java,1.6,12.28 -BlockingHelper.java,1.3,12.28 -BlockingHelperTest.java,1.0,11.33 -BlockingIgnoringReceiver.java,0.3,11.33 -BlockingLastObserver.java,0.3,11.33 -BlockingLastSubscriber.java,0.4,11.33 -BlockingMultiObserver.java,1.2,11.73 -BlockingMultiObserverTest.java,3.3,12.33 -BlockingObservableIterable.java,3.2,12.73 -BlockingObservableLatest.java,5.3,13.33 -BlockingObservableLatestTest.java,14.6,25.74 -BlockingObservableMostRecent.java,2.4,12.73 -BlockingObservableMostRecentTest.java,11.5,16.69 -BlockingObservableNext.java,2.9,13.77 -BlockingObservableNextTest.java,13.1,25.98 -BlockingObservableToFutureTest.java,10.3,21.47 -BlockingObservableToIteratorTest.java,9.8,18.48 -BlockingObserver.java,1.3,11.88 -BlockingObserverTest.java,1.7,12.08 -BlockingPerf.java,1.7,12.08 -BlockingSubscriber.java,0.6,11.88 -BlockingSubscriberTest.java,3.6,13.88 -BooleanSubscription.java,0.4,11.52 -BooleanSupplier.java,0.4,11.52 -BoundedSubscriber.java,3.7,12.92 -BoundedSubscriberTest.java,34.7,21.36 -BufferBoundaryTckTest.java,0.6,12 -BufferExactSizeTckTest.java,0.3,11.98 -BufferUntilSubscriberTest.java,2.8,18.46 -Burst.java,0.9,12.24 -CacheTckTest.java,0.6,12.24 -CachedThreadSchedulerTest.java,6.3,17.24 -CallableAsyncPerf.java,12.4,18.73 -CallbackCompletableObserver.java,1.8,12.73 -CallbackCompletableObserverTest.java,0.6,12.27 -Cancellable.java,0.1,12.27 -CancellableDisposable.java,0.7,12.27 -CancellableDisposableTest.java,1.5,13.27 -CapturingUncaughtExceptionHandler.java,0.4,12.27 -CheckLocalVariablesInTests.java,9.4,16.74 -CheckReturnValue.java,0.3,12.27 -CollectTckTest.java,0.7,12.28 -CombineLatestArrayDelayErrorTckTest.java,0.5,12.28 -CombineLatestArrayTckTest.java,0.8,12.28 -CombineLatestIterableDelayErrorTckTest.java,0.5,12.28 -CombineLatestIterableTckTest.java,0.7,12.3 -Completable.java,19.4,26.86 -CompletableAmb.java,1.7,12.85 -CompletableAmbTest.java,7.8,20.37 -CompletableAndThenObservable.java,1.8,13.4 -CompletableAndThenObservableTest.java,7.9,16.4 -CompletableAndThenPublisher.java,1.8,12.88 -CompletableAndThenPublisherTckTest.java,0.3,12.4 -CompletableAndThenPublisherTest.java,4.2,14.4 -CompletableAndThenTest.java,1.8,12.96 -CompletableAwaitTest.java,1.5,12.88 -CompletableCache.java,3.4,12.97 -CompletableCacheTest.java,8.1,17.89 -CompletableConcat.java,5.9,14.43 -CompletableConcatArray.java,1.2,12.43 -CompletableConcatIterable.java,2.9,13.43 -CompletableConcatTest.java,7.6,18.42 -CompletableConverter.java,0.6,12.49 -CompletableCreate.java,1.3,12.93 -CompletableCreateTest.java,8.4,16.5 -CompletableDefer.java,1.1,12.51 -CompletableDelay.java,1.6,12.93 -CompletableDelayTest.java,3.7,14.93 -CompletableDetach.java,1.7,12.94 -CompletableDetachTest.java,6.8,17.93 -CompletableDisposeOn.java,1.5,12.95 -CompletableDisposeOnTest.java,7.4,15.95 -CompletableDoFinally.java,1.0,12.95 -CompletableDoFinallyTest.java,2.6,13.51 -CompletableDoOnEvent.java,1.0,12.51 -CompletableDoOnTest.java,3.9,15.52 -CompletableEmitter.java,0.8,12.52 -CompletableEmpty.java,0.4,12.52 -CompletableError.java,0.3,12.54 -CompletableErrorSupplier.java,0.9,12.54 -CompletableFromAction.java,0.7,12.52 -CompletableFromActionTest.java,1.7,13.52 -CompletableFromCallable.java,0.9,12.53 -CompletableFromCallableTest.java,8.0,15.97 -CompletableFromMaybeTest.java,0.9,13.01 -CompletableFromObservable.java,0.6,12.55 -CompletableFromObservableTest.java,0.8,12.97 -CompletableFromPublisher.java,1.3,12.98 -CompletableFromPublisherTest.java,1.8,13.01 -CompletableFromRunnable.java,0.8,12.54 -CompletableFromRunnableTest.java,2.7,13.54 -CompletableFromSingle.java,0.7,12.54 -CompletableFromSingleTest.java,1.0,12.54 -CompletableFromUnsafeSource.java,0.0,12.56 -CompletableHide.java,1.1,12.98 -CompletableHideTest.java,2.0,13.1 -CompletableLift.java,0.5,12.54 -CompletableLiftTest.java,1.5,12.98 -CompletableMerge.java,3.0,13.99 -CompletableMergeArray.java,0.8,12.55 -CompletableMergeDelayErrorArray.java,1.1,12.99 -CompletableMergeDelayErrorIterable.java,1.6,13.11 -CompletableMergeIterable.java,2.5,13.55 -CompletableMergeIterableTest.java,3.0,14.55 -CompletableMergeTest.java,22.6,36.14 -CompletableNever.java,0.6,12.62 -CompletableObserveOn.java,1.5,13.12 -CompletableObserveOnTest.java,0.7,12.63 -CompletableObserver.java,0.3,12.63 -CompletableOnErrorComplete.java,1.1,12.63 -CompletableOnErrorXTest.java,0.6,12.63 -CompletableOnSubscribe.java,0.4,12.63 -CompletableOperator.java,0.7,12.63 -CompletablePeek.java,1.5,13.14 -CompletablePeekTest.java,1.2,13.14 -CompletableRepeatWhenTest.java,0.8,12.64 -CompletableResumeNext.java,1.8,13.14 -CompletableResumeNextTest.java,0.7,12.64 -CompletableRetryTest.java,1.6,13.14 -CompletableSource.java,0.4,12.64 -CompletableSubject.java,2.7,13.65 -CompletableSubjectTest.java,5.7,15.65 -CompletableSubscribeOn.java,1.2,12.65 -CompletableSubscribeOnTest.java,2.9,13.64 -CompletableSubscribeTest.java,1.7,13.14 -CompletableTakeUntilCompletable.java,1.8,13.15 -CompletableTakeUntilTest.java,9.6,17.65 -CompletableTest.java,109.3,45.04 -CompletableTimeout.java,2.2,13.07 -CompletableTimeoutTest.java,5.9,15.76 -CompletableTimer.java,0.9,12.76 -CompletableTimerTest.java,4.2,15.76 -CompletableToFlowable.java,1.0,13.25 -CompletableToFlowableTest.java,0.6,12.79 -CompletableToObservable.java,1.4,13.25 -CompletableToObservableTest.java,1.6,13.33 -CompletableToSingle.java,1.3,13.25 -CompletableTransformer.java,0.6,12.79 -CompletableUnsafeTest.java,2.5,13.79 -CompletableUsing.java,3.6,14.25 -CompletableUsingTest.java,21.7,32.27 -CompositeDisposable.java,5.3,21.37 -CompositeDisposableTest.java,15.6,19.73 -CompositeException.java,7.6,17.26 -CompositeExceptionTest.java,8.5,17.73 -ComputationScheduler.java,3.3,14.8 -ComputationSchedulerInternalTest.java,0.3,13.27 -ComputationSchedulerTests.java,14.0,23.73 -ConcatArrayEagerTckTest.java,0.8,13.29 -ConcatIterableEagerTckTest.java,0.6,13.29 -ConcatMapIterableTckTest.java,0.6,13.29 -ConcatMapMaybeTckTest.java,0.6,13.29 -ConcatMapSingleTckTest.java,0.6,13.29 -ConcatMapTckTest.java,0.6,13.29 -ConcatPublisherEagerTckTest.java,0.2,13.29 -ConcatPublisherTckTest.java,0.8,13.29 -ConcatTckTest.java,0.5,13.3 -ConcatWithCompletableTckTest.java,0.2,13.3 -ConcatWithMaybeEmptyTckTest.java,0.3,13.3 -ConcatWithMaybeTckTest.java,0.3,13.3 -ConcatWithSingleTckTest.java,0.3,13.3 -ConditionalSubscriber.java,0.3,13.3 -ConnectConsumer.java,0.6,13.3 -ConnectableFlowable.java,2.9,14.31 -ConnectableObservable.java,2.1,13.77 -Consumer.java,0.1,13.3 -ConsumerSingleObserver.java,1.3,13.76 -ConsumerSingleObserverTest.java,3.0,14.76 -ConverterTest.java,5.7,17.77 -CrashingIterable.java,1.1,13.43 -CrashingMappedIterable.java,1.6,14.97 -CreateTckTest.java,0.8,13.48 -DefaultIfEmptyTckTest.java,0.5,13.48 -DefaultObserver.java,0.9,13.49 -DefaultSubscriber.java,0.9,13.49 -DefaultSubscriberTest.java,0.9,13.58 -DeferTckTest.java,0.8,13.49 -DeferredScalarDisposable.java,2.3,14.03 -DeferredScalarObserver.java,0.9,13.49 -DeferredScalarObserverTest.java,25.1,25.5 -DeferredScalarSubscriber.java,1.0,13.49 -DeferredScalarSubscriberTest.java,17.5,23.96 -DeferredScalarSubscription.java,2.1,13.96 -DeferredScalarSubscriptionTest.java,7.3,16.49 -DelaySubscriptionTckTest.java,0.6,13.5 -DelayTckTest.java,0.7,13.5 -Disposable.java,0.5,13.5 -DisposableCompletableObserver.java,1.0,13.5 -DisposableCompletableObserverTest.java,2.3,14.04 -DisposableContainer.java,0.0,13.5 -DisposableHelper.java,2.2,15.96 -DisposableHelperTest.java,4.9,15.04 -DisposableLambdaObserver.java,1.9,14.04 -DisposableLambdaObserverTest.java,4.5,15.58 -DisposableMaybeObserver.java,1.1,13.59 -DisposableMaybeObserverTest.java,4.1,15.59 -DisposableObserver.java,1.2,13.6 -DisposableObserverTest.java,3.7,15.59 -DisposableSingleObserver.java,1.2,13.6 -DisposableSingleObserverTest.java,4.9,15.6 -DisposableSubscriber.java,1.4,13.6 -DisposableSubscriberTest.java,4.7,15.6 -Disposables.java,1.2,14.06 -DisposablesTest.java,3.4,15.6 -DisposeOnCancel.java,0.3,13.6 -DisposeOnCancelTest.java,0.4,13.6 -DistinctTckTest.java,0.4,13.6 -DistinctUntilChangedTckTest.java,0.3,13.6 -DoAfterNextTckTest.java,0.1,13.61 -DoFinallyTckTest.java,0.2,13.61 -DoOnNextTckTest.java,0.4,13.61 -EachTypeFlatMapPerf.java,14.5,19.61 -ElementAtTckTest.java,0.7,13.61 -Emitter.java,0.1,13.61 -EmptyCompletableObserver.java,1.0,13.61 -EmptyCompletableObserverTest.java,0.5,13.61 -EmptyComponent.java,1.3,14.07 -EmptyComponentTest.java,1.7,14.07 -EmptyDisposable.java,1.4,14.07 -EmptyDisposableTest.java,0.9,13.61 -EmptySubscription.java,1.2,14.08 -EmptyTckTest.java,0.5,13.61 -EndConsumerHelper.java,2.1,14.08 -EndConsumerHelperTest.java,18.1,28.63 -ErrorMode.java,0.0,13.61 -ExceptionHelper.java,3.1,15.08 -ExceptionHelperTest.java,1.1,14.08 -Exceptions.java,0.9,13.62 -ExceptionsNullTest.java,1.7,14.08 -ExceptionsTest.java,9.4,22.09 -ExecutorScheduler.java,3.7,16.14 -ExecutorSchedulerDelayedRunnableTest.java,1.5,13.67 -ExecutorSchedulerTest.java,14.9,20.69 -Experimental.java,0.1,13.69 -FailOnBlockingTest.java,5.9,18.16 -FilterTckTest.java,0.5,13.69 -FirstTckTest.java,0.8,13.69 -FixLicenseHeaders.java,4.4,16.15 -FlatMapJustPerf.java,6.2,16.15 -FlatMapTckTest.java,0.4,13.69 -FlattenCrossMapPerf.java,6.0,16.15 -FlattenJustPerf.java,6.1,16.15 -FlattenRangePerf.java,6.0,16.15 -Flowable.java,88.7,69.69 -FlowableAll.java,1.8,14.69 -FlowableAllSingle.java,3.2,15.52 -FlowableAllTest.java,22.4,36 -FlowableAmb.java,5.9,16.55 -FlowableAmbTest.java,37.3,33.03 -FlowableAny.java,1.5,15.17 -FlowableAnySingle.java,1.7,15.67 -FlowableAnyTest.java,45.0,36.45 -FlowableAsObservableTest.java,4.7,17.18 -FlowableAutoConnect.java,0.8,14.68 -FlowableAutoConnectTest.java,1.3,14.68 -FlowableBackpressureTests.java,30.7,46.22 -FlowableBlockingSubscribe.java,4.4,16.7 -FlowableBlockingTest.java,19.3,32.22 -FlowableBuffer.java,7.1,19.21 -FlowableBufferBoundary.java,8.6,20.73 -FlowableBufferBoundarySupplier.java,6.0,19.4 -FlowableBufferExactBoundary.java,4.9,17.93 -FlowableBufferTest.java,124.5,114.11 -FlowableBufferTimed.java,14.5,22.93 -FlowableCache.java,5.6,19.59 -FlowableCacheTest.java,32.0,46.1 -FlowableCastTest.java,4.7,19.21 -FlowableCollect.java,2.0,17.21 -FlowableCollectSingle.java,1.6,17.72 -FlowableCollectTest.java,11.5,28.22 -FlowableCombineLatest.java,6.3,22.39 -FlowableCombineLatestTest.java,94.9,96.08 -FlowableCombineLatestTests.java,5.4,25.32 -FlowableConcatArray.java,3.9,19.56 -FlowableConcatDelayErrorTest.java,16.4,26.57 -FlowableConcatMap.java,15.9,28.08 -FlowableConcatMapCompletable.java,3.3,19.72 -FlowableConcatMapCompletablePerf.java,4.0,21.22 -FlowableConcatMapCompletableTest.java,10.9,27.73 -FlowableConcatMapEager.java,5.1,22.24 -FlowableConcatMapEagerPublisher.java,0.3,17.75 -FlowableConcatMapEagerTest.java,43.4,33.4 -FlowableConcatMapMaybe.java,6.6,20.27 -FlowableConcatMapMaybeEmptyPerf.java,6.6,21.76 -FlowableConcatMapMaybePerf.java,6.3,21.76 -FlowableConcatMapMaybeTest.java,13.5,31.27 -FlowableConcatMapPublisher.java,0.5,17.86 -FlowableConcatMapSingle.java,3.5,20.37 -FlowableConcatMapSinglePerf.java,8.6,21.86 -FlowableConcatMapSingleTest.java,15.4,27.87 -FlowableConcatMapTest.java,4.4,19.36 -FlowableConcatTest.java,65.2,59.26 -FlowableConcatTests.java,16.2,35.08 -FlowableConcatWithCompletable.java,1.6,19.08 -FlowableConcatWithCompletableTest.java,5.0,20.08 -FlowableConcatWithMaybe.java,1.7,19.08 -FlowableConcatWithMaybeTest.java,4.6,20.08 -FlowableConcatWithSingle.java,1.3,19.08 -FlowableConcatWithSingleTest.java,3.4,20.08 -FlowableConversionTest.java,4.2,26.09 -FlowableConverter.java,1.0,19.37 -FlowableCount.java,1.1,18.88 -FlowableCountSingle.java,2.3,19.39 -FlowableCountTest.java,1.5,19.39 -FlowableCovarianceTest.java,17.9,44.9 -FlowableCreate.java,17.4,29.87 -FlowableCreateTest.java,30.8,51.47 -FlowableDebounce.java,3.7,22.11 -FlowableDebounceTest.java,24.0,44.16 -FlowableDebounceTimed.java,5.7,23.19 -FlowableDefaultIfEmptyTest.java,5.2,23.79 -FlowableDefer.java,1.1,19.79 -FlowableDeferTest.java,5.5,23.79 -FlowableDelay.java,1.9,20.29 -FlowableDelaySubscriptionOther.java,2.8,20.79 -FlowableDelaySubscriptionOtherTest.java,18.3,29.3 -FlowableDelayTest.java,38.3,29.66 -FlowableDematerialize.java,1.8,22.23 -FlowableDematerializeTest.java,16.2,30.95 -FlowableDetach.java,2.8,20.95 -FlowableDetachTest.java,7.8,24.45 -FlowableDistinct.java,4.9,21.95 -FlowableDistinctTest.java,6.8,27.96 -FlowableDistinctUntilChanged.java,2.4,21.48 -FlowableDistinctUntilChangedTest.java,21.8,36.98 -FlowableDoAfterNext.java,1.3,20.47 -FlowableDoAfterNextTest.java,10.7,25.48 -FlowableDoAfterTerminateTest.java,3.1,21.98 -FlowableDoFinally.java,5.3,23.03 -FlowableDoFinallyTest.java,18.9,32.06 -FlowableDoOnEach.java,4.2,21.56 -FlowableDoOnEachTest.java,38.5,27.88 -FlowableDoOnLifecycle.java,1.8,20.72 -FlowableDoOnLifecycleTest.java,4.8,22.22 -FlowableDoOnRequestTest.java,1.7,20.7 -FlowableDoOnSubscribeTest.java,7.2,26.72 -FlowableDoOnTest.java,2.0,20.72 -FlowableDoOnUnsubscribeTest.java,17.4,28.73 -FlowableElementAt.java,1.4,20.72 -FlowableElementAtMaybe.java,2.6,21.23 -FlowableElementAtSingle.java,2.2,21.23 -FlowableElementAtTest.java,6.9,25.23 -FlowableEmitter.java,1.0,20.73 -FlowableEmpty.java,0.6,20.24 -FlowableError.java,1.0,20.25 -FlowableErrorHandlingTests.java,6.7,26.76 -FlowableEventStream.java,1.4,21.76 -FlowableEventStreamTest.java,0.6,20.32 -FlowableFilter.java,4.0,21.82 -FlowableFilterTest.java,27.5,43.33 -FlowableFirstTest.java,34.4,58.34 -FlowableFlatMap.java,13.4,52.35 -FlowableFlatMapCompletable.java,5.0,23.33 -FlowableFlatMapCompletableAsyncPerf.java,5.1,24.83 -FlowableFlatMapCompletableCompletable.java,4.7,22.83 -FlowableFlatMapCompletablePerf.java,4.7,24.83 -FlowableFlatMapCompletableSyncPerf.java,4.5,23.83 -FlowableFlatMapCompletableTest.java,20.8,43.35 -FlowableFlatMapMaybe.java,9.1,27.84 -FlowableFlatMapMaybeEmptyPerf.java,6.8,25.33 -FlowableFlatMapMaybePerf.java,5.3,25.33 -FlowableFlatMapMaybeTest.java,20.1,43.35 -FlowableFlatMapPublisher.java,0.4,21.36 -FlowableFlatMapSingle.java,7.0,27.36 -FlowableFlatMapSinglePerf.java,7.2,25.36 -FlowableFlatMapSingleTest.java,18.4,38.37 -FlowableFlatMapTest.java,56.1,51.65 -FlowableFlattenIterable.java,6.9,26.12 -FlowableFlattenIterableTest.java,28.0,46.64 -FlowableForEachTest.java,1.0,21.63 -FlowableFromArray.java,3.2,23.15 -FlowableFromArrayTest.java,6.2,24.65 -FlowableFromCallable.java,1.9,22.15 -FlowableFromCallableTest.java,13.9,30.13 -FlowableFromFuture.java,2.4,22.65 -FlowableFromIterable.java,6.3,24.16 -FlowableFromIterableTest.java,38.3,63.88 -FlowableFromObservable.java,0.9,21.86 -FlowableFromObservableTest.java,0.9,21.86 -FlowableFromPublisher.java,0.6,21.86 -FlowableFromSourceTest.java,15.7,35.87 -FlowableFuseableTest.java,1.5,22.44 -FlowableGenerate.java,2.6,22.94 -FlowableGenerateTest.java,9.5,26.96 -FlowableGroupBy.java,12.8,48.23 -FlowableGroupByTest.java,61.7,41.09 -FlowableGroupByTests.java,2.5,29.72 -FlowableGroupJoin.java,13.7,34.24 -FlowableGroupJoinTest.java,38.2,67.75 -FlowableHide.java,0.9,28.9 -FlowableHideTest.java,5.4,31.4 -FlowableIgnoreElements.java,1.9,29.4 -FlowableIgnoreElementsCompletable.java,1.9,29.4 -FlowableIgnoreElementsTest.java,8.5,34.41 -FlowableInternalHelper.java,7.4,37.41 -FlowableInternalHelperTest.java,0.5,29.24 -FlowableInterval.java,1.7,29.74 -FlowableIntervalRange.java,2.2,29.75 -FlowableIntervalRangeTest.java,2.1,30.25 -FlowableIntervalTest.java,2.0,29.74 -FlowableJoin.java,10.0,33.26 -FlowableJoinTest.java,36.1,67.26 -FlowableJust.java,0.6,29.3 -FlowableLastMaybe.java,2.2,29.8 -FlowableLastSingle.java,2.4,29.8 -FlowableLastTest.java,25.6,49.81 -FlowableLift.java,0.5,29.31 -FlowableLiftTest.java,1.5,29.8 -FlowableLimit.java,1.1,29.81 -FlowableLimitTest.java,8.3,33.31 -FlowableMap.java,3.2,30.81 -FlowableMapNotification.java,2.9,30.31 -FlowableMapNotificationTest.java,10.6,34.32 -FlowableMapPublisher.java,0.5,29.32 -FlowableMapTest.java,25.4,60.34 -FlowableMaterialize.java,1.2,30.65 -FlowableMaterializeTest.java,9.9,37.73 -FlowableMergeDelayErrorTest.java,33.4,59.75 -FlowableMergeMaxConcurrentTest.java,24.1,48.76 -FlowableMergeTest.java,91.5,75.6 -FlowableMergeTests.java,16.7,41.6 -FlowableMergeWithCompletable.java,2.6,31.63 -FlowableMergeWithCompletableTest.java,4.0,32.13 -FlowableMergeWithMaybe.java,11.3,35.14 -FlowableMergeWithMaybeTest.java,24.1,48.64 -FlowableMergeWithSingle.java,8.0,35.25 -FlowableMergeWithSingleTest.java,27.5,46.75 -FlowableNever.java,0.5,30.74 -FlowableNotificationTest.java,2.6,31.74 -FlowableNullTests.java,89.5,82.86 -FlowableObserveOn.java,9.8,35.29 -FlowableObserveOnTest.java,64.5,51.83 -FlowableOnBackpressureBuffer.java,3.8,32.44 -FlowableOnBackpressureBufferStrategy.java,5.8,37.01 -FlowableOnBackpressureBufferStrategyTest.java,5.5,34.32 -FlowableOnBackpressureBufferTest.java,19.1,44.09 -FlowableOnBackpressureDrop.java,1.9,31.58 -FlowableOnBackpressureDropTest.java,9.1,35.59 -FlowableOnBackpressureError.java,1.2,31.09 -FlowableOnBackpressureErrorTest.java,1.0,31.09 -FlowableOnBackpressureLatest.java,2.6,33.09 -FlowableOnBackpressureLatestTest.java,8.7,36.64 -FlowableOnErrorNext.java,3.6,32.65 -FlowableOnErrorResumeNextViaFlowableTest.java,23.3,44.18 -FlowableOnErrorResumeNextViaFunctionTest.java,22.9,44.68 -FlowableOnErrorReturn.java,1.9,31.67 -FlowableOnErrorReturnTest.java,15.1,42.18 -FlowableOnExceptionResumeNextViaFlowableTest.java,21.4,44.18 -FlowableOnSubscribe.java,0.2,31.18 -FlowableOperator.java,0.5,31.18 -FlowableProcessor.java,1.1,31.18 -FlowableProcessorTest.java,2.1,31.68 -FlowablePublish.java,16.3,40.71 -FlowablePublishFunctionTest.java,35.1,47.2 -FlowablePublishMulticast.java,10.1,38.22 -FlowablePublishMulticastTest.java,11.2,38.71 -FlowablePublishTest.java,47.3,84.89 -FlowableRange.java,4.3,32.86 -FlowableRangeLong.java,4.2,32.86 -FlowableRangeLongTest.java,30.1,54.87 -FlowableRangeTest.java,33.5,58.87 -FlowableReduce.java,2.9,32.36 -FlowableReduceMaybe.java,2.8,32.36 -FlowableReduceSeedSingle.java,2.9,32.37 -FlowableReduceTest.java,30.2,55.38 -FlowableReduceTests.java,23.0,42.87 -FlowableReduceWithSingle.java,1.3,31.4 -FlowableReduceWithSingleTest.java,0.6,31.4 -FlowableRefCount.java,4.5,33.41 -FlowableRefCountTest.java,59.7,41.54 -FlowableRepeat.java,4.0,34.16 -FlowableRepeatTest.java,20.3,43.05 -FlowableRepeatUntil.java,2.6,32.55 -FlowableRepeatWhen.java,6.1,35.05 -FlowableReplay.java,23.3,62.11 -FlowableReplayTest.java,87.5,78.68 -FlowableRetryBiPredicate.java,3.3,33.62 -FlowableRetryPredicate.java,3.7,33.62 -FlowableRetryTest.java,43.2,90.65 -FlowableRetryWhen.java,4.9,35.19 -FlowableRetryWithPredicateTest.java,26.8,61.2 -FlowableSamplePublisher.java,3.5,34.72 -FlowableSampleTest.java,22.8,53.24 -FlowableSampleTimed.java,3.7,34.23 -FlowableScalarXMap.java,2.3,34.23 -FlowableScalarXMapTest.java,9.4,38.73 -FlowableScan.java,2.6,33.73 -FlowableScanSeed.java,4.7,35.23 -FlowableScanTest.java,33.7,64.75 -FlowableSequenceEqual.java,6.9,37.89 -FlowableSequenceEqualSingle.java,5.9,35.89 -FlowableSequenceEqualTest.java,39.6,75.9 -FlowableSerializeTest.java,5.9,37.99 -FlowableSerialized.java,0.2,33.48 -FlowableSingle.java,1.6,33.98 -FlowableSingleMaybe.java,2.3,34.48 -FlowableSingleSingle.java,2.8,34.48 -FlowableSingleTest.java,42.4,81 -FlowableSkip.java,1.1,33.54 -FlowableSkipLast.java,1.8,33.54 -FlowableSkipLastTest.java,13.9,41.54 -FlowableSkipLastTimed.java,4.1,34.54 -FlowableSkipLastTimedTest.java,10.2,40.54 -FlowableSkipTest.java,14.6,44.04 -FlowableSkipTimedTest.java,10.4,40.04 -FlowableSkipUntil.java,2.2,34.54 -FlowableSkipUntilTest.java,14.8,41.55 -FlowableSkipWhile.java,2.1,34.04 -FlowableSkipWhileTest.java,13.1,39.05 -FlowableStartWithTests.java,6.2,36.54 -FlowableSubscribeOn.java,3.5,34.55 -FlowableSubscribeOnTest.java,27.1,51.06 -FlowableSubscriber.java,0.4,33.56 -FlowableSubscriberTest.java,29.4,62.58 -FlowableSwitchIfEmpty.java,1.8,34.27 -FlowableSwitchIfEmptyTest.java,14.1,41.78 -FlowableSwitchMap.java,9.2,39.33 -FlowableSwitchMapCompletable.java,4.1,35.37 -FlowableSwitchMapCompletablePerf.java,8.1,37.36 -FlowableSwitchMapCompletableTest.java,13.3,46.37 -FlowableSwitchMapMaybe.java,10.7,38.38 -FlowableSwitchMapMaybeEmptyPerf.java,7.3,37.89 -FlowableSwitchMapMaybePerf.java,7.4,37.89 -FlowableSwitchMapMaybeTest.java,25.8,55.91 -FlowableSwitchMapSingle.java,5.6,37.9 -FlowableSwitchMapSinglePerf.java,6.7,37.9 -FlowableSwitchMapSingleTest.java,30.1,52.91 -FlowableSwitchTest.java,67.1,49.68 -FlowableTake.java,2.3,34.74 -FlowableTakeLast.java,2.3,34.74 -FlowableTakeLastOne.java,1.3,34.24 -FlowableTakeLastOneTest.java,4.9,36.74 -FlowableTakeLastTest.java,23.1,44.25 -FlowableTakeLastTimed.java,5.4,40.25 -FlowableTakeLastTimedTest.java,16.4,44.99 -FlowableTakePublisher.java,0.8,34.48 -FlowableTakeTest.java,23.2,55.5 -FlowableTakeTimedTest.java,9.6,38.99 -FlowableTakeUntil.java,1.9,35.49 -FlowableTakeUntilPredicate.java,2.0,34.99 -FlowableTakeUntilPredicateTest.java,14.0,41.49 -FlowableTakeUntilTest.java,28.4,55.51 -FlowableTakeWhile.java,1.5,35 -FlowableTakeWhileTest.java,25.3,51 -FlowableTests.java,45.8,90.54 -FlowableThrottleFirstTest.java,14.8,43.14 -FlowableThrottleFirstTimed.java,1.5,35.14 -FlowableThrottleLastTests.java,2.5,35.64 -FlowableThrottleLatest.java,4.4,36.15 -FlowableThrottleLatestTest.java,10.1,42.65 -FlowableThrottleWithTimeoutTests.java,2.3,35.64 -FlowableTimeInterval.java,1.8,35.64 -FlowableTimeIntervalTest.java,2.9,35.69 -FlowableTimeout.java,9.3,39.2 -FlowableTimeoutTests.java,29.6,64.71 -FlowableTimeoutTimed.java,7.6,38.2 -FlowableTimeoutWithSelectorTest.java,38.6,78.22 -FlowableTimer.java,1.2,35.02 -FlowableTimerTest.java,18.6,47.02 -FlowableTimestampTest.java,3.7,37.52 -FlowableToCompletableTest.java,6.2,38.02 -FlowableToFutureTest.java,31.2,51.02 -FlowableToList.java,2.1,35.55 -FlowableToListSingle.java,3.3,37.05 -FlowableToListTest.java,37.1,62.1 -FlowableToMapTest.java,17.5,47.6 -FlowableToMultimapTest.java,33.9,51.24 -FlowableToSingleTest.java,13.4,41.87 -FlowableToSortedListTest.java,28.7,51.38 -FlowableTransformer.java,0.7,35.37 -FlowableUnsubscribeOn.java,1.0,35.38 -FlowableUnsubscribeOnTest.java,13.5,42.38 -FlowableUsing.java,3.0,36.38 -FlowableUsingTest.java,26.9,65.4 -FlowableWindow.java,10.1,52.04 -FlowableWindowBoundary.java,4.9,49.49 -FlowableWindowBoundarySelector.java,7.2,55.62 -FlowableWindowBoundarySupplier.java,7.2,45.9 -FlowableWindowTests.java,0.8,38.63 -FlowableWindowTimed.java,20.9,71.16 -FlowableWindowWithFlowableTest.java,63.0,111.93 -FlowableWindowWithSizeTest.java,25.6,55.4 -FlowableWindowWithStartEndFlowableTest.java,29.9,73.02 -FlowableWindowWithTimeTest.java,43.4,92.39 -FlowableWithLatestFrom.java,3.2,41.41 -FlowableWithLatestFromMany.java,4.1,43.92 -FlowableWithLatestFromTest.java,36.7,74.95 -FlowableZip.java,9.3,45.46 -FlowableZipCompletionTest.java,3.0,41.96 -FlowableZipIterable.java,4.8,42.48 -FlowableZipIterableTest.java,27.4,61.99 -FlowableZipTest.java,85.9,68.7 -FlowableZipTests.java,10.5,48.09 -ForEachWhileObserver.java,1.5,41.29 -ForEachWhileSubscriber.java,1.4,41.29 -FromArrayTckTest.java,0.3,40.79 -FromCallableTckTest.java,0.5,40.79 -FromFutureTckTest.java,2.0,41.79 -FromIterableTckTest.java,0.4,40.79 -Function.java,0.1,40.8 -Function3.java,0.3,40.8 -Function4.java,1.0,40.8 -Function5.java,0.6,40.8 -Function6.java,0.8,40.8 -Function7.java,1.2,40.8 -Function8.java,1.2,40.8 -Function9.java,1.1,41.3 -Functions.java,12.3,50.32 -FunctionsTest.java,10.8,46.83 -FuseToFlowable.java,0.1,41.32 -FuseToMaybe.java,0.4,40.84 -FuseToObservable.java,0.2,40.84 -FutureDisposable.java,0.8,40.83 -FutureDisposableTest.java,4.0,42.34 -FutureObserver.java,3.4,41.84 -FutureObserverTest.java,8.2,45.85 -FutureSingleObserver.java,2.2,41.84 -FutureSingleObserverTest.java,5.7,43.84 -FutureSubscriber.java,2.8,41.84 -FutureSubscriberTest.java,4.6,43.35 -GenerateTckTest.java,0.5,40.85 -GroupByTckTest.java,0.5,40.85 -GroupedFlowable.java,0.3,40.85 -GroupedObservable.java,0.4,40.85 -HalfSerializer.java,1.7,41.35 -HalfSerializerObserverTest.java,3.7,42.85 -HalfSerializerSubscriberTest.java,4.9,42.85 -HasUpstreamCompletableSource.java,0.1,40.85 -HasUpstreamMaybeSource.java,0.2,40.85 -HasUpstreamObservableSource.java,0.1,40.85 -HasUpstreamPublisher.java,0.3,40.85 -HasUpstreamSingleSource.java,0.2,40.85 -HashMapSupplier.java,0.6,40.85 -HideTckTest.java,0.1,40.85 -IgnoreElementsTckTest.java,0.3,40.85 -ImmediateThinScheduler.java,2.9,41.86 -ImmediateThinSchedulerTest.java,3.1,41.86 -InnerQueuedObserver.java,2.9,41.86 -InnerQueuedObserverSupport.java,0.2,40.85 -InnerQueuedSubscriber.java,3.5,42.36 -InnerQueuedSubscriberSupport.java,0.3,40.86 -InnerQueuedSubscriberTest.java,4.5,43.35 -InputWithIncrementingInteger.java,2.7,41.87 -InstantPeriodicTask.java,3.0,41.87 -InstantPeriodicTaskTest.java,7.8,44.87 -IntFunction.java,0.6,40.87 -InternalWrongNaming.java,4.8,42.87 -IntervalRangeTckTest.java,0.3,40.87 -IntervalTckTest.java,0.1,40.87 -IoScheduler.java,5.8,43.38 -IsEmptyTckTest.java,0.4,40.87 -JavadocFindUnescapedAngleBrackets.java,4.1,42.37 -JavadocForAnnotations.java,5.0,43.88 -JavadocWording.java,27.5,73.92 -JustAsyncPerf.java,11.0,45.91 -JustTckTest.java,0.4,40.91 -LambdaConsumerIntrospection.java,0.0,40.91 -LambdaObserver.java,2.1,41.41 -LambdaObserverTest.java,32.4,72.41 -LambdaSubscriber.java,2.3,41.41 -LambdaSubscriberTest.java,32.6,70.93 -LastTckTest.java,0.6,40.93 -LatchedSingleObserver.java,0.5,40.93 -LimitTckTest.java,0.5,40.92 -LinkedArrayList.java,1.0,41.43 -ListAddBiConsumer.java,0.6,40.92 -ListCompositeDisposable.java,4.1,44.93 -ListCompositeDisposableTest.java,9.7,45.06 -LongConsumer.java,0.1,41.05 -MapTckTest.java,0.4,41.06 -Maybe.java,29.2,62.77 -MaybeAmb.java,3.2,42.09 -MaybeAmbTest.java,6.6,44.59 -MaybeCache.java,4.3,44.09 -MaybeCacheTest.java,16.7,52.11 -MaybeCallbackObserver.java,1.3,41.61 -MaybeCallbackObserverTest.java,9.8,49.61 -MaybeConcatArray.java,3.5,42.61 -MaybeConcatArrayDelayError.java,3.5,43.11 -MaybeConcatArrayTest.java,7.8,47.12 -MaybeConcatIterable.java,4.6,43.62 -MaybeConcatIterableTest.java,7.1,45.12 -MaybeConcatPublisherTest.java,0.8,41.12 -MaybeContains.java,2.0,41.62 -MaybeContainsTest.java,3.4,43.12 -MaybeConverter.java,0.2,41.12 -MaybeCount.java,2.2,41.64 -MaybeCountTest.java,4.2,42.66 -MaybeCreate.java,2.5,42.66 -MaybeCreateTest.java,4.9,44.16 -MaybeDefer.java,1.1,41.17 -MaybeDelay.java,1.6,41.98 -MaybeDelayOtherPublisher.java,2.0,42.17 -MaybeDelayOtherTest.java,16.9,52.17 -MaybeDelaySubscriptionOtherPublisher.java,3.7,42.67 -MaybeDelaySubscriptionTest.java,5.4,45.67 -MaybeDelayTest.java,8.5,44.17 -MaybeDelayWithCompletable.java,1.6,41.67 -MaybeDetach.java,1.9,41.67 -MaybeDetachTest.java,9.1,48.67 -MaybeDoAfterSuccess.java,1.6,41.18 -MaybeDoAfterSuccessTest.java,2.6,42.68 -MaybeDoFinally.java,1.7,41.18 -MaybeDoFinallyTest.java,4.5,43.18 -MaybeDoOnEvent.java,1.9,41.67 -MaybeDoOnEventTest.java,2.1,41.68 -MaybeEmitter.java,0.8,41.19 -MaybeEmpty.java,0.5,41.18 -MaybeEmptyTest.java,1.1,41.19 -MaybeEqualSingle.java,4.4,43.18 -MaybeEqualTest.java,1.0,41.19 -MaybeError.java,0.4,41.19 -MaybeErrorCallable.java,0.9,41.19 -MaybeErrorTest.java,0.8,41.19 -MaybeFilter.java,1.5,41.69 -MaybeFilterSingle.java,2.2,41.69 -MaybeFilterSingleTest.java,0.5,41.19 -MaybeFlatMapBiSelector.java,2.8,42.7 -MaybeFlatMapBiSelectorTest.java,3.2,42.7 -MaybeFlatMapCompletable.java,2.6,42.2 -MaybeFlatMapCompletableTest.java,0.8,41.2 -MaybeFlatMapIterableFlowable.java,4.2,43.2 -MaybeFlatMapIterableFlowableTest.java,10.6,48.24 -MaybeFlatMapIterableObservable.java,2.7,42.71 -MaybeFlatMapIterableObservableTest.java,5.5,44.7 -MaybeFlatMapNotification.java,3.9,42.71 -MaybeFlatMapNotificationTest.java,6.4,44.71 -MaybeFlatMapObservable.java,2.1,41.73 -MaybeFlatMapObservableTest.java,4.4,44.23 -MaybeFlatMapPublisher.java,2.2,41.73 -MaybeFlatMapPublisherTckTest.java,0.6,41.23 -MaybeFlatMapPublisherTest.java,5.8,44.23 -MaybeFlatMapSingle.java,1.5,42.23 -MaybeFlatMapSingleElement.java,2.4,41.73 -MaybeFlatMapSingleElementTest.java,3.2,42.23 -MaybeFlatMapSingleTest.java,2.7,42.23 -MaybeFlatten.java,2.3,42.23 -MaybeFlattenTest.java,2.2,41.73 -MaybeFromAction.java,1.3,41.23 -MaybeFromActionTest.java,10.2,46.74 -MaybeFromCallable.java,1.6,41.73 -MaybeFromCallableTest.java,12.6,49.74 -MaybeFromCompletable.java,1.6,41.74 -MaybeFromCompletableTest.java,1.8,41.74 -MaybeFromFuture.java,1.5,41.74 -MaybeFromFutureTest.java,13.0,47.24 -MaybeFromRunnable.java,1.0,41.24 -MaybeFromRunnableTest.java,8.6,46.74 -MaybeFromSingle.java,2.0,41.77 -MaybeFromSingleTest.java,2.5,42.27 -MaybeHide.java,1.2,41.77 -MaybeHideTest.java,2.3,41.77 -MaybeIgnoreElement.java,2.1,41.78 -MaybeIgnoreElementCompletable.java,2.2,41.78 -MaybeIgnoreElementTest.java,2.6,42.28 -MaybeIsEmpty.java,1.2,41.28 -MaybeIsEmptySingle.java,1.8,41.78 -MaybeIsEmptySingleTest.java,1.6,41.78 -MaybeIsEmptyTest.java,4.1,42.78 -MaybeJust.java,0.6,41.28 -MaybeJustTest.java,1.3,41.78 -MaybeLift.java,0.9,41.28 -MaybeMap.java,1.8,41.78 -MaybeMapTest.java,0.6,41.28 -MaybeMergeArray.java,6.8,45.8 -MaybeMergeArrayTest.java,9.4,46.79 -MaybeMergeTest.java,5.1,45.79 -MaybeMergeWithTest.java,0.3,41.29 -MaybeNever.java,0.7,41.29 -MaybeNo2Dot0Since.java,1.8,41.79 -MaybeObserveOn.java,1.6,41.79 -MaybeObserver.java,0.6,41.3 -MaybeOfTypeTest.java,5.6,44.79 -MaybeOnErrorComplete.java,1.3,41.8 -MaybeOnErrorNext.java,2.2,42.3 -MaybeOnErrorReturn.java,1.4,41.8 -MaybeOnErrorXTest.java,5.1,42.8 -MaybeOnSubscribe.java,0.4,41.3 -MaybeOperator.java,0.8,41.3 -MaybePeek.java,2.8,42.3 -MaybePeekTest.java,12.3,49.8 -MaybeRetryTest.java,1.4,41.8 -MaybeSource.java,0.3,41.3 -MaybeSubject.java,6.0,43.81 -MaybeSubjectTest.java,11.3,47.31 -MaybeSubscribeOn.java,2.2,41.8 -MaybeSubscribeOnTest.java,0.5,41.31 -MaybeSwitchIfEmpty.java,1.8,41.81 -MaybeSwitchIfEmptySingle.java,2.0,41.81 -MaybeSwitchIfEmptySingleTest.java,4.1,43.81 -MaybeSwitchIfEmptyTest.java,5.2,43.79 -MaybeTakeUntilMaybe.java,2.7,42.31 -MaybeTakeUntilPublisher.java,2.6,42.31 -MaybeTakeUntilPublisherTest.java,13.7,49.81 -MaybeTakeUntilTest.java,31.3,70.32 -MaybeTest.java,87.9,69.69 -MaybeTimeoutMaybe.java,4.0,42.87 -MaybeTimeoutPublisher.java,3.7,42.87 -MaybeTimeoutPublisherTest.java,22.6,54.37 -MaybeTimeoutTest.java,20.3,56.37 -MaybeTimer.java,1.1,41.36 -MaybeTimerTest.java,5.1,43.37 -MaybeToCompletableTest.java,1.8,41.87 -MaybeToFlowable.java,1.2,41.37 -MaybeToFlowableTest.java,1.9,41.87 -MaybeToObservable.java,1.3,41.37 -MaybeToObservableTest.java,1.7,41.87 -MaybeToPublisher.java,0.7,41.37 -MaybeToSingle.java,2.1,41.87 -MaybeToSingleTest.java,2.1,42.37 -MaybeTransformer.java,1.1,41.37 -MaybeUnsafeCreate.java,0.5,41.37 -MaybeUnsubscribeOn.java,1.4,41.87 -MaybeUnsubscribeOnTest.java,4.4,43.38 -MaybeUsing.java,3.6,42.88 -MaybeUsingTest.java,25.7,58.89 -MaybeZipArray.java,3.0,42.38 -MaybeZipArrayTest.java,7.4,46.38 -MaybeZipIterable.java,2.5,42.38 -MaybeZipIterableTest.java,9.6,47.39 -MemoryPerf.java,8.8,46.4 -MergeIterableTckTest.java,0.2,41.38 -MergePublisherTckTest.java,0.9,41.38 -MergeTckTest.java,0.5,41.39 -MergeWithCompletableTckTest.java,0.5,41.38 -MergeWithMaybeEmptyTckTest.java,0.5,41.39 -MergeWithMaybeTckTest.java,0.3,41.39 -MergeWithSingleTckTest.java,0.5,41.39 -MergerBiFunction.java,4.1,43.39 -MergerBiFunctionTest.java,13.1,52.38 -MiscUtilTest.java,8.5,46.44 -MissingBackpressureException.java,0.2,41.44 -MpscLinkedQueue.java,3.5,42.94 -MulticastProcessor.java,11.0,50.46 -MulticastProcessorAsPublisherTckTest.java,1.6,41.61 -MulticastProcessorRefCountedTckTest.java,2.2,42.61 -MulticastProcessorTckTest.java,2.3,42.61 -MulticastProcessorTest.java,30.4,71.13 -NewLinesBeforeAnnotation.java,4.8,44.1 -NewThreadScheduler.java,0.4,41.61 -NewThreadSchedulerTest.java,1.8,42.12 -NewThreadWorker.java,6.1,44.62 -NoAnonymousInnerClassesTest.java,3.7,42.62 -NonBlockingThread.java,0.0,41.61 -NonNull.java,0.5,42.11 -Notification.java,2.2,42.63 -NotificationLite.java,2.9,42.63 -NotificationLiteTest.java,1.3,42.13 -NotificationTest.java,4.0,44.63 -Nullable.java,0.6,41.63 -ObjectHelper.java,0.4,41.63 -ObjectHelperTest.java,2.6,42.63 -Observable.java,59.6,108.11 -ObservableAll.java,1.7,42.23 -ObservableAllSingle.java,1.3,42.22 -ObservableAllTest.java,24.3,60.74 -ObservableAmb.java,3.2,43.24 -ObservableAmbTest.java,26.6,59.74 -ObservableAny.java,1.5,42.23 -ObservableAnySingle.java,1.7,42.23 -ObservableAnyTest.java,41.0,89.24 -ObservableAutoConnect.java,0.4,41.74 -ObservableAutoConnectTest.java,0.9,41.73 -ObservableBlockingSubscribe.java,2.7,43.24 -ObservableBlockingTest.java,12.7,48.24 -ObservableBuffer.java,3.7,44.24 -ObservableBufferBoundary.java,6.6,45.25 -ObservableBufferBoundarySupplier.java,4.8,44.25 -ObservableBufferExactBoundary.java,3.5,43.24 -ObservableBufferTest.java,94.2,78.51 -ObservableBufferTimed.java,10.1,47.79 -ObservableBufferUntilSubscriberTest.java,2.4,42.78 -ObservableCache.java,4.8,44.29 -ObservableCacheTest.java,27.5,67.28 -ObservableCastTest.java,3.9,43.28 -ObservableCollect.java,1.8,42.28 -ObservableCollectSingle.java,1.4,42.29 -ObservableCollectTest.java,15.1,50.79 -ObservableCombineLatest.java,4.7,44.29 -ObservableCombineLatestTest.java,77.4,55.6 -ObservableCombineLatestTests.java,5.3,45.25 -ObservableConcatMap.java,10.1,46.8 -ObservableConcatMapCompletable.java,6.0,44.29 -ObservableConcatMapCompletablePerf.java,6.9,45.29 -ObservableConcatMapCompletableTest.java,16.5,52.3 -ObservableConcatMapEager.java,10.0,47.3 -ObservableConcatMapEagerTest.java,37.4,79.32 -ObservableConcatMapMaybe.java,5.1,44.3 -ObservableConcatMapMaybeEmptyPerf.java,8.4,45.79 -ObservableConcatMapMaybePerf.java,6.6,45.79 -ObservableConcatMapMaybeTest.java,20.3,54.8 -ObservableConcatMapSingle.java,5.6,44.3 -ObservableConcatMapSinglePerf.java,5.8,45.8 -ObservableConcatMapSingleTest.java,26.7,54.31 -ObservableConcatMapTest.java,28.3,57.81 -ObservableConcatTest.java,43.4,91.84 -ObservableConcatTests.java,24.1,58.31 -ObservableConcatWithCompletable.java,1.5,41.81 -ObservableConcatWithCompletableTest.java,3.1,43.31 -ObservableConcatWithMaybe.java,1.4,42.31 -ObservableConcatWithMaybeTest.java,3.5,43.81 -ObservableConcatWithSingle.java,1.0,42.31 -ObservableConcatWithSingleTest.java,3.6,43.31 -ObservableConverter.java,0.6,41.81 -ObservableCount.java,1.3,41.81 -ObservableCountSingle.java,1.8,42.3 -ObservableCountTest.java,1.0,41.81 -ObservableCovarianceTest.java,23.9,58.32 -ObservableCreate.java,4.3,44.32 -ObservableCreateTest.java,24.3,60.33 -ObservableDebounce.java,3.4,43.32 -ObservableDebounceTest.java,28.4,65.33 -ObservableDebounceTimed.java,3.7,43.32 -ObservableDefaultIfEmptyTest.java,7.3,44.82 -ObservableDefer.java,1.2,41.81 -ObservableDeferTest.java,9.4,45.82 -ObservableDelay.java,2.7,42.82 -ObservableDelaySubscriptionOther.java,2.3,42.32 -ObservableDelaySubscriptionOtherTest.java,7.5,46.82 -ObservableDelayTest.java,38.2,80.9 -ObservableDematerialize.java,1.4,42.32 -ObservableDematerializeTest.java,19.3,52.82 -ObservableDetach.java,2.4,42.82 -ObservableDetachTest.java,6.0,45.32 -ObservableDistinct.java,3.3,43.32 -ObservableDistinctTest.java,13.9,49.33 -ObservableDistinctUntilChanged.java,2.0,42.33 -ObservableDistinctUntilChangedTest.java,13.9,53.33 -ObservableDoAfterNext.java,0.9,41.83 -ObservableDoAfterNextTest.java,7.6,47.33 -ObservableDoFinally.java,3.3,42.83 -ObservableDoFinallyTest.java,15.4,53.84 -ObservableDoOnEach.java,1.7,42.33 -ObservableDoOnEachTest.java,24.1,62.85 -ObservableDoOnLifecycle.java,0.5,41.83 -ObservableDoOnSubscribeTest.java,9.0,48.83 -ObservableDoOnTest.java,1.8,42.33 -ObservableDoOnUnsubscribeTest.java,14.6,50.34 -ObservableElementAt.java,2.0,42.33 -ObservableElementAtMaybe.java,1.9,42.34 -ObservableElementAtSingle.java,1.5,42.34 -ObservableElementAtTest.java,8.9,45.84 -ObservableEmitter.java,1.1,41.84 -ObservableEmpty.java,0.3,41.84 -ObservableError.java,0.7,41.84 -ObservableErrorHandlingTests.java,9.6,48.34 -ObservableEventStream.java,1.2,42.16 -ObservableFilter.java,1.3,42.34 -ObservableFilterTest.java,9.5,46.84 -ObservableFinallyTest.java,0.9,41.84 -ObservableFirstTest.java,35.2,79.86 -ObservableFlatMap.java,14.7,49.85 -ObservableFlatMapCompletable.java,3.5,43.35 -ObservableFlatMapCompletableCompletable.java,3.7,43.35 -ObservableFlatMapCompletablePerf.java,7.9,45.35 -ObservableFlatMapCompletableTest.java,31.4,62.36 -ObservableFlatMapMaybe.java,5.3,46.86 -ObservableFlatMapMaybeEmptyPerf.java,4.4,45.85 -ObservableFlatMapMaybePerf.java,7.3,45.85 -ObservableFlatMapMaybeTest.java,23.3,60.36 -ObservableFlatMapPerf.java,2.1,43.35 -ObservableFlatMapSingle.java,7.3,45.86 -ObservableFlatMapSinglePerf.java,9.3,45.85 -ObservableFlatMapSingleTest.java,20.2,55.86 -ObservableFlatMapTest.java,53.6,105.88 -ObservableFlattenIterable.java,3.9,43.36 -ObservableFlattenIterableTest.java,1.1,42.36 -ObservableForEachTest.java,5.6,44.87 -ObservableFromArray.java,2.6,42.86 -ObservableFromCallable.java,1.7,42.86 -ObservableFromCallableTest.java,13.1,50.87 -ObservableFromFuture.java,3.0,43.37 -ObservableFromIterable.java,4.0,43.37 -ObservableFromIterableTest.java,17.1,58.37 -ObservableFromPublisher.java,1.7,42.37 -ObservableFromTest.java,2.3,42.87 -ObservableFromUnsafeSource.java,0.2,41.87 -ObservableFuseableTest.java,1.7,42.37 -ObservableGenerate.java,2.6,42.87 -ObservableGenerateTest.java,4.5,43.88 -ObservableGroupBy.java,5.4,48.22 -ObservableGroupByTest.java,42.2,84 -ObservableGroupByTests.java,1.8,42.45 -ObservableGroupJoin.java,10.1,46.96 -ObservableGroupJoinTest.java,34.2,77.47 -ObservableHide.java,0.9,41.95 -ObservableHideTest.java,5.8,44.45 -ObservableIgnoreElements.java,1.0,41.95 -ObservableIgnoreElementsCompletable.java,1.2,41.95 -ObservableIgnoreElementsTest.java,8.3,45.46 -ObservableInternalHelper.java,5.7,44.96 -ObservableInternalHelperTest.java,0.6,41.96 -ObservableInterval.java,1.6,42.46 -ObservableIntervalRange.java,1.5,42.46 -ObservableIntervalRangeTest.java,2.1,42.46 -ObservableIntervalTest.java,1.4,42.46 -ObservableJoin.java,6.5,45.97 -ObservableJoinTest.java,31.9,73.47 -ObservableJust.java,1.4,42.47 -ObservableLastMaybe.java,2.0,42.48 -ObservableLastSingle.java,2.0,42.48 -ObservableLastTest.java,27.9,62.49 -ObservableLift.java,1.4,42.48 -ObservableLiftTest.java,0.9,41.98 -ObservableMap.java,1.6,42.48 -ObservableMapNotification.java,3.1,43.48 -ObservableMapNotificationTest.java,5.0,44.98 -ObservableMapTest.java,21.3,60.99 -ObservableMaterialize.java,2.4,42.98 -ObservableMaterializeTest.java,6.2,45.49 -ObservableMergeDelayErrorTest.java,23.5,63 -ObservableMergeMaxConcurrentTest.java,21.8,58.49 -ObservableMergeTest.java,64.8,119.51 -ObservableMergeTests.java,19.1,52.61 -ObservableMergeWithCompletable.java,2.1,43.1 -ObservableMergeWithCompletableTest.java,4.6,43.61 -ObservableMergeWithMaybe.java,4.9,44.6 -ObservableMergeWithMaybeTest.java,12.2,52.62 -ObservableMergeWithSingle.java,6.6,44.6 -ObservableMergeWithSingleTest.java,15.0,52.62 -ObservableMulticastTest.java,0.1,42.11 -ObservableNever.java,0.5,42.11 -ObservableNullTests.java,77.6,63.84 -ObservableObserveOn.java,4.4,44.12 -ObservableObserveOnTest.java,32.3,71.14 -ObservableOnErrorNext.java,1.8,43.12 -ObservableOnErrorResumeNextViaFunctionTest.java,20.6,54.63 -ObservableOnErrorResumeNextViaObservableTest.java,24.8,54.12 -ObservableOnErrorReturn.java,1.4,42.62 -ObservableOnErrorReturnTest.java,14.5,52.12 -ObservableOnExceptionResumeNextViaObservableTest.java,18.6,54.12 -ObservableOnSubscribe.java,0.3,42.12 -ObservableOperator.java,0.7,42.12 -ObservablePublish.java,7.8,47.63 -ObservablePublishSelector.java,3.1,43.64 -ObservablePublishTest.java,36.0,75.68 -ObservableQueueDrain.java,0.2,42.16 -ObservableRange.java,2.2,42.66 -ObservableRangeLong.java,1.9,42.66 -ObservableRangeLongTest.java,9.8,47.65 -ObservableRangeTest.java,10.5,46.66 -ObservableRedoTest.java,1.0,42.16 -ObservableReduceMaybe.java,2.7,43.16 -ObservableReduceSeedSingle.java,1.9,43.16 -ObservableReduceTest.java,30.9,62.17 -ObservableReduceTests.java,22.1,53.16 -ObservableReduceWithSingle.java,1.0,42.17 -ObservableRefCount.java,4.0,44.17 -ObservableRefCountTest.java,51.8,103.69 -ObservableRepeat.java,3.6,43.73 -ObservableRepeatTest.java,18.3,52.24 -ObservableRepeatUntil.java,2.9,43.24 -ObservableRepeatWhen.java,4.7,44.24 -ObservableReplay.java,25.2,58.27 -ObservableReplayTest.java,73.7,53.35 -ObservableResourceWrapperTest.java,4.6,44.43 -ObservableRetryBiPredicate.java,2.1,43.44 -ObservableRetryPredicate.java,3.2,43.44 -ObservableRetryTest.java,41.9,87.97 -ObservableRetryWhen.java,5.1,44.49 -ObservableRetryWithPredicateTest.java,34.8,68 -ObservableSampleTest.java,28.6,62.5 -ObservableSampleTimed.java,3.0,43.5 -ObservableSampleWithObservable.java,3.5,43.98 -ObservableScalarXMap.java,5.2,45 -ObservableScalarXMapTest.java,12.0,47.5 -ObservableScan.java,2.5,43 -ObservableScanSeed.java,3.4,43.5 -ObservableScanTest.java,21.8,57.01 -ObservableScanTests.java,0.9,42.5 -ObservableSequenceEqual.java,4.3,44.5 -ObservableSequenceEqualSingle.java,4.9,44.51 -ObservableSequenceEqualTest.java,34.2,75.01 -ObservableSerializeTest.java,9.5,47.01 -ObservableSerialized.java,0.3,42.5 -ObservableSingleMaybe.java,1.4,43 -ObservableSingleSingle.java,1.5,43 -ObservableSingleTest.java,38.9,83.52 -ObservableSkip.java,2.0,42.51 -ObservableSkipLast.java,1.3,42.51 -ObservableSkipLastTest.java,13.7,50.51 -ObservableSkipLastTimed.java,2.6,43.51 -ObservableSkipLastTimedTest.java,9.3,49.51 -ObservableSkipTest.java,15.8,52.51 -ObservableSkipTimedTest.java,11.8,49.01 -ObservableSkipUntil.java,1.5,43.01 -ObservableSkipUntilTest.java,10.3,50.51 -ObservableSkipWhile.java,1.5,43.01 -ObservableSkipWhileTest.java,9.7,48.01 -ObservableSource.java,0.3,42.51 -ObservableStartWithTests.java,5.1,45.51 -ObservableSubscribeOn.java,1.2,43.01 -ObservableSubscribeOnTest.java,4.5,46.02 -ObservableSubscriberTest.java,5.7,45.52 -ObservableSwitchIfEmpty.java,1.5,43.02 -ObservableSwitchIfEmptyTest.java,3.9,44.52 -ObservableSwitchMap.java,7.0,46.03 -ObservableSwitchMapCompletable.java,3.7,44.52 -ObservableSwitchMapCompletablePerf.java,8.5,46.02 -ObservableSwitchMapCompletableTest.java,24.6,57.03 -ObservableSwitchMapMaybe.java,9.4,46.53 -ObservableSwitchMapMaybeEmptyPerf.java,7.0,46.52 -ObservableSwitchMapMaybePerf.java,8.4,46.52 -ObservableSwitchMapMaybeTest.java,29.6,66.54 -ObservableSwitchMapSingle.java,7.8,46.53 -ObservableSwitchMapSinglePerf.java,5.7,46.52 -ObservableSwitchMapSingleTest.java,28.0,66.04 -ObservableSwitchTest.java,62.5,115.06 -ObservableTake.java,1.7,43.13 -ObservableTakeLast.java,1.7,42.64 -ObservableTakeLastOne.java,1.6,42.64 -ObservableTakeLastOneTest.java,4.1,44.14 -ObservableTakeLastTest.java,15.1,51.14 -ObservableTakeLastTimed.java,4.1,44.14 -ObservableTakeLastTimedTest.java,13.9,51.64 -ObservableTakeTest.java,26.0,61.15 -ObservableTakeTimedTest.java,8.3,47.14 -ObservableTakeUntil.java,2.0,43.14 -ObservableTakeUntilPredicate.java,1.7,43.14 -ObservableTakeUntilPredicateTest.java,10.8,51.15 -ObservableTakeUntilTest.java,25.1,62.79 -ObservableTakeWhile.java,1.7,43.27 -ObservableTakeWhileTest.java,27.8,57.29 -ObservableTest.java,47.6,98.82 -ObservableThrottleFirstTest.java,12.7,51.31 -ObservableThrottleFirstTimed.java,2.1,43.3 -ObservableThrottleLastTests.java,2.5,43.8 -ObservableThrottleLatest.java,3.7,43.81 -ObservableThrottleLatestTest.java,11.0,47.81 -ObservableThrottleWithTimeoutTests.java,2.3,43.81 -ObservableTimeInterval.java,1.5,43.31 -ObservableTimeIntervalTest.java,3.1,43.81 -ObservableTimeout.java,9.6,47.32 -ObservableTimeoutTests.java,33.3,72.83 -ObservableTimeoutTimed.java,6.5,46.31 -ObservableTimeoutWithSelectorTest.java,37.0,80.83 -ObservableTimer.java,1.5,42.83 -ObservableTimerTest.java,20.4,54.83 -ObservableTimestampTest.java,5.0,45.33 -ObservableToFlowabeTestSync.java,5.9,45.83 -ObservableToFutureTest.java,15.6,52.33 -ObservableToList.java,2.2,43.33 -ObservableToListSingle.java,2.7,43.83 -ObservableToListTest.java,28.3,62.84 -ObservableToMapTest.java,16.7,52.34 -ObservableToMultimapTest.java,26.1,56.35 -ObservableToSortedListTest.java,23.4,53.33 -ObservableToXTest.java,3.9,44.33 -ObservableTransformer.java,0.8,42.83 -ObservableUnsubscribeOn.java,1.4,43.33 -ObservableUnsubscribeOnTest.java,11.6,49.84 -ObservableUsing.java,3.1,43.83 -ObservableUsingTest.java,23.1,68.85 -ObservableWindow.java,5.5,48.84 -ObservableWindowBoundary.java,4.9,44.98 -ObservableWindowBoundarySelector.java,5.2,45.48 -ObservableWindowBoundarySupplier.java,6.2,45.99 -ObservableWindowTests.java,0.5,42.98 -ObservableWindowTimed.java,13.5,54.51 -ObservableWindowWithObservableTest.java,59.9,113.19 -ObservableWindowWithSizeTest.java,23.2,55.16 -ObservableWindowWithStartEndObservableTest.java,32.7,70.66 -ObservableWindowWithTimeTest.java,35.6,79.67 -ObservableWithLatestFrom.java,2.6,44.15 -ObservableWithLatestFromMany.java,4.7,46.16 -ObservableWithLatestFromTest.java,34.4,69.67 -ObservableZip.java,4.5,45.16 -ObservableZipCompletionTest.java,2.2,44.16 -ObservableZipIterable.java,3.8,45.16 -ObservableZipIterableTest.java,28.7,64.17 -ObservableZipTest.java,58.2,111.2 -ObservableZipTests.java,6.9,47.68 -ObserveOnTckTest.java,0.7,43.18 -Observer.java,0.7,43.18 -ObserverFusion.java,3.2,44.18 -ObserverResourceWrapper.java,1.1,43.18 -OnBackpressureBufferTckTest.java,0.3,43.18 -OnErrorNotImplementedException.java,0.5,43.18 -OnErrorNotImplementedExceptionTest.java,3.1,44.18 -OnErrorResumeNextTckTest.java,0.3,43.18 -OnErrorReturnItemTckTest.java,0.4,43.18 -OnNextValueTest.java,3.8,45.18 -OpenHashSet.java,5.1,45.68 -OpenHashSetTest.java,1.5,43.7 -OperatorFlatMapPerf.java,1.8,43.7 -OperatorMergePerf.java,19.6,51.7 -OperatorsAreFinal.java,3.2,44.7 -ParallelCollect.java,2.3,44.21 -ParallelCollectTest.java,8.6,47.21 -ParallelConcatMap.java,2.4,44.21 -ParallelDoOnNextTry.java,15.1,51.21 -ParallelDoOnNextTryTest.java,19.3,53.23 -ParallelFailureHandling.java,0.3,43.23 -ParallelFilter.java,3.4,44.23 -ParallelFilterTest.java,4.1,44.73 -ParallelFilterTry.java,15.5,51.23 -ParallelFilterTryTest.java,15.8,52.24 -ParallelFlatMap.java,1.9,43.73 -ParallelFlowable.java,23.4,54.27 -ParallelFlowableConverter.java,0.8,43.31 -ParallelFlowableTest.java,42.9,91.85 -ParallelFromArray.java,0.8,43.32 -ParallelFromPublisher.java,8.9,47.32 -ParallelFromPublisherTest.java,3.7,45.32 -ParallelInvalid.java,0.6,43.33 -ParallelJoin.java,18.7,53.85 -ParallelJoinTest.java,18.1,54.86 -ParallelMap.java,3.9,45.36 -ParallelMapTest.java,3.8,45.36 -ParallelMapTry.java,11.2,51.86 -ParallelMapTryTest.java,12.6,51.86 -ParallelPeek.java,3.7,45.86 -ParallelPeekTest.java,5.3,46.36 -ParallelPerf.java,9.0,48.36 -ParallelReduce.java,3.9,44.36 -ParallelReduceFull.java,7.3,48.86 -ParallelReduceFullTest.java,7.8,47.44 -ParallelReduceTest.java,8.3,47.95 -ParallelRunOn.java,9.3,46.95 -ParallelRunOnTest.java,11.0,49.45 -ParallelSortedJoin.java,6.0,46.45 -ParallelSortedJoinTest.java,8.2,48.95 -ParallelTransformer.java,0.7,43.45 -ParamValidationCheckerTest.java,27.4,61.01 -PerfAsyncConsumer.java,1.0,43.47 -PerfBoundedSubscriber.java,0.7,43.47 -PerfConsumer.java,0.9,43.47 -PerfInteropConsumer.java,0.9,43.47 -PerfObserver.java,0.7,43.47 -PerfSubscriber.java,1.0,43.47 -Pow2.java,0.7,43.48 -Predicate.java,0.1,43.48 -ProtocolViolationException.java,0.1,43.48 -PublicFinalMethods.java,1.2,43.47 -PublishProcessor.java,6.8,46.49 -PublishProcessorAsPublisherTckTest.java,1.3,43.47 -PublishProcessorPerf.java,3.2,44.48 -PublishProcessorTest.java,36.9,67 -PublishSelectorTckTest.java,0.6,43.49 -PublishSubject.java,5.7,45.5 -PublishSubjectTest.java,24.9,65.51 -PublishTckTest.java,0.4,43.49 -QueueDisposable.java,0.1,43.49 -QueueDrain.java,0.7,43.49 -QueueDrainHelper.java,5.4,58.5 -QueueDrainHelperTest.java,21.2,63.68 -QueueDrainObserver.java,2.8,45.17 -QueueDrainObserverTest.java,6.6,47.17 -QueueDrainSubscriber.java,2.6,45.18 -QueueDrainSubscriberTest.java,12.7,51.18 -QueueFuseable.java,0.2,44.18 -QueueSubscription.java,0.4,44.18 -QueueSubscriptionTest.java,2.2,44.68 -RangePerf.java,3.0,45.68 -RangeTckTest.java,0.3,44.17 -RebatchRequestsTckTest.java,0.4,44.18 -ReducePerf.java,2.8,45.67 -ReduceTckTest.java,0.7,44.18 -ReduceWithTckTest.java,0.7,44.18 -RefCountProcessor.java,5.1,46.69 -ReferenceDisposable.java,1.0,44.2 -RepeatTckTest.java,0.2,44.2 -ReplayProcessor.java,37.0,99.74 -ReplayProcessorBoundedConcurrencyTest.java,25.5,59.57 -ReplayProcessorConcurrencyTest.java,14.4,56.13 -ReplayProcessorSizeBoundAsPublisherTckTest.java,1.0,45.62 -ReplayProcessorTest.java,54.6,109.17 -ReplayProcessorTimeBoundAsPublisherTckTest.java,0.9,45.72 -ReplayProcessorUnboundedAsPublisherTckTest.java,0.9,45.72 -ReplaySelectorTckTest.java,1.0,45.72 -ReplaySubject.java,31.8,83.76 -ReplaySubjectBoundedConcurrencyTest.java,22.9,59.21 -ReplaySubjectConcurrencyTest.java,18.3,56.71 -ReplaySubjectTest.java,43.1,95.23 -ReplayTckTest.java,0.5,46.2 -ResettableConnectable.java,0.3,46.2 -ResourceCompletableObserver.java,1.2,46.21 -ResourceCompletableObserverTest.java,3.4,47.7 -ResourceMaybeObserver.java,0.9,46.21 -ResourceMaybeObserverTest.java,12.4,51.21 -ResourceObserver.java,1.0,46.21 -ResourceObserverTest.java,8.4,50.71 -ResourceSingleObserver.java,1.0,46.21 -ResourceSingleObserverTest.java,7.9,50.21 -ResourceSubscriber.java,1.0,46.21 -ResourceSubscriberTest.java,9.7,51.21 -ResumeSingleObserver.java,0.6,46.21 -Retry.java,1.7,46.71 -RetryTckTest.java,0.5,46.21 -RunnableDisposable.java,0.6,46.21 -RxJavaPlugins.java,16.4,56.76 -RxJavaPluginsTest.java,37.9,64.39 -RxThreadFactory.java,1.0,46.33 -RxThreadFactoryTest.java,0.4,46.33 -RxVsStreamPerf.java,9.0,51.33 -SafeObserver.java,2.6,46.84 -SafeObserverTest.java,38.5,83.36 -SafeSubscriber.java,1.9,46.92 -SafeSubscriberTest.java,39.4,89.45 -SafeSubscriberWithPluginTest.java,24.3,62.44 -ScalarCallable.java,0.7,46.43 -ScalarSubscription.java,1.1,46.93 -ScalarSubscriptionTest.java,3.5,48.43 -ScalarXMapZHelper.java,3.2,47.94 -ScalarXMapZHelperTest.java,0.3,46.44 -ScanTckTest.java,0.5,46.44 -ScheduledDirectPeriodicTask.java,0.5,46.44 -ScheduledDirectPeriodicTaskTest.java,1.6,46.94 -ScheduledDirectTask.java,0.4,46.44 -ScheduledRunnable.java,2.6,47.44 -ScheduledRunnableTest.java,8.3,49.95 -Scheduler.java,8.2,51.47 -SchedulerLifecycleTest.java,4.2,47.96 -SchedulerMultiWorkerSupport.java,0.4,46.46 -SchedulerMultiWorkerSupportTest.java,2.8,47.47 -SchedulerPoolFactory.java,3.2,47.47 -SchedulerPoolFactoryTest.java,2.3,46.97 -SchedulerRunnableIntrospection.java,0.7,46.47 -SchedulerSupport.java,0.6,46.47 -SchedulerTest.java,8.3,50.47 -SchedulerTestHelper.java,4.0,47.97 -SchedulerWhen.java,4.7,48.48 -SchedulerWhenTest.java,12.2,54.98 -SchedulerWorkerTest.java,8.0,49.6 -Schedulers.java,4.1,48.12 -SequenceEqualTckTest.java,0.3,46.6 -SequentialDisposable.java,0.6,46.6 -SequentialDisposableTest.java,3.0,47.61 -SerialDisposable.java,1.5,46.61 -SerialDisposableTests.java,2.8,47.61 -SerializedObserver.java,5.0,48.61 -SerializedObserverTest.java,41.4,86.13 -SerializedProcessor.java,3.9,48.64 -SerializedProcessorTest.java,34.5,76.16 -SerializedSubject.java,4.3,48.64 -SerializedSubjectTest.java,34.6,76.16 -SerializedSubscriber.java,3.8,48.14 -SerializedSubscriberTest.java,39.5,85.18 -ShareTckTest.java,0.5,46.64 -SimplePlainQueue.java,1.4,46.64 -SimpleQueue.java,0.9,46.64 -SimpleQueueTest.java,8.3,51.64 -Single.java,32.5,64.82 -SingleAmb.java,3.1,47.65 -SingleAmbTest.java,27.0,60.15 -SingleCache.java,4.1,48.16 -SingleCacheTest.java,7.7,50.66 -SingleConcatPublisherTest.java,0.6,46.66 -SingleConcatTest.java,13.9,55.66 -SingleContains.java,1.2,46.66 -SingleContainstTest.java,0.9,46.66 -SingleConverter.java,0.7,46.66 -SingleCreate.java,2.4,47.66 -SingleCreateTest.java,6.2,49.67 -SingleDefer.java,1.1,46.67 -SingleDeferTest.java,2.8,48.16 -SingleDelay.java,1.4,46.68 -SingleDelayTest.java,7.3,49.68 -SingleDelayWithCompletable.java,1.1,46.68 -SingleDelayWithObservable.java,1.2,46.68 -SingleDelayWithPublisher.java,1.1,47.18 -SingleDelayWithSingle.java,1.2,46.68 -SingleDetach.java,1.6,47.18 -SingleDetachTest.java,10.0,52.18 -SingleDoAfterSuccess.java,1.3,46.68 -SingleDoAfterSuccessTest.java,3.6,47.68 -SingleDoAfterTerminate.java,1.1,46.68 -SingleDoAfterTerminateTest.java,3.5,47.68 -SingleDoFinally.java,1.0,46.69 -SingleDoFinallyTest.java,2.7,47.68 -SingleDoOnDispose.java,1.2,46.69 -SingleDoOnError.java,0.8,46.69 -SingleDoOnEvent.java,0.7,46.69 -SingleDoOnSubscribe.java,0.9,46.69 -SingleDoOnSuccess.java,0.9,46.69 -SingleDoOnTest.java,8.0,55.18 -SingleEmitter.java,0.6,46.69 -SingleEquals.java,0.8,46.69 -SingleEqualsTest.java,1.1,47.19 -SingleError.java,1.0,46.69 -SingleErrorTest.java,0.2,46.69 -SingleFlatMap.java,2.1,47.19 -SingleFlatMapCompletable.java,2.8,47.69 -SingleFlatMapCompletableTest.java,0.6,46.69 -SingleFlatMapFlowableTckTest.java,0.3,46.7 -SingleFlatMapIterableFlowable.java,4.3,48.7 -SingleFlatMapIterableFlowableTest.java,13.9,54.21 -SingleFlatMapIterableObservable.java,4.1,48.2 -SingleFlatMapIterableObservableTest.java,7.3,50.2 -SingleFlatMapMaybe.java,2.6,47.2 -SingleFlatMapMaybeTest.java,2.8,47.7 -SingleFlatMapObservable.java,2.2,47.2 -SingleFlatMapObservableTest.java,10.3,53.2 -SingleFlatMapPublisher.java,2.6,47.2 -SingleFlatMapTest.java,14.2,54.21 -SingleFromCallable.java,1.5,47.2 -SingleFromCallableTest.java,14.7,55.71 -SingleFromPublisher.java,2.0,47.2 -SingleFromPublisherTest.java,4.1,48.2 -SingleFromTest.java,1.0,46.71 -SingleFromUnsafeSource.java,0.5,46.71 -SingleHide.java,1.1,46.71 -SingleHideTest.java,0.8,46.71 -SingleInternalHelper.java,2.3,47.21 -SingleInternalHelperTest.java,1.3,46.71 -SingleJust.java,0.5,46.71 -SingleLift.java,1.2,46.71 -SingleLiftTest.java,0.4,46.71 -SingleMap.java,1.5,47.21 -SingleMapTest.java,1.8,47.21 -SingleMergeTest.java,5.0,48.71 -SingleMiscTest.java,6.5,49.72 -SingleNever.java,0.4,46.72 -SingleNullTests.java,34.7,77.24 -SingleObserveOn.java,1.7,47.22 -SingleObserveOnTest.java,0.8,46.72 -SingleObserver.java,0.5,46.72 -SingleOnErrorReturn.java,1.2,46.72 -SingleOnErrorXTest.java,5.3,49.22 -SingleOnSubscribe.java,0.2,46.72 -SingleOperator.java,1.0,46.72 -SinglePostCompleteSubscriber.java,1.1,46.73 -SinglePostCompleteSubscriberTest.java,1.6,47.22 -SingleResumeNext.java,1.9,47.24 -SingleRetryTest.java,1.7,47.24 -SingleScheduler.java,5.9,50.24 -SingleSchedulerTest.java,3.6,47.74 -SingleSource.java,0.4,46.74 -SingleSubject.java,5.4,49.25 -SingleSubjectTest.java,10.3,52.74 -SingleSubscribeOn.java,1.5,46.74 -SingleSubscribeOnTest.java,2.8,47.74 -SingleSubscribeTest.java,8.5,52.25 -SingleTakeUntil.java,2.9,48.24 -SingleTakeUntilTest.java,41.3,92.26 -SingleTckTest.java,0.3,46.74 -SingleTest.java,36.2,86.76 -SingleTimeout.java,3.6,48.6 -SingleTimeoutTest.java,11.4,53.6 -SingleTimer.java,1.0,47.1 -SingleTimerTest.java,4.6,49.09 -SingleToFlowable.java,0.9,47.1 -SingleToFlowableTest.java,0.9,47.1 -SingleToObservable.java,0.9,47.1 -SingleToObservableTest.java,0.9,47.1 -SingleTransformer.java,0.8,47.1 -SingleUnsubscribeOn.java,1.3,47.6 -SingleUnsubscribeOnTest.java,5.0,48.6 -SingleUsing.java,3.2,48.6 -SingleUsingTest.java,14.8,56.11 -SingleZipArray.java,3.3,48.16 -SingleZipArrayTest.java,13.1,52.66 -SingleZipIterable.java,2.1,48.16 -SingleZipIterableTest.java,12.0,53.67 -SingleZipTest.java,5.8,51.18 -SkipLastTckTest.java,0.4,47.19 -SkipTckTest.java,0.2,47.19 -SkipUntilTckTest.java,0.1,47.19 -SkipWhileTckTest.java,0.2,47.2 -SortedTckTest.java,0.6,47.2 -SorterFunction.java,0.3,47.2 -SpscArrayQueue.java,3.0,48.2 -SpscLinkedArrayQueue.java,8.0,51.21 -StrictPerf.java,3.1,48.24 -StrictSubscriber.java,1.6,47.74 -StrictSubscriberTest.java,31.7,67.25 -Subject.java,0.8,47.25 -SubjectTest.java,1.7,47.75 -SubscribeOnTckTest.java,0.5,47.25 -SubscribeWithTest.java,1.3,47.25 -SubscriberCompletableObserver.java,1.0,47.25 -SubscriberFusion.java,4.0,48.76 -SubscriberResourceWrapper.java,1.4,47.75 -SubscriberResourceWrapperTest.java,1.4,47.75 -SubscriptionArbiter.java,5.2,49.26 -SubscriptionArbiterTest.java,4.6,48.76 -SubscriptionDisposable.java,0.6,47.26 -SubscriptionHelper.java,2.2,47.76 -SubscriptionHelperTest.java,9.3,51.76 -SuppressAnimalSniffer.java,0.3,47.26 -SwitchIfEmptyTckTest.java,0.2,47.26 -SwitchMapDelayErrorTckTest.java,0.5,47.26 -SwitchMapTckTest.java,0.2,47.26 -SwitchOnNextTckTest.java,0.3,47.26 -TakeLastTckTest.java,0.4,47.26 -TakeTckTest.java,0.4,47.26 -TakeUntilPerf.java,7.7,51.75 -TakeUntilTckTest.java,0.5,47.26 -TakeWhileTckTest.java,0.1,47.27 -TestException.java,0.0,47.26 -TestHelper.java,100.8,111.61 -TestObserver.java,6.7,54.14 -TestObserverTest.java,42.3,96.72 -TestScheduler.java,4.0,50.68 -TestSchedulerTest.java,9.7,53.68 -TestSubscriber.java,7.8,53.19 -TestSubscriberTest.java,55.8,115.73 -TestingHelper.java,0.8,48.68 -TextualAorAn.java,4.5,50.68 -TimeIntervalTckTest.java,0.2,48.68 -Timed.java,3.4,50.68 -TimedTest.java,6.9,54.68 -TimeoutTckTest.java,0.1,48.68 -TimerTckTest.java,0.5,48.68 -TimestampTckTest.java,0.3,48.68 -ToFlowablePerf.java,7.4,54.18 -ToListTckTest.java,0.4,48.76 -ToMapTckTest.java,0.8,48.76 -ToMultimapTckTest.java,0.8,48.76 -ToSortedListTckTest.java,0.1,48.77 -TooManyEmptyNewLines.java,3.6,50.27 -TrampolineScheduler.java,2.9,50.27 -TrampolineSchedulerInternalTest.java,4.1,50.27 -TrampolineSchedulerTest.java,8.2,54.27 -TransformerTest.java,1.5,49.83 -UndeliverableException.java,0.4,48.83 -UnicastProcessor.java,5.1,53.34 -UnicastProcessorAsPublisherTckTest.java,0.7,48.88 -UnicastProcessorTckTest.java,2.8,49.87 -UnicastProcessorTest.java,24.6,70.88 -UnicastSubject.java,6.0,52.42 -UnicastSubjectTest.java,18.7,71.41 -UnsubscribeOnTckTest.java,0.5,48.93 -UsingTckTest.java,0.3,48.93 -VolatileSizeArrayList.java,3.3,49.93 -VolatileSizeArrayListTest.java,3.2,50.93 -WindowBoundaryTckTest.java,0.7,48.93 -WindowExactSizeTckTest.java,0.3,48.93 -WithLatestFromTckTest.java,0.5,48.93 -XFlatMapTest.java,37.7,91.96 -XMapYPerf.java,33.2,83.45 -ZipIterableTckTest.java,0.9,48.94 -ZipTckTest.java,0.2,48.95 -ZipWithIterableTckTest.java,0.9,48.95 -ZipWithTckTest.java,0.2,48.95 -package-info.java,0.1,48.95 \ No newline at end of file diff --git a/benchmarks/src/test/result/UcfsOff/UcfsOff_java_correct_junit-4-12.csv b/benchmarks/src/test/result/UcfsOff/UcfsOff_java_correct_junit-4-12.csv deleted file mode 100644 index a61093453..000000000 --- a/benchmarks/src/test/result/UcfsOff/UcfsOff_java_correct_junit-4-12.csv +++ /dev/null @@ -1,353 +0,0 @@ -fileName,processing_tim_avg_20_times_millis,max_heap_size_mbMb -ActiveTestSuite.java,30.75,14.96 -ActiveTestTest.java,37.8,22.75 -After.java,4.0,8.62 -AfterClass.java,4.45,8.58 -AllDefaultPossibilitiesBuilder.java,16.55,16.48 -AllMembersSupplier.java,77.35,52.83 -AllMembersSupplierTest.java,49.15,45.76 -AllTests.java,40.85,38.59 -AllTestsTest.java,29.15,21.53 -Annotatable.java,3.6,8.18 -AnnotatedBuilder.java,25.8,18.32 -AnnotatedBuilderTest.java,39.75,34.06 -AnnotatedDescriptionTest.java,27.1,20.5 -AnnotationTest.java,138.65,113.51 -AnnotationValidator.java,6.8,10.7 -AnnotationValidatorFactory.java,12.35,13.95 -AnnotationValidatorFactoryTest.java,18.55,18.39 -AnnotationsValidator.java,32.4,61.37 -AnnotationsValidatorTest.java,26.1,21.44 -ArrayComparisonFailure.java,15.6,14.82 -Assert.java,130.75,95.55 -AssertTest.java,36.2,34.87 -AssertionFailedError.java,4.75,10.1 -AssertionFailedErrorTest.java,10.1,12.43 -AssertionTest.java,215.5,157.38 -Assignments.java,46.85,43.82 -Assume.java,18.45,17.1 -AssumingInTheoriesTest.java,12.75,10.95 -AssumptionTest.java,71.8,58.43 -AssumptionViolatedException.java,26.9,21.43 -AssumptionViolatedExceptionTest.java,37.05,29.67 -BadlyFormedClassesTest.java,16.85,15.36 -BaseTestRunner.java,102.75,68.28 -BaseTestRunnerTest.java,11.0,13.47 -Before.java,3.1,8.59 -BeforeClass.java,4.7,8.57 -BlockJUnit4ClassRunner.java,109.15,73.23 -BlockJUnit4ClassRunnerOverrideTest.java,26.1,21.91 -BlockJUnit4ClassRunnerTest.java,8.45,12.45 -BlockJUnit4ClassRunnerWithParameters.java,47.35,41.63 -BlockJUnit4ClassRunnerWithParametersFactory.java,4.4,8.74 -BooleanSupplier.java,6.45,10.13 -Categories.java,121.2,76.5 -CategoriesAndParameterizedTest.java,33.25,24.77 -Category.java,4.75,8.77 -CategoryFilterFactory.java,15.05,12.66 -CategoryFilterFactoryTest.java,19.4,16.43 -CategoryTest.java,148.75,110.4 -CategoryValidator.java,18.9,15.6 -CategoryValidatorTest.java,32.4,24.53 -ClassLevelMethodsWithIgnoredTestsTest.java,33.8,28.58 -ClassRequest.java,10.95,12.34 -ClassRequestTest.java,6.75,9.88 -ClassRoadie.java,27.4,18.66 -ClassRule.java,5.35,8.93 -ClassRulesTest.java,51.4,47.28 -Classes.java,4.35,9.4 -CommandLineTest.java,20.45,18.91 -ComparisonCompactor.java,40.5,33.83 -ComparisonCompactorTest.java,45.05,36 -ComparisonCriteria.java,30.35,23.05 -ComparisonFailure.java,44.3,39.53 -ComparisonFailureTest.java,17.9,17.04 -Computer.java,8.55,12.09 -ConcurrentRunNotifierTest.java,48.6,42.49 -Correspondent.java,3.25,7.95 -CouldNotReadCoreException.java,3.75,8.61 -DataPoint.java,6.35,9.5 -DataPoints.java,5.6,9.5 -Describable.java,1.95,7.9 -Description.java,55.35,52.48 -DescriptionTest.java,49.1,46.09 -DisableOnDebug.java,17.25,15.38 -DisableOnDebugTest.java,40.05,34.06 -DoublePrecisionAssertTest.java,15.2,15.94 -EachTestNotifier.java,12.9,15.05 -Enclosed.java,10.6,12.5 -EnclosedTest.java,17.05,15.44 -EnumSupplier.java,14.45,12.68 -ErrorCollector.java,12.25,14.51 -ErrorReportingRunner.java,27.85,75.73 -ErrorReportingRunnerTest.java,5.3,9.14 -EventCollector.java,48.15,46.1 -ExactComparisonCriteria.java,4.2,8.86 -ExcludeCategories.java,6.45,12.19 -ExpectException.java,13.45,14.5 -ExpectedException.java,29.3,23.52 -ExpectedExceptionMatcherBuilder.java,15.5,14.45 -ExpectedExceptionTest.java,103.1,65.22 -ExpectedTest.java,31.25,20.61 -ExperimentalTests.java,11.75,12.45 -ExtensionTest.java,28.75,23.81 -ExternalResource.java,5.2,11.72 -ExternalResourceRuleTest.java,10.85,11.87 -Fail.java,5.45,9.36 -FailOnTimeout.java,80.3,50.78 -FailOnTimeoutTest.java,48.1,41.94 -FailedBefore.java,3.25,8.22 -FailedConstructionTest.java,14.5,11.56 -FailingDataPointMethods.java,31.6,28.2 -Failure.java,3.95,8.38 -FailureList.java,10.5,12.36 -Filter.java,32.3,20.47 -FilterFactories.java,22.0,19.87 -FilterFactoriesTest.java,38.15,31.92 -FilterFactory.java,3.75,9.22 -FilterFactoryParams.java,6.65,11.39 -FilterOptionIntegrationTest.java,53.85,52.65 -FilterRequest.java,11.15,13.33 -FilterTest.java,18.75,16.76 -Filterable.java,3.4,7.89 -FilterableTest.java,16.05,14.59 -FixMethodOrder.java,4.05,9.13 -FloatAssertTest.java,18.9,17.01 -ForwardCompatibilityPrintingTest.java,32.8,25.9 -ForwardCompatibilityTest.java,76.4,51.83 -FrameworkField.java,17.3,16.94 -FrameworkFieldTest.java,18.4,18.45 -FrameworkMember.java,11.85,13.09 -FrameworkMethod.java,43.55,38.57 -FrameworkMethodTest.java,22.9,18.74 -FromDataPoints.java,3.55,9.14 -Guesser.java,39.15,32.12 -GuesserQueue.java,15.5,15.97 -IMoney.java,3.9,8.97 -Ignore.java,5.55,9.19 -IgnoreClassTest.java,7.7,12.26 -IgnoredBuilder.java,5.95,10.09 -IgnoredClassRunner.java,8.5,10.78 -IncludeCategories.java,9.05,12.22 -InexactComparisonCriteria.java,10.35,12.47 -InheritedTestCase.java,2.95,8.02 -InheritedTestTest.java,11.45,11.09 -InitializationError.java,8.4,11.5 -InitializationErrorForwardCompatibilityTest.java,31.8,23.24 -InvokeMethod.java,6.2,10.11 -JUnit38ClassRunner.java,57.45,56.19 -JUnit38ClassRunnerTest.java,43.5,36.3 -JUnit38SortingTest.java,17.75,15.03 -JUnit3Builder.java,5.45,10.99 -JUnit4.java,4.7,8.51 -JUnit4Builder.java,3.9,9.03 -JUnit4ClassRunner.java,44.75,40.67 -JUnit4ClassRunnerTest.java,18.0,16.38 -JUnit4TestAdapter.java,30.3,21.64 -JUnit4TestAdapterCache.java,31.25,23.6 -JUnit4TestCaseFacade.java,5.3,11.45 -JUnitCommandLineParseResult.java,44.7,40.6 -JUnitCommandLineParseResultTest.java,47.9,43.52 -JUnitCore.java,32.2,25.32 -JUnitCoreReturnsCorrectExitCodeTest.java,13.8,14.05 -JUnitCoreTest.java,7.45,12.04 -JUnitMatchers.java,21.2,18.51 -JUnitSystem.java,3.35,8.13 -JavadocTest.java,31.7,19.98 -ListTest.java,34.65,26.16 -ListenerTest.java,11.45,13.44 -LoggingTestWatcher.java,11.2,12.64 -MainRunner.java,78.15,60.42 -MatcherTest.java,15.3,15.47 -MaxCore.java,45.55,39.7 -MaxHistory.java,42.6,36.89 -MaxStarterTest.java,113.35,74.29 -MethodCall.java,19.55,18.98 -MethodRoadie.java,46.25,43.99 -MethodRule.java,3.2,8.34 -MethodRulesTest.java,84.5,55.55 -MethodSorter.java,24.1,20.74 -MethodSorterTest.java,45.4,39.03 -MethodSorters.java,6.0,10.3 -MethodValidator.java,35.7,29.1 -Money.java,31.25,24.63 -MoneyBag.java,47.4,43.97 -MoneyTest.java,93.35,60.49 -MultiCategoryTest.java,91.35,59.4 -MultipleFailureException.java,4.05,8.96 -MultipleFailureExceptionTest.java,26.3,19.89 -NameRulesTest.java,10.8,14.08 -NoArgTestCaseTest.java,3.75,8.18 -NoGenericTypeParametersValidator.java,27.5,19.93 -NoTestCaseClass.java,3.25,8.04 -NoTestCases.java,2.9,8.18 -NoTestsRemainException.java,3.15,8.18 -NotPublicTestCase.java,3.25,8.42 -NotVoidTestCase.java,3.75,8.7 -NullBuilder.java,3.85,8.7 -ObjectContractTest.java,19.85,14.65 -OldTestClassAdaptingListenerTest.java,10.25,12 -OldTests.java,4.9,9.31 -OneTestCase.java,4.5,8.71 -OverrideTestCase.java,2.5,8.19 -ParallelClassTest.java,34.75,25.57 -ParallelComputer.java,23.4,20.01 -ParallelMethodTest.java,17.45,18.52 -ParameterSignature.java,49.35,43.7 -ParameterSignatureTest.java,36.65,24.78 -ParameterSupplier.java,3.5,8.24 -Parameterized.java,48.6,44.24 -ParameterizedAssertionError.java,21.7,19.01 -ParameterizedAssertionErrorTest.java,35.25,27.56 -ParameterizedNamesTest.java,18.5,15.97 -ParameterizedTestMethodTest.java,32.5,26.71 -ParameterizedTestTest.java,136.9,101.96 -ParametersRunnerFactory.java,3.55,8.2 -ParametersSuppliedBy.java,4.75,9.2 -ParentRunner.java,120.3,69.7 -ParentRunnerFilteringTest.java,48.5,44.79 -ParentRunnerTest.java,60.8,58.46 -PotentialAssignment.java,18.3,15.62 -PotentialAssignmentTest.java,18.75,17.15 -PrintableResult.java,12.05,14.17 -PrintableResultTest.java,18.4,17.29 -Protectable.java,3.1,8.04 -PublicClassValidator.java,9.55,11.45 -PublicClassValidatorTest.java,16.0,13.19 -RealSystem.java,4.65,9.36 -ReflectiveCallable.java,6.35,9.71 -ReguessableValue.java,4.2,8.92 -RepeatedTest.java,11.4,12.78 -RepeatedTestTest.java,29.2,20.22 -Request.java,28.1,21 -Result.java,46.8,42.23 -ResultMatchers.java,16.35,16.52 -ResultMatchersTest.java,9.1,11.45 -ResultPrinter.java,42.05,34.18 -ResultTest.java,41.1,34.11 -Rule.java,4.95,9.08 -RuleChain.java,13.25,14.24 -RuleChainTest.java,18.45,15.61 -RuleMemberValidator.java,80.05,56.49 -RuleMemberValidatorTest.java,87.95,58.32 -RunAfters.java,13.55,14.58 -RunBefores.java,5.1,11.86 -RunListener.java,6.85,11.58 -RunNotifier.java,41.0,36.25 -RunNotifierTest.java,44.3,40.39 -RunRules.java,7.05,12.52 -RunWith.java,3.5,9.05 -RunWithTest.java,20.25,19.55 -Runner.java,5.75,9.26 -RunnerBuilder.java,22.1,20.02 -RunnerBuilderStub.java,4.95,9.08 -RunnerScheduler.java,3.7,8.11 -RunnerSpy.java,6.2,12.59 -RunnerTest.java,19.35,18.55 -SimpleTest.java,11.7,13.62 -SingleMethodTest.java,45.85,40.08 -Sortable.java,3.5,8.02 -SortableTest.java,44.55,40.22 -Sorter.java,12.9,13.32 -SortingRequest.java,4.85,11.49 -SpecificDataPointsSupplier.java,37.1,29.22 -SpecificDataPointsSupplierTest.java,47.7,43.74 -StackFilterTest.java,18.35,18.6 -StacktracePrintingMatcher.java,16.45,15.63 -StacktracePrintingMatcherTest.java,13.65,13.64 -Statement.java,3.35,8.12 -StoppedByUserException.java,4.1,8.24 -Stopwatch.java,30.4,24.58 -StopwatchTest.java,65.6,55.98 -StringableObject.java,12.15,12.56 -Stub.java,3.3,8.36 -StubbedTheories.java,20.85,19.52 -StubbedTheoriesTest.java,5.35,10.15 -Sub.java,3.2,7.88 -Success.java,4.1,8.48 -SuccessfulWithDataPointFields.java,41.75,35.2 -Suite.java,30.15,23.66 -SuiteDescriptionTest.java,19.75,17.32 -SuiteMethod.java,11.65,13.14 -SuiteMethodBuilder.java,9.4,11.61 -SuiteMethodTest.java,38.95,31.14 -SuiteTest.java,48.7,44.72 -Super.java,3.7,8.28 -SynchronizedRunListener.java,27.25,19.42 -SynchronizedRunListenerTest.java,47.5,44.7 -SystemExitTest.java,16.0,15.48 -TempFolderRuleTest.java,89.4,59.2 -TemporaryFolder.java,40.1,31.15 -TemporaryFolderUsageTest.java,60.55,55.89 -Test.java,4.3,10.22 -TestCase.java,96.2,62.65 -TestCaseTest.java,48.3,46.69 -TestClass.java,38.95,31.67 -TestClassTest.java,57.05,54.71 -TestClassValidator.java,3.0,8.29 -TestDecorator.java,7.85,12.38 -TestDescriptionMethodNameTest.java,18.4,14.61 -TestDescriptionTest.java,10.05,12.83 -TestFailure.java,12.8,13.73 -TestImplementorTest.java,19.5,16.54 -TestListener.java,2.95,8.66 -TestListenerTest.java,19.75,19.65 -TestMethod.java,22.1,19.59 -TestMethodTest.java,43.15,40.05 -TestName.java,5.1,9.62 -TestResult.java,40.0,32.14 -TestRule.java,3.5,8.25 -TestRuleTest.java,164.9,118.98 -TestRunListener.java,6.0,9.67 -TestRunner.java,49.55,48.09 -TestSetup.java,9.45,11.87 -TestSuite.java,82.05,54.38 -TestSystem.java,7.55,11.65 -TestTimedOutException.java,9.95,11.98 -TestWatcher.java,37.25,26.95 -TestWatcherTest.java,46.1,42.4 -TestWatchman.java,13.95,12.6 -TestWatchmanTest.java,17.35,17.06 -TestWithParameters.java,28.05,22.1 -TestWithParametersTest.java,44.4,38.69 -TestedOn.java,5.3,9.22 -TestedOnSupplier.java,9.55,12.36 -TestedOnSupplierTest.java,14.6,12.68 -TextFeedbackTest.java,42.2,37.48 -TextListener.java,34.35,28.34 -TextListenerTest.java,27.4,21.14 -TextRunnerSingleMethodTest.java,12.55,13.05 -TextRunnerTest.java,26.55,19.86 -Theories.java,86.2,58.99 -TheoriesPerformanceTest.java,11.6,13.38 -Theory.java,4.65,8.92 -TheoryTestUtils.java,8.95,11.67 -ThreeTestCases.java,3.6,8.81 -ThrowableCauseMatcher.java,15.55,13.19 -ThrowableCauseMatcherTest.java,5.7,10.6 -ThrowableMessageMatcher.java,13.25,12.76 -Throwables.java,7.25,10.51 -Timeout.java,31.4,23.73 -TimeoutRuleTest.java,49.75,46.23 -TimeoutTest.java,114.2,86.09 -TypeMatchingBetweenMultiDataPointsMethod.java,12.6,15.2 -TypeSafeMatcher.java,18.25,17.6 -UnsuccessfulWithDataPointFields.java,57.05,49.28 -UseSuiteAsASuperclassTest.java,14.55,13.76 -UserStopTest.java,9.55,12.69 -ValidateWith.java,4.2,8.68 -ValidationError.java,6.95,10.16 -ValidationTest.java,16.35,12.67 -Verifier.java,7.15,10.25 -VerifierRuleTest.java,44.0,39.64 -Version.java,4.95,9.67 -WasRun.java,3.8,8.94 -WhenNoParametersMatch.java,18.9,15.69 -WithAutoGeneratedDataPoints.java,18.45,16.88 -WithDataPointMethod.java,31.65,23.43 -WithExtendedParameterSources.java,44.55,39.43 -WithNamedDataPoints.java,18.6,18.57 -WithOnlyTestAnnotations.java,27.25,21.66 -WithParameterSupplier.java,35.25,29.44 -WithUnresolvedGenericTypeVariablesOnTheoryParms.java,47.5,42.96 -package-info.java,2.65,7.86 \ No newline at end of file diff --git a/benchmarks/src/test/result/UcfsOff/UcfsOff_java_correct_rxjava-2-2-2.csv b/benchmarks/src/test/result/UcfsOff/UcfsOff_java_correct_rxjava-2-2-2.csv deleted file mode 100644 index 31dc68ee4..000000000 --- a/benchmarks/src/test/result/UcfsOff/UcfsOff_java_correct_rxjava-2-2-2.csv +++ /dev/null @@ -1,1614 +0,0 @@ -fileName,processing_tim_avg_10_times_millis,max_heap_size_mbMb -AbstractDirectTask.java,52.4,21.15 -AbstractDirectTaskTest.java,118.3,60.58 -AbstractFlowableWithUpstream.java,5.3,10.71 -AbstractFlowableWithUpstreamTest.java,7.5,11.59 -AbstractMaybeWithUpstream.java,4.5,10.11 -AbstractMaybeWithUpstreamTest.java,5.3,11.59 -AbstractObservableWithUpstream.java,4.0,10.11 -AbstractObservableWithUpstreamTest.java,5.3,11.59 -AbstractSchedulerConcurrencyTests.java,141.6,84.5 -AbstractSchedulerTests.java,268.3,167.71 -Action.java,3.4,8.24 -ActionDisposable.java,5.7,11.09 -AllTckTest.java,4.8,11.68 -AmbArrayTckTest.java,4.3,10.55 -AmbTckTest.java,6.1,10.88 -AnyTckTest.java,5.8,11.69 -AppendOnlyLinkedArrayList.java,48.1,42.22 -ArrayCompositeDisposable.java,28.7,23.2 -ArrayCompositeDisposableTest.java,45.2,31.3 -ArrayCompositeSubscription.java,33.3,21.9 -ArrayCompositeSubscriptionTest.java,39.7,31.61 -ArrayListSupplier.java,10.3,13.4 -AsyncProcessor.java,100.0,62.49 -AsyncProcessorAsPublisherTckTest.java,13.8,15.94 -AsyncProcessorTest.java,201.1,138.72 -AsyncSubject.java,93.4,60.01 -AsyncSubjectTest.java,199.3,137.9 -AsyncSubscription.java,17.7,17.14 -AsyncSubscriptionTest.java,59.1,50.02 -AtomicThrowable.java,5.1,11.32 -AtomicThrowableTest.java,5.9,10.73 -BackpressureEnumTest.java,10.8,11.81 -BackpressureHelper.java,41.2,34.82 -BackpressureHelperTest.java,54.8,50.38 -BackpressureKind.java,3.1,8.19 -BackpressureOverflowStrategy.java,3.2,8.13 -BackpressureStrategy.java,3.4,8.13 -BackpressureSupport.java,5.4,9.25 -BaseTck.java,31.7,23.44 -BaseTypeAnnotations.java,90.3,57.26 -BaseTypeParser.java,49.1,46.24 -BasicFuseableConditionalSubscriber.java,37.4,26.18 -BasicFuseableConditionalSubscriberTest.java,14.7,15.83 -BasicFuseableObserver.java,36.2,26.09 -BasicFuseableObserverTest.java,18.2,16.19 -BasicFuseableSubscriber.java,36.0,26.27 -BasicFuseableSubscriberTest.java,12.0,12.84 -BasicIntQueueDisposable.java,3.6,10.57 -BasicIntQueueSubscription.java,3.5,10.58 -BasicQueueDisposable.java,3.2,10.02 -BasicQueueDisposableTest.java,11.1,12.83 -BasicQueueSubscription.java,7.6,10.58 -BehaviorProcessor.java,164.6,112.05 -BehaviorProcessorAsPublisherTckTest.java,16.7,16.77 -BehaviorProcessorTest.java,390.3,233.42 -BehaviorSubject.java,135.0,92.63 -BehaviorSubjectTest.java,337.9,213.17 -Beta.java,2.2,8.21 -BiConsumer.java,3.6,8.39 -BiConsumerSingleObserver.java,19.2,17.11 -BiFunction.java,3.7,8.63 -BiPredicate.java,4.4,8.63 -BinaryFlatMapPerf.java,73.4,60.09 -BlockingBaseObserver.java,18.2,17.41 -BlockingBaseSubscriber.java,18.5,18.74 -BlockingFirstObserver.java,6.6,11.71 -BlockingFirstObserverTest.java,15.6,15.42 -BlockingFirstSubscriber.java,6.4,12.52 -BlockingFlowableIterable.java,49.0,39.47 -BlockingFlowableLatest.java,38.6,24.72 -BlockingFlowableLatestTest.java,98.1,60.4 -BlockingFlowableMostRecent.java,33.9,22.3 -BlockingFlowableMostRecentTest.java,46.8,36.24 -BlockingFlowableNext.java,45.0,36.15 -BlockingFlowableNextTest.java,135.8,96.08 -BlockingFlowableToFutureTest.java,41.8,38.53 -BlockingFlowableToIteratorTest.java,54.3,46.16 -BlockingGetPerf.java,20.9,18.87 -BlockingHelper.java,11.7,14.41 -BlockingHelperTest.java,15.3,14.87 -BlockingIgnoringReceiver.java,7.9,10.67 -BlockingLastObserver.java,6.3,10.25 -BlockingLastSubscriber.java,5.4,10.25 -BlockingMultiObserver.java,42.8,34.84 -BlockingMultiObserverTest.java,41.1,30.81 -BlockingObservableIterable.java,40.1,30.39 -BlockingObservableLatest.java,33.3,23.67 -BlockingObservableLatestTest.java,91.7,59.57 -BlockingObservableMostRecent.java,25.9,22.57 -BlockingObservableMostRecentTest.java,45.7,36.32 -BlockingObservableNext.java,42.4,34.68 -BlockingObservableNextTest.java,125.4,97.96 -BlockingObservableToFutureTest.java,45.7,37.94 -BlockingObservableToIteratorTest.java,41.1,31.98 -BlockingObserver.java,13.0,15.49 -BlockingObserverTest.java,4.5,11.94 -BlockingPerf.java,17.5,15.01 -BlockingSubscriber.java,18.0,16.36 -BlockingSubscriberTest.java,34.6,26.85 -BooleanSubscription.java,7.2,11.81 -BooleanSupplier.java,1.9,8.3 -BoundedSubscriber.java,40.1,30.94 -BoundedSubscriberTest.java,121.7,90.53 -BufferBoundaryTckTest.java,6.9,11.61 -BufferExactSizeTckTest.java,3.0,10.23 -BufferUntilSubscriberTest.java,32.3,27.7 -Burst.java,17.1,17.85 -CacheTckTest.java,3.7,9.87 -CachedThreadSchedulerTest.java,43.1,35.3 -CallableAsyncPerf.java,51.6,43.95 -CallbackCompletableObserver.java,19.5,19.36 -CallbackCompletableObserverTest.java,5.3,11.79 -Cancellable.java,1.7,8.31 -CancellableDisposable.java,14.0,12.75 -CancellableDisposableTest.java,31.7,24.32 -CapturingUncaughtExceptionHandler.java,4.0,10.31 -CheckLocalVariablesInTests.java,108.9,77.85 -CheckReturnValue.java,3.5,9.21 -CollectTckTest.java,11.8,12.67 -CombineLatestArrayDelayErrorTckTest.java,11.6,12.31 -CombineLatestArrayTckTest.java,7.1,12.38 -CombineLatestIterableDelayErrorTckTest.java,5.2,12.68 -CombineLatestIterableTckTest.java,9.7,12.68 -Completable.java,324.4,216.49 -CompletableAmb.java,39.0,34.22 -CompletableAmbTest.java,106.0,65.92 -CompletableAndThenObservable.java,20.6,20.27 -CompletableAndThenObservableTest.java,38.3,32.25 -CompletableAndThenPublisher.java,28.2,78.25 -CompletableAndThenPublisherTckTest.java,5.7,10.48 -CompletableAndThenPublisherTest.java,25.6,20.51 -CompletableAndThenTest.java,37.1,23.6 -CompletableAwaitTest.java,25.8,21.95 -CompletableCache.java,46.9,40.81 -CompletableCacheTest.java,70.3,58.37 -CompletableConcat.java,60.3,54.03 -CompletableConcatArray.java,22.9,20.38 -CompletableConcatIterable.java,37.2,27.3 -CompletableConcatTest.java,115.4,68.63 -CompletableConverter.java,3.9,8.64 -CompletableCreate.java,36.4,60.77 -CompletableCreateTest.java,92.3,54.88 -CompletableDefer.java,13.1,13.13 -CompletableDelay.java,31.6,22.43 -CompletableDelayTest.java,37.5,28.47 -CompletableDetach.java,20.3,17.65 -CompletableDetachTest.java,37.2,31.3 -CompletableDisposeOn.java,20.5,18.96 -CompletableDisposeOnTest.java,36.8,28.43 -CompletableDoFinally.java,20.9,19.81 -CompletableDoFinallyTest.java,23.6,19.9 -CompletableDoOnEvent.java,16.0,16.19 -CompletableDoOnTest.java,33.3,24.38 -CompletableEmitter.java,4.2,9.4 -CompletableEmpty.java,6.0,9.96 -CompletableError.java,4.6,10.12 -CompletableErrorSupplier.java,11.0,12.84 -CompletableFromAction.java,14.3,12.78 -CompletableFromActionTest.java,37.5,28.22 -CompletableFromCallable.java,12.2,13.65 -CompletableFromCallableTest.java,44.1,38.07 -CompletableFromMaybeTest.java,7.8,13.45 -CompletableFromObservable.java,10.0,13.82 -CompletableFromObservableTest.java,13.1,11.91 -CompletableFromPublisher.java,14.9,15.92 -CompletableFromPublisherTest.java,14.4,15.44 -CompletableFromRunnable.java,10.2,12.92 -CompletableFromRunnableTest.java,33.9,27.01 -CompletableFromSingle.java,7.9,13.63 -CompletableFromSingleTest.java,6.4,12.31 -CompletableFromUnsafeSource.java,3.9,9.84 -CompletableHide.java,11.9,90.31 -CompletableHideTest.java,17.4,17.39 -CompletableLift.java,6.6,12.92 -CompletableLiftTest.java,5.7,12.6 -CompletableMerge.java,54.1,49.84 -CompletableMergeArray.java,27.6,21.92 -CompletableMergeDelayErrorArray.java,36.8,24.29 -CompletableMergeDelayErrorIterable.java,34.9,23 -CompletableMergeIterable.java,40.5,29.47 -CompletableMergeIterableTest.java,35.9,26.87 -CompletableMergeTest.java,192.5,126.88 -CompletableNever.java,4.7,10 -CompletableObserveOn.java,25.9,19.59 -CompletableObserveOnTest.java,5.0,12.17 -CompletableObserver.java,2.8,8.85 -CompletableOnErrorComplete.java,15.2,16.16 -CompletableOnErrorXTest.java,10.5,13.15 -CompletableOnSubscribe.java,3.1,8.57 -CompletableOperator.java,2.9,8.61 -CompletablePeek.java,40.0,57.88 -CompletablePeekTest.java,9.1,14.12 -CompletableRepeatWhenTest.java,11.6,13.54 -CompletableResumeNext.java,27.8,19.89 -CompletableResumeNextTest.java,14.9,16.47 -CompletableRetryTest.java,46.8,27.83 -CompletableSource.java,2.5,8.48 -CompletableSubject.java,54.8,49.61 -CompletableSubjectTest.java,65.3,57.79 -CompletableSubscribeOn.java,17.5,18.08 -CompletableSubscribeOnTest.java,16.4,15.38 -CompletableSubscribeTest.java,9.6,12.62 -CompletableTakeUntilCompletable.java,37.7,28.52 -CompletableTakeUntilTest.java,82.3,56.09 -CompletableTest.java,java.lang.OutOfMemoryError,OOM -CompletableTimeout.java,39.9,27.82 -CompletableTimeoutTest.java,53.7,40.09 -CompletableTimer.java,18.4,15.64 -CompletableTimerTest.java,21.2,18.64 -CompletableToFlowable.java,7.2,10.6 -CompletableToFlowableTest.java,4.4,10.31 -CompletableToObservable.java,21.5,17.1 -CompletableToObservableTest.java,20.7,17.44 -CompletableToSingle.java,19.3,18.15 -CompletableTransformer.java,2.5,8.28 -CompletableUnsafeTest.java,28.4,20.17 -CompletableUsing.java,52.9,42.95 -CompletableUsingTest.java,158.2,108 -CompositeDisposable.java,51.6,49.86 -CompositeDisposableTest.java,238.8,158.24 -CompositeException.java,63.0,57.22 -CompositeExceptionTest.java,161.0,98.1 -ComputationScheduler.java,64.9,56.25 -ComputationSchedulerInternalTest.java,9.9,13.53 -ComputationSchedulerTests.java,80.2,52.14 -ConcatArrayEagerTckTest.java,4.5,11.34 -ConcatIterableEagerTckTest.java,6.0,11.01 -ConcatMapIterableTckTest.java,5.6,11.45 -ConcatMapMaybeTckTest.java,5.1,11.38 -ConcatMapSingleTckTest.java,5.6,11.38 -ConcatMapTckTest.java,5.0,11.38 -ConcatPublisherEagerTckTest.java,5.7,11.1 -ConcatPublisherTckTest.java,4.6,11.1 -ConcatTckTest.java,4.3,10.74 -ConcatWithCompletableTckTest.java,4.2,10.14 -ConcatWithMaybeEmptyTckTest.java,4.9,10.14 -ConcatWithMaybeTckTest.java,5.9,10.9 -ConcatWithSingleTckTest.java,5.1,10.9 -ConditionalSubscriber.java,2.7,8.38 -ConnectConsumer.java,3.4,9.14 -ConnectableFlowable.java,48.3,30 -ConnectableObservable.java,40.5,26.47 -Consumer.java,2.0,8.18 -ConsumerSingleObserver.java,18.3,17.41 -ConsumerSingleObserverTest.java,7.9,12.35 -ConverterTest.java,79.6,50.83 -CrashingIterable.java,15.3,16.9 -CrashingMappedIterable.java,19.8,18.73 -CreateTckTest.java,5.6,12.47 -DefaultIfEmptyTckTest.java,3.8,9.91 -DefaultObserver.java,6.2,12.59 -DefaultSubscriber.java,10.6,13.23 -DefaultSubscriberTest.java,10.2,13.23 -DeferTckTest.java,4.7,10.91 -DeferredScalarDisposable.java,38.7,31.24 -DeferredScalarObserver.java,11.8,14.73 -DeferredScalarObserverTest.java,158.8,108.57 -DeferredScalarSubscriber.java,10.8,14.67 -DeferredScalarSubscriberTest.java,139.6,96.92 -DeferredScalarSubscription.java,46.6,41.59 -DeferredScalarSubscriptionTest.java,48.2,32.32 -DelaySubscriptionTckTest.java,4.0,10.72 -DelayTckTest.java,5.0,10.76 -Disposable.java,2.5,8.28 -DisposableCompletableObserver.java,10.1,11.78 -DisposableCompletableObserverTest.java,36.7,26.28 -DisposableContainer.java,2.6,8.6 -DisposableHelper.java,44.7,32.27 -DisposableHelperTest.java,47.1,35.76 -DisposableLambdaObserver.java,28.6,20.92 -DisposableLambdaObserverTest.java,16.4,15.63 -DisposableMaybeObserver.java,9.0,13.16 -DisposableMaybeObserverTest.java,36.7,28.34 -DisposableObserver.java,8.6,13.18 -DisposableObserverTest.java,34.0,27.93 -DisposableSingleObserver.java,11.2,13.16 -DisposableSingleObserverTest.java,33.3,26.87 -DisposableSubscriber.java,14.7,13.69 -DisposableSubscriberTest.java,37.6,28.19 -Disposables.java,17.1,17.28 -DisposablesTest.java,45.2,37.41 -DisposeOnCancel.java,8.5,12.51 -DisposeOnCancelTest.java,6.5,12.81 -DistinctTckTest.java,4.9,10.72 -DistinctUntilChangedTckTest.java,3.5,9.82 -DoAfterNextTckTest.java,3.6,10.25 -DoFinallyTckTest.java,4.6,10.14 -DoOnNextTckTest.java,5.1,10.25 -EachTypeFlatMapPerf.java,36.9,29.59 -ElementAtTckTest.java,3.6,10.47 -Emitter.java,2.1,8.54 -EmptyCompletableObserver.java,10.5,13.38 -EmptyCompletableObserverTest.java,3.7,9.54 -EmptyComponent.java,12.5,14.8 -EmptyComponentTest.java,16.4,17.55 -EmptyDisposable.java,24.1,20.16 -EmptyDisposableTest.java,9.9,13.81 -EmptySubscription.java,14.8,15.26 -EmptyTckTest.java,4.1,9.95 -EndConsumerHelper.java,33.5,24.16 -EndConsumerHelperTest.java,166.4,110.56 -ErrorMode.java,2.3,8.07 -ExceptionHelper.java,38.1,30.45 -ExceptionHelperTest.java,11.9,13.82 -Exceptions.java,16.1,12.2 -ExceptionsNullTest.java,13.7,12.26 -ExceptionsTest.java,121.0,83.3 -ExecutorScheduler.java,111.5,72.15 -ExecutorSchedulerDelayedRunnableTest.java,10.4,13.26 -ExecutorSchedulerTest.java,191.4,132.9 -Experimental.java,2.2,8.04 -FailOnBlockingTest.java,217.8,123.48 -FilterTckTest.java,5.3,11.47 -FirstTckTest.java,7.4,10.44 -FixLicenseHeaders.java,43.5,38.06 -FlatMapJustPerf.java,20.2,17.05 -FlatMapTckTest.java,5.6,11.44 -FlattenCrossMapPerf.java,24.2,19.72 -FlattenJustPerf.java,22.0,18.72 -FlattenRangePerf.java,20.4,18.75 -Flowable.java,java.lang.OutOfMemoryError,OOM -FlowableAll.java,28.9,23.06 -FlowableAllSingle.java,33.7,26.58 -FlowableAllTest.java,176.4,110.48 -FlowableAmb.java,79.1,60.4 -FlowableAmbTest.java,327.6,187.61 -FlowableAny.java,30.5,23.51 -FlowableAnySingle.java,42.8,26.62 -FlowableAnyTest.java,286.5,165.37 -FlowableAsObservableTest.java,22.0,19.48 -FlowableAutoConnect.java,10.4,11.77 -FlowableAutoConnectTest.java,4.6,10.39 -FlowableBackpressureTests.java,368.8,218.5 -FlowableBlockingSubscribe.java,35.2,31.72 -FlowableBlockingTest.java,186.5,122.54 -FlowableBuffer.java,118.9,86.43 -FlowableBufferBoundary.java,126.3,88.95 -FlowableBufferBoundarySupplier.java,68.2,59.81 -FlowableBufferExactBoundary.java,50.1,44.42 -FlowableBufferTest.java,java.lang.OutOfMemoryError,OOM -FlowableBufferTimed.java,167.3,113.89 -FlowableCache.java,117.9,75.5 -FlowableCacheTest.java,220.8,133.72 -FlowableCastTest.java,28.9,21.48 -FlowableCollect.java,36.8,24.57 -FlowableCollectSingle.java,39.7,28.79 -FlowableCollectTest.java,128.7,95.09 -FlowableCombineLatest.java,157.2,117.95 -FlowableCombineLatestTest.java,886.4,415.12 -FlowableCombineLatestTests.java,34.0,26.45 -FlowableConcatArray.java,43.7,35.71 -FlowableConcatDelayErrorTest.java,116.1,75.3 -FlowableConcatMap.java,175.8,120.63 -FlowableConcatMapCompletable.java,69.3,60.83 -FlowableConcatMapCompletablePerf.java,27.6,23.34 -FlowableConcatMapCompletableTest.java,135.4,84.13 -FlowableConcatMapEager.java,116.2,75.21 -FlowableConcatMapEagerPublisher.java,9.6,13.78 -FlowableConcatMapEagerTest.java,621.2,304.75 -FlowableConcatMapMaybe.java,102.9,62.82 -FlowableConcatMapMaybeEmptyPerf.java,28.2,22.37 -FlowableConcatMapMaybePerf.java,29.4,22.81 -FlowableConcatMapMaybeTest.java,130.2,91.74 -FlowableConcatMapPublisher.java,10.0,12.81 -FlowableConcatMapSingle.java,90.7,61.67 -FlowableConcatMapSinglePerf.java,28.2,22.86 -FlowableConcatMapSingleTest.java,111.4,72.17 -FlowableConcatMapTest.java,40.8,34.2 -FlowableConcatTest.java,808.9,404.83 -FlowableConcatTests.java,96.4,59.23 -FlowableConcatWithCompletable.java,24.6,21.35 -FlowableConcatWithCompletableTest.java,38.4,30.78 -FlowableConcatWithMaybe.java,23.8,20.34 -FlowableConcatWithMaybeTest.java,37.0,30.36 -FlowableConcatWithSingle.java,19.3,18.93 -FlowableConcatWithSingleTest.java,32.2,25.67 -FlowableConversionTest.java,73.3,62.2 -FlowableConverter.java,2.7,8.51 -FlowableCount.java,18.1,15.46 -FlowableCountSingle.java,20.5,19.34 -FlowableCountTest.java,27.3,22.2 -FlowableCovarianceTest.java,78.9,59.52 -FlowableCreate.java,195.1,130.98 -FlowableCreateTest.java,410.7,232.99 -FlowableDebounce.java,51.4,47.33 -FlowableDebounceTest.java,201.8,137.91 -FlowableDebounceTimed.java,50.2,46.74 -FlowableDefaultIfEmptyTest.java,40.5,32.75 -FlowableDefer.java,8.7,13.53 -FlowableDeferTest.java,35.9,29.88 -FlowableDelay.java,39.8,29.25 -FlowableDelaySubscriptionOther.java,29.8,23.51 -FlowableDelaySubscriptionOtherTest.java,122.1,86.8 -FlowableDelayTest.java,537.9,292.12 -FlowableDematerialize.java,28.0,23.78 -FlowableDematerializeTest.java,73.4,58.96 -FlowableDetach.java,20.8,19.82 -FlowableDetachTest.java,47.0,43.04 -FlowableDistinct.java,43.2,32.58 -FlowableDistinctTest.java,111.9,73.95 -FlowableDistinctUntilChanged.java,60.0,54.84 -FlowableDistinctUntilChangedTest.java,212.2,137.13 -FlowableDoAfterNext.java,33.4,27.63 -FlowableDoAfterNextTest.java,117.3,64.72 -FlowableDoAfterTerminateTest.java,29.3,23.92 -FlowableDoFinally.java,56.9,53.55 -FlowableDoFinallyTest.java,152.3,105.72 -FlowableDoOnEach.java,108.2,66.66 -FlowableDoOnEachTest.java,337.4,202.38 -FlowableDoOnLifecycle.java,34.4,26.14 -FlowableDoOnLifecycleTest.java,45.6,37.02 -FlowableDoOnRequestTest.java,17.7,17.59 -FlowableDoOnSubscribeTest.java,39.4,30.03 -FlowableDoOnTest.java,34.5,26.15 -FlowableDoOnUnsubscribeTest.java,46.4,39.2 -FlowableElementAt.java,34.9,24.78 -FlowableElementAtMaybe.java,33.6,24.1 -FlowableElementAtSingle.java,37.0,27.82 -FlowableElementAtTest.java,114.7,76.54 -FlowableEmitter.java,3.9,9.52 -FlowableEmpty.java,7.7,10.9 -FlowableError.java,11.1,13.2 -FlowableErrorHandlingTests.java,31.5,22.39 -FlowableEventStream.java,32.4,22.52 -FlowableEventStreamTest.java,4.3,9.11 -FlowableFilter.java,46.7,38.35 -FlowableFilterTest.java,181.8,130.81 -FlowableFirstTest.java,232.8,161.4 -FlowableFlatMap.java,265.5,159.68 -FlowableFlatMapCompletable.java,50.5,47.44 -FlowableFlatMapCompletableAsyncPerf.java,29.7,19.8 -FlowableFlatMapCompletableCompletable.java,52.2,47.11 -FlowableFlatMapCompletablePerf.java,28.8,22.33 -FlowableFlatMapCompletableSyncPerf.java,19.8,18.87 -FlowableFlatMapCompletableTest.java,178.0,125.35 -FlowableFlatMapMaybe.java,122.8,85.23 -FlowableFlatMapMaybeEmptyPerf.java,28.2,22.94 -FlowableFlatMapMaybePerf.java,30.4,20.85 -FlowableFlatMapMaybeTest.java,195.2,142.72 -FlowableFlatMapPublisher.java,10.4,13.7 -FlowableFlatMapSingle.java,118.1,86.92 -FlowableFlatMapSinglePerf.java,28.0,23.8 -FlowableFlatMapSingleTest.java,180.3,125.5 -FlowableFlatMapTest.java,494.2,279.88 -FlowableFlattenIterable.java,129.6,91.35 -FlowableFlattenIterableTest.java,352.3,215.15 -FlowableForEachTest.java,20.1,18.78 -FlowableFromArray.java,83.1,62.98 -FlowableFromArrayTest.java,54.3,50 -FlowableFromCallable.java,15.0,15.45 -FlowableFromCallableTest.java,80.7,60.35 -FlowableFromFuture.java,15.8,16.17 -FlowableFromIterable.java,119.0,78.41 -FlowableFromIterableTest.java,297.0,182.92 -FlowableFromObservable.java,13.9,15.45 -FlowableFromObservableTest.java,4.0,11.19 -FlowableFromPublisher.java,4.6,10.27 -FlowableFromSourceTest.java,250.0,158.3 -FlowableFuseableTest.java,44.3,38.41 -FlowableGenerate.java,51.3,43.78 -FlowableGenerateTest.java,83.7,55.23 -FlowableGroupBy.java,233.3,155.38 -FlowableGroupByTest.java,860.4,440.95 -FlowableGroupByTests.java,34.6,27.18 -FlowableGroupJoin.java,137.6,96.58 -FlowableGroupJoinTest.java,278.3,172.92 -FlowableHide.java,17.2,16.21 -FlowableHideTest.java,30.0,20.69 -FlowableIgnoreElements.java,19.4,19.88 -FlowableIgnoreElementsCompletable.java,19.0,18.42 -FlowableIgnoreElementsTest.java,117.7,72.1 -FlowableInternalHelper.java,126.3,66.34 -FlowableInternalHelperTest.java,5.2,10.05 -FlowableInterval.java,32.8,24.25 -FlowableIntervalRange.java,37.3,29.92 -FlowableIntervalRangeTest.java,42.9,34.34 -FlowableIntervalTest.java,14.3,14.99 -FlowableJoin.java,124.7,88.93 -FlowableJoinTest.java,201.5,142.48 -FlowableJust.java,7.7,11.45 -FlowableLastMaybe.java,21.2,20.39 -FlowableLastSingle.java,27.8,21.59 -FlowableLastTest.java,126.8,90.52 -FlowableLift.java,17.3,14.42 -FlowableLiftTest.java,13.4,13.41 -FlowableLimit.java,38.0,28.48 -FlowableLimitTest.java,59.3,53.83 -FlowableMap.java,41.5,33.94 -FlowableMapNotification.java,33.4,23.92 -FlowableMapNotificationTest.java,55.0,49.96 -FlowableMapPublisher.java,8.9,11.7 -FlowableMapTest.java,205.9,144.48 -FlowableMaterialize.java,11.2,15.68 -FlowableMaterializeTest.java,118.5,82.98 -FlowableMergeDelayErrorTest.java,413.9,233.88 -FlowableMergeMaxConcurrentTest.java,139.1,98.44 -FlowableMergeTest.java,886.0,402.03 -FlowableMergeTests.java,42.1,31.48 -FlowableMergeWithCompletable.java,37.3,27.9 -FlowableMergeWithCompletableTest.java,42.4,32.45 -FlowableMergeWithMaybe.java,115.3,71.92 -FlowableMergeWithMaybeTest.java,124.2,86.36 -FlowableMergeWithSingle.java,113.5,71.12 -FlowableMergeWithSingleTest.java,130.3,86.2 -FlowableNever.java,4.0,10.29 -FlowableNotificationTest.java,41.1,26.02 -FlowableNullTests.java,java.lang.OutOfMemoryError,OOM -FlowableObserveOn.java,186.6,142.83 -FlowableObserveOnTest.java,740.0,397.3 -FlowableOnBackpressureBuffer.java,80.6,61.17 -FlowableOnBackpressureBufferStrategy.java,73.2,58.12 -FlowableOnBackpressureBufferStrategyTest.java,59.7,56 -FlowableOnBackpressureBufferTest.java,109.3,67.45 -FlowableOnBackpressureDrop.java,33.2,25.85 -FlowableOnBackpressureDropTest.java,54.1,49.28 -FlowableOnBackpressureError.java,29.8,23.18 -FlowableOnBackpressureErrorTest.java,16.8,14.5 -FlowableOnBackpressureLatest.java,44.9,40 -FlowableOnBackpressureLatestTest.java,49.4,42.34 -FlowableOnErrorNext.java,35.2,27.27 -FlowableOnErrorResumeNextViaFlowableTest.java,102.2,66.3 -FlowableOnErrorResumeNextViaFunctionTest.java,132.7,96.62 -FlowableOnErrorReturn.java,21.2,17.91 -FlowableOnErrorReturnTest.java,106.7,63.48 -FlowableOnExceptionResumeNextViaFlowableTest.java,126.1,90.9 -FlowableOnSubscribe.java,4.3,8.6 -FlowableOperator.java,4.6,8.85 -FlowableProcessor.java,8.6,11.33 -FlowableProcessorTest.java,17.2,13.49 -FlowablePublish.java,175.2,118.63 -FlowablePublishFunctionTest.java,184.5,130.19 -FlowablePublishMulticast.java,152.9,112.2 -FlowablePublishMulticastTest.java,55.7,51.66 -FlowablePublishTest.java,490.7,286.09 -FlowableRange.java,58.7,54 -FlowableRangeLong.java,53.9,51.75 -FlowableRangeLongTest.java,178.5,126.36 -FlowableRangeTest.java,193.4,136.5 -FlowableReduce.java,35.8,25.79 -FlowableReduceMaybe.java,37.9,27.4 -FlowableReduceSeedSingle.java,38.6,25.33 -FlowableReduceTest.java,192.3,131.16 -FlowableReduceTests.java,42.7,34.33 -FlowableReduceWithSingle.java,12.1,13.89 -FlowableReduceWithSingleTest.java,9.6,12.97 -FlowableRefCount.java,59.1,55.03 -FlowableRefCountTest.java,511.5,283.56 -FlowableRepeat.java,31.6,26.76 -FlowableRepeatTest.java,123.2,94.92 -FlowableRepeatUntil.java,34.8,27.41 -FlowableRepeatWhen.java,46.4,39.54 -FlowableReplay.java,342.0,208.76 -FlowableReplayTest.java,898.9,481.75 -FlowableRetryBiPredicate.java,35.0,27.15 -FlowableRetryPredicate.java,42.5,29.31 -FlowableRetryTest.java,457.3,259.01 -FlowableRetryWhen.java,24.8,20.91 -FlowableRetryWithPredicateTest.java,201.6,135.04 -FlowableSamplePublisher.java,51.3,49.35 -FlowableSampleTest.java,195.7,132.04 -FlowableSampleTimed.java,46.0,40.27 -FlowableScalarXMap.java,42.6,34.31 -FlowableScalarXMapTest.java,63.6,55.99 -FlowableScan.java,35.9,25.19 -FlowableScanSeed.java,56.5,55.04 -FlowableScanTest.java,239.0,160.96 -FlowableSequenceEqual.java,108.1,71.04 -FlowableSequenceEqualSingle.java,79.2,59.85 -FlowableSequenceEqualTest.java,216.3,151.47 -FlowableSerializeTest.java,120.6,82.61 -FlowableSerialized.java,4.6,10.43 -FlowableSingle.java,34.1,25.8 -FlowableSingleMaybe.java,34.8,24.81 -FlowableSingleSingle.java,35.4,27.87 -FlowableSingleTest.java,278.9,174 -FlowableSkip.java,18.9,19.19 -FlowableSkipLast.java,19.2,19.44 -FlowableSkipLastTest.java,53.6,49.37 -FlowableSkipLastTimed.java,54.3,50.46 -FlowableSkipLastTimedTest.java,105.2,65.07 -FlowableSkipTest.java,100.2,59.03 -FlowableSkipTimedTest.java,56.6,54.48 -FlowableSkipUntil.java,39.2,28.51 -FlowableSkipUntilTest.java,77.9,59.95 -FlowableSkipWhile.java,27.9,21.89 -FlowableSkipWhileTest.java,81.5,59.2 -FlowableStartWithTests.java,29.6,23.29 -FlowableSubscribeOn.java,43.5,34.83 -FlowableSubscribeOnTest.java,128.6,98.21 -FlowableSubscriber.java,3.2,8.71 -FlowableSubscriberTest.java,233.7,153.53 -FlowableSwitchIfEmpty.java,19.8,19.55 -FlowableSwitchIfEmptyTest.java,61.7,53.92 -FlowableSwitchMap.java,130.5,98.08 -FlowableSwitchMapCompletable.java,52.1,53.81 -FlowableSwitchMapCompletablePerf.java,29.2,22.5 -FlowableSwitchMapCompletableTest.java,120.6,87.46 -FlowableSwitchMapMaybe.java,90.0,55.04 -FlowableSwitchMapMaybeEmptyPerf.java,30.2,75.79 -FlowableSwitchMapMaybePerf.java,33.3,20.7 -FlowableSwitchMapMaybeTest.java,207.8,131.8 -FlowableSwitchMapSingle.java,69.7,61.85 -FlowableSwitchMapSinglePerf.java,28.7,23.1 -FlowableSwitchMapSingleTest.java,182.5,128.33 -FlowableSwitchTest.java,564.9,311.12 -FlowableTake.java,33.4,28.57 -FlowableTakeLast.java,39.4,29.46 -FlowableTakeLastOne.java,18.7,17.68 -FlowableTakeLastOneTest.java,44.7,35.78 -FlowableTakeLastTest.java,119.6,76.3 -FlowableTakeLastTimed.java,64.2,59.49 -FlowableTakeLastTimedTest.java,138.3,88.37 -FlowableTakePublisher.java,5.4,11.32 -FlowableTakeTest.java,200.4,127.08 -FlowableTakeTimedTest.java,48.1,41.36 -FlowableTakeUntil.java,35.3,27.03 -FlowableTakeUntilPredicate.java,29.9,24.23 -FlowableTakeUntilPredicateTest.java,82.6,60.44 -FlowableTakeUntilTest.java,180.9,129.73 -FlowableTakeWhile.java,30.9,23.76 -FlowableTakeWhileTest.java,118.5,77.49 -FlowableTests.java,534.3,307.29 -FlowableThrottleFirstTest.java,71.1,53.08 -FlowableThrottleFirstTimed.java,42.0,34.58 -FlowableThrottleLastTests.java,23.4,20.21 -FlowableThrottleLatest.java,52.0,50.51 -FlowableThrottleLatestTest.java,90.3,61.07 -FlowableThrottleWithTimeoutTests.java,27.2,22.17 -FlowableTimeInterval.java,22.2,21.21 -FlowableTimeIntervalTest.java,42.7,37.25 -FlowableTimeout.java,119.5,82.48 -FlowableTimeoutTests.java,263.9,156.67 -FlowableTimeoutTimed.java,95.4,57.81 -FlowableTimeoutWithSelectorTest.java,346.6,210.83 -FlowableTimer.java,24.0,20.72 -FlowableTimerTest.java,127.7,94.73 -FlowableTimestampTest.java,48.7,42.15 -FlowableToCompletableTest.java,35.1,26.31 -FlowableToFutureTest.java,94.0,56.09 -FlowableToList.java,27.5,21.96 -FlowableToListSingle.java,34.2,25.7 -FlowableToListTest.java,201.3,142.35 -FlowableToMapTest.java,159.5,120.56 -FlowableToMultimapTest.java,251.8,166.61 -FlowableToSingleTest.java,33.3,25.19 -FlowableToSortedListTest.java,118.5,93.21 -FlowableTransformer.java,3.2,8.93 -FlowableUnsubscribeOn.java,26.3,21.93 -FlowableUnsubscribeOnTest.java,91.9,55.1 -FlowableUsing.java,47.5,41.54 -FlowableUsingTest.java,202.3,146.49 -FlowableWindow.java,155.2,105.95 -FlowableWindowBoundary.java,92.5,57.26 -FlowableWindowBoundarySelector.java,121.2,77.75 -FlowableWindowBoundarySupplier.java,109.9,68.69 -FlowableWindowTests.java,17.5,15.89 -FlowableWindowTimed.java,274.9,173.23 -FlowableWindowWithFlowableTest.java,491.8,288.9 -FlowableWindowWithSizeTest.java,175.6,124.6 -FlowableWindowWithStartEndFlowableTest.java,162.1,115.94 -FlowableWindowWithTimeTest.java,350.8,221.63 -FlowableWithLatestFrom.java,46.6,38.03 -FlowableWithLatestFromMany.java,111.9,64.57 -FlowableWithLatestFromTest.java,333.9,210.29 -FlowableZip.java,132.7,92.27 -FlowableZipCompletionTest.java,39.4,34.11 -FlowableZipIterable.java,43.8,36.43 -FlowableZipIterableTest.java,152.2,108.22 -FlowableZipTest.java,911.8,481.27 -FlowableZipTests.java,46.1,39.46 -ForEachWhileObserver.java,30.2,23.72 -ForEachWhileSubscriber.java,35.1,21.52 -FromArrayTckTest.java,6.4,10.58 -FromCallableTckTest.java,8.7,11.25 -FromFutureTckTest.java,7.1,12.25 -FromIterableTckTest.java,6.4,9.83 -Function.java,3.9,8.72 -Function3.java,3.8,8.96 -Function4.java,4.9,9.08 -Function5.java,5.1,9.24 -Function6.java,5.1,9.36 -Function7.java,4.9,9.48 -Function8.java,5.2,9.6 -Function9.java,5.0,9.72 -Functions.java,259.0,163.07 -FunctionsTest.java,98.3,61.76 -FuseToFlowable.java,3.2,8.68 -FuseToMaybe.java,3.5,8.68 -FuseToObservable.java,3.3,8.68 -FutureDisposable.java,10.7,13.55 -FutureDisposableTest.java,22.8,20.21 -FutureObserver.java,49.6,38.67 -FutureObserverTest.java,118.9,75.81 -FutureSingleObserver.java,41.5,32.9 -FutureSingleObserverTest.java,54.7,46.73 -FutureSubscriber.java,45.8,37.86 -FutureSubscriberTest.java,92.9,55.96 -GenerateTckTest.java,6.5,13.26 -GroupByTckTest.java,5.4,12.69 -GroupedFlowable.java,3.1,10.11 -GroupedObservable.java,2.7,10.12 -HalfSerializer.java,38.4,33.28 -HalfSerializerObserverTest.java,81.5,54.47 -HalfSerializerSubscriberTest.java,82.4,55.07 -HasUpstreamCompletableSource.java,1.5,8.51 -HasUpstreamMaybeSource.java,1.7,8.7 -HasUpstreamObservableSource.java,2.0,8.62 -HasUpstreamPublisher.java,1.9,8.62 -HasUpstreamSingleSource.java,2.1,8.62 -HashMapSupplier.java,4.6,11.26 -HideTckTest.java,4.7,10.14 -IgnoreElementsTckTest.java,4.8,10.77 -ImmediateThinScheduler.java,18.2,18.29 -ImmediateThinSchedulerTest.java,25.8,20.73 -InnerQueuedObserver.java,32.6,23.51 -InnerQueuedObserverSupport.java,4.5,9.25 -InnerQueuedSubscriber.java,42.6,30.58 -InnerQueuedSubscriberSupport.java,3.5,9.25 -InnerQueuedSubscriberTest.java,18.0,15.45 -InputWithIncrementingInteger.java,26.6,22.28 -InstantPeriodicTask.java,37.0,26.81 -InstantPeriodicTaskTest.java,92.6,56.03 -IntFunction.java,3.4,8.75 -InternalWrongNaming.java,51.5,44.89 -IntervalRangeTckTest.java,5.8,10.62 -IntervalTckTest.java,8.3,11.1 -IoScheduler.java,64.6,55.57 -IsEmptyTckTest.java,6.7,10.76 -JavadocFindUnescapedAngleBrackets.java,52.6,41.64 -JavadocForAnnotations.java,102.6,62.84 -JavadocWording.java,528.5,295.34 -JustAsyncPerf.java,50.7,42.32 -JustTckTest.java,3.8,10.26 -LambdaConsumerIntrospection.java,2.8,8.44 -LambdaObserver.java,35.3,25.17 -LambdaObserverTest.java,132.5,93.35 -LambdaSubscriber.java,37.3,26.82 -LambdaSubscriberTest.java,126.1,86.57 -LastTckTest.java,4.7,10.8 -LatchedSingleObserver.java,7.5,12.61 -LimitTckTest.java,6.0,10.4 -LinkedArrayList.java,29.3,22.82 -ListAddBiConsumer.java,5.2,11.78 -ListCompositeDisposable.java,52.4,44.62 -ListCompositeDisposableTest.java,124.1,86.21 -LongConsumer.java,2.2,8.54 -MapTckTest.java,7.1,10.59 -Maybe.java,723.0,378.78 -MaybeAmb.java,43.0,37.56 -MaybeAmbTest.java,44.3,33.94 -MaybeCache.java,55.2,50.96 -MaybeCacheTest.java,107.8,61.68 -MaybeCallbackObserver.java,25.2,21.34 -MaybeCallbackObserverTest.java,46.8,34.52 -MaybeConcatArray.java,44.0,34.59 -MaybeConcatArrayDelayError.java,46.2,38.55 -MaybeConcatArrayTest.java,51.3,47.23 -MaybeConcatIterable.java,49.4,41.54 -MaybeConcatIterableTest.java,46.3,40.08 -MaybeConcatPublisherTest.java,9.9,12.81 -MaybeContains.java,23.5,20.64 -MaybeContainsTest.java,25.0,22.51 -MaybeConverter.java,4.1,8.88 -MaybeCount.java,20.6,18.24 -MaybeCountTest.java,24.8,20.75 -MaybeCreate.java,39.2,34.8 -MaybeCreateTest.java,75.4,59.77 -MaybeDefer.java,6.7,13.77 -MaybeDelay.java,35.4,23.49 -MaybeDelayOtherPublisher.java,40.1,31.6 -MaybeDelayOtherTest.java,82.0,59.09 -MaybeDelaySubscriptionOtherPublisher.java,33.9,29.59 -MaybeDelaySubscriptionTest.java,41.5,32.05 -MaybeDelayTest.java,34.1,26 -MaybeDelayWithCompletable.java,26.0,22.36 -MaybeDetach.java,23.5,21.81 -MaybeDetachTest.java,42.3,36.51 -MaybeDoAfterSuccess.java,20.1,18.83 -MaybeDoAfterSuccessTest.java,41.0,32.52 -MaybeDoFinally.java,24.2,21.36 -MaybeDoFinallyTest.java,41.9,35.28 -MaybeDoOnEvent.java,32.9,23.56 -MaybeDoOnEventTest.java,22.4,20.65 -MaybeEmitter.java,4.4,9.84 -MaybeEmpty.java,4.0,10.83 -MaybeEmptyTest.java,7.2,11.72 -MaybeEqualSingle.java,41.7,36.18 -MaybeEqualTest.java,6.4,13.48 -MaybeError.java,3.8,11.02 -MaybeErrorCallable.java,7.2,13.66 -MaybeErrorTest.java,5.6,10.94 -MaybeFilter.java,25.5,21.39 -MaybeFilterSingle.java,24.6,20.87 -MaybeFilterSingleTest.java,12.6,12.88 -MaybeFlatMapBiSelector.java,43.9,34.04 -MaybeFlatMapBiSelectorTest.java,59.2,51.84 -MaybeFlatMapCompletable.java,23.2,21.41 -MaybeFlatMapCompletableTest.java,16.9,13.97 -MaybeFlatMapIterableFlowable.java,70.0,60.29 -MaybeFlatMapIterableFlowableTest.java,169.1,117.08 -MaybeFlatMapIterableObservable.java,46.3,39.22 -MaybeFlatMapIterableObservableTest.java,113.6,68.34 -MaybeFlatMapNotification.java,43.6,34.33 -MaybeFlatMapNotificationTest.java,46.1,32.82 -MaybeFlatMapObservable.java,28.9,22.48 -MaybeFlatMapObservableTest.java,28.8,23.42 -MaybeFlatMapPublisher.java,32.2,23.11 -MaybeFlatMapPublisherTckTest.java,6.6,12.04 -MaybeFlatMapPublisherTest.java,30.8,23.34 -MaybeFlatMapSingle.java,34.2,25.92 -MaybeFlatMapSingleElement.java,33.7,24.73 -MaybeFlatMapSingleElementTest.java,48.1,33.76 -MaybeFlatMapSingleTest.java,43.8,33.76 -MaybeFlatten.java,33.0,24.64 -MaybeFlattenTest.java,28.6,21.53 -MaybeFromAction.java,12.6,15.48 -MaybeFromActionTest.java,47.5,41.91 -MaybeFromCallable.java,17.5,16.95 -MaybeFromCallableTest.java,54.2,48.87 -MaybeFromCompletable.java,19.2,16.87 -MaybeFromCompletableTest.java,17.3,16.88 -MaybeFromFuture.java,19.2,18.48 -MaybeFromFutureTest.java,36.1,29.04 -MaybeFromRunnable.java,12.3,15.49 -MaybeFromRunnableTest.java,48.4,44.37 -MaybeFromSingle.java,17.9,16.82 -MaybeFromSingleTest.java,15.5,17.32 -MaybeHide.java,14.1,16.57 -MaybeHideTest.java,22.3,17.63 -MaybeIgnoreElement.java,17.7,17.38 -MaybeIgnoreElementCompletable.java,19.3,18.22 -MaybeIgnoreElementTest.java,11.0,12.91 -MaybeIsEmpty.java,13.8,16.08 -MaybeIsEmptySingle.java,22.1,19.87 -MaybeIsEmptySingleTest.java,6.5,11.41 -MaybeIsEmptyTest.java,40.1,28.27 -MaybeJust.java,7.1,11.85 -MaybeJustTest.java,7.6,12.39 -MaybeLift.java,9.4,14.25 -MaybeMap.java,22.7,21.44 -MaybeMapTest.java,6.6,11.28 -MaybeMergeArray.java,122.1,82.3 -MaybeMergeArrayTest.java,77.2,60.48 -MaybeMergeTest.java,37.6,33.39 -MaybeMergeWithTest.java,6.2,10.24 -MaybeNever.java,6.5,10.26 -MaybeNo2Dot0Since.java,33.9,25.59 -MaybeObserveOn.java,32.9,21.63 -MaybeObserver.java,2.8,9.28 -MaybeOfTypeTest.java,29.2,22.78 -MaybeOnErrorComplete.java,21.9,21.41 -MaybeOnErrorNext.java,37.2,29.91 -MaybeOnErrorReturn.java,23.2,20.95 -MaybeOnErrorXTest.java,49.1,46.47 -MaybeOnSubscribe.java,3.3,8.83 -MaybeOperator.java,4.5,9.13 -MaybePeek.java,47.7,36.67 -MaybePeekTest.java,44.8,35.14 -MaybeRetryTest.java,38.5,28.36 -MaybeSource.java,4.0,8.89 -MaybeSubject.java,79.0,60.86 -MaybeSubjectTest.java,116.5,71.11 -MaybeSubscribeOn.java,22.4,20.88 -MaybeSubscribeOnTest.java,5.1,10.13 -MaybeSwitchIfEmpty.java,31.5,24.88 -MaybeSwitchIfEmptySingle.java,31.7,23.75 -MaybeSwitchIfEmptySingleTest.java,36.4,28.58 -MaybeSwitchIfEmptyTest.java,39.1,29.44 -MaybeTakeUntilMaybe.java,39.4,30.67 -MaybeTakeUntilPublisher.java,39.5,30.82 -MaybeTakeUntilPublisherTest.java,56.6,53.76 -MaybeTakeUntilTest.java,190.2,126.94 -MaybeTest.java,java.lang.OutOfMemoryError,OOM -MaybeTimeoutMaybe.java,50.5,40.4 -MaybeTimeoutPublisher.java,48.7,41.44 -MaybeTimeoutPublisherTest.java,90.6,58.28 -MaybeTimeoutTest.java,129.9,86.89 -MaybeTimer.java,13.7,16.97 -MaybeTimerTest.java,19.9,18.84 -MaybeToCompletableTest.java,12.0,14.53 -MaybeToFlowable.java,17.6,16.69 -MaybeToFlowableTest.java,6.8,13.73 -MaybeToObservable.java,20.4,17.47 -MaybeToObservableTest.java,6.7,13.68 -MaybeToPublisher.java,5.1,11.73 -MaybeToSingle.java,24.3,21.69 -MaybeToSingleTest.java,12.6,14.61 -MaybeTransformer.java,2.1,9.01 -MaybeUnsafeCreate.java,3.2,10.29 -MaybeUnsubscribeOn.java,21.9,20.26 -MaybeUnsubscribeOnTest.java,39.7,29.36 -MaybeUsing.java,55.9,50.31 -MaybeUsingTest.java,161.4,110.82 -MaybeZipArray.java,51.8,48.07 -MaybeZipArrayTest.java,50.6,44.82 -MaybeZipIterable.java,30.6,26.05 -MaybeZipIterableTest.java,85.0,51.76 -MemoryPerf.java,199.2,128.39 -MergeIterableTckTest.java,7.5,11.94 -MergePublisherTckTest.java,5.0,11.62 -MergeTckTest.java,7.1,11.32 -MergeWithCompletableTckTest.java,7.2,10.47 -MergeWithMaybeEmptyTckTest.java,7.2,10.42 -MergeWithMaybeTckTest.java,7.4,12.12 -MergeWithSingleTckTest.java,4.8,11.68 -MergerBiFunction.java,30.6,24.86 -MergerBiFunctionTest.java,36.6,28.15 -MiscUtilTest.java,96.8,58.24 -MissingBackpressureException.java,3.3,9.81 -MpscLinkedQueue.java,39.8,33.18 -MulticastProcessor.java,165.6,113.43 -MulticastProcessorAsPublisherTckTest.java,15.6,17.33 -MulticastProcessorRefCountedTckTest.java,16.3,14.55 -MulticastProcessorTckTest.java,15.7,14.56 -MulticastProcessorTest.java,270.7,172.85 -NewLinesBeforeAnnotation.java,51.1,44.79 -NewThreadScheduler.java,12.6,14.54 -NewThreadSchedulerTest.java,32.5,23.89 -NewThreadWorker.java,46.6,40.06 -NoAnonymousInnerClassesTest.java,31.6,24.33 -NonBlockingThread.java,3.5,8.54 -NonNull.java,6.5,10.69 -Notification.java,37.2,27.12 -NotificationLite.java,53.7,48.67 -NotificationLiteTest.java,40.2,31.38 -NotificationTest.java,25.3,22.38 -Nullable.java,5.4,10.67 -ObjectHelper.java,35.0,21.26 -ObjectHelperTest.java,29.5,23.39 -Observable.java,java.lang.OutOfMemoryError,OOM -ObservableAll.java,29.6,23.73 -ObservableAllSingle.java,32.8,24.25 -ObservableAllTest.java,124.4,83.53 -ObservableAmb.java,58.5,56.95 -ObservableAmbTest.java,152.5,106.85 -ObservableAny.java,30.5,26.14 -ObservableAnySingle.java,33.2,24.26 -ObservableAnyTest.java,253.4,162.54 -ObservableAutoConnect.java,7.7,13.85 -ObservableAutoConnectTest.java,5.4,10.91 -ObservableBlockingSubscribe.java,38.7,27.02 -ObservableBlockingTest.java,111.7,66.22 -ObservableBuffer.java,53.6,52.24 -ObservableBufferBoundary.java,123.3,76.29 -ObservableBufferBoundarySupplier.java,76.0,58.06 -ObservableBufferExactBoundary.java,48.7,41.68 -ObservableBufferTest.java,1185.3,472.41 -ObservableBufferTimed.java,156.6,113.17 -ObservableBufferUntilSubscriberTest.java,33.3,26.99 -ObservableCache.java,97.8,63.31 -ObservableCacheTest.java,136.7,101.6 -ObservableCastTest.java,15.9,17.57 -ObservableCollect.java,30.3,25.68 -ObservableCollectSingle.java,32.7,26.32 -ObservableCollectTest.java,125.2,94.18 -ObservableCombineLatest.java,119.9,71.75 -ObservableCombineLatestTest.java,585.2,330.35 -ObservableCombineLatestTests.java,33.2,25.49 -ObservableConcatMap.java,160.6,103.95 -ObservableConcatMapCompletable.java,82.2,57.4 -ObservableConcatMapCompletablePerf.java,30.1,22.51 -ObservableConcatMapCompletableTest.java,123.7,91.31 -ObservableConcatMapEager.java,120.5,80.44 -ObservableConcatMapEagerTest.java,409.9,234.09 -ObservableConcatMapMaybe.java,72.3,53.64 -ObservableConcatMapMaybeEmptyPerf.java,27.8,21.75 -ObservableConcatMapMaybePerf.java,26.9,23.09 -ObservableConcatMapMaybeTest.java,132.4,99.55 -ObservableConcatMapSingle.java,74.0,51.99 -ObservableConcatMapSinglePerf.java,32.8,23.19 -ObservableConcatMapSingleTest.java,120.6,80.23 -ObservableConcatMapTest.java,160.2,106.27 -ObservableConcatTest.java,529.1,292.08 -ObservableConcatTests.java,94.3,61.16 -ObservableConcatWithCompletable.java,24.0,20.51 -ObservableConcatWithCompletableTest.java,43.8,35.92 -ObservableConcatWithMaybe.java,23.3,22.04 -ObservableConcatWithMaybeTest.java,48.8,42.7 -ObservableConcatWithSingle.java,21.9,21 -ObservableConcatWithSingleTest.java,45.4,38.88 -ObservableConverter.java,3.6,9.08 -ObservableCount.java,13.3,16.26 -ObservableCountSingle.java,19.5,18.53 -ObservableCountTest.java,15.9,15.16 -ObservableCovarianceTest.java,79.1,59.99 -ObservableCreate.java,72.1,50.39 -ObservableCreateTest.java,197.5,135.89 -ObservableDebounce.java,46.8,41.25 -ObservableDebounceTest.java,198.3,130.39 -ObservableDebounceTimed.java,45.5,40.35 -ObservableDefaultIfEmptyTest.java,34.9,23.48 -ObservableDefer.java,8.5,13.96 -ObservableDeferTest.java,41.3,28.21 -ObservableDelay.java,38.4,29.94 -ObservableDelaySubscriptionOther.java,25.4,21.52 -ObservableDelaySubscriptionOtherTest.java,75.7,60.39 -ObservableDelayTest.java,490.2,275.72 -ObservableDematerialize.java,32.5,23.29 -ObservableDematerializeTest.java,71.1,60.46 -ObservableDetach.java,20.9,19.98 -ObservableDetachTest.java,37.6,30.4 -ObservableDistinct.java,39.9,30.71 -ObservableDistinctTest.java,114.7,72.77 -ObservableDistinctUntilChanged.java,33.5,26.53 -ObservableDistinctUntilChangedTest.java,125.3,87.29 -ObservableDoAfterNext.java,17.8,18.63 -ObservableDoAfterNextTest.java,111.3,67.36 -ObservableDoFinally.java,41.2,31.74 -ObservableDoFinallyTest.java,159.0,110.04 -ObservableDoOnEach.java,40.3,31.77 -ObservableDoOnEachTest.java,239.3,158.93 -ObservableDoOnLifecycle.java,7.0,12.4 -ObservableDoOnSubscribeTest.java,48.8,39.19 -ObservableDoOnTest.java,35.6,24.95 -ObservableDoOnUnsubscribeTest.java,46.6,38.9 -ObservableElementAt.java,35.0,26.34 -ObservableElementAtMaybe.java,30.0,22.33 -ObservableElementAtSingle.java,35.7,25.77 -ObservableElementAtTest.java,104.8,58.5 -ObservableEmitter.java,3.7,9.83 -ObservableEmpty.java,4.6,11.39 -ObservableError.java,10.5,13.39 -ObservableErrorHandlingTests.java,29.8,23.69 -ObservableEventStream.java,29.0,24.23 -ObservableFilter.java,19.1,18.77 -ObservableFilterTest.java,44.2,35.71 -ObservableFinallyTest.java,13.4,14.37 -ObservableFirstTest.java,251.8,164.61 -ObservableFlatMap.java,185.7,145.65 -ObservableFlatMapCompletable.java,46.9,41.87 -ObservableFlatMapCompletableCompletable.java,49.2,40.99 -ObservableFlatMapCompletablePerf.java,25.2,22.55 -ObservableFlatMapCompletableTest.java,154.6,108.53 -ObservableFlatMapMaybe.java,126.4,67.92 -ObservableFlatMapMaybeEmptyPerf.java,28.2,21.21 -ObservableFlatMapMaybePerf.java,28.0,23.08 -ObservableFlatMapMaybeTest.java,151.7,103.42 -ObservableFlatMapPerf.java,19.4,18.92 -ObservableFlatMapSingle.java,100.4,60.15 -ObservableFlatMapSinglePerf.java,29.1,77.79 -ObservableFlatMapSingleTest.java,122.2,82.23 -ObservableFlatMapTest.java,457.8,267.11 -ObservableFlattenIterable.java,40.2,32.15 -ObservableFlattenIterableTest.java,24.3,22.56 -ObservableForEachTest.java,49.1,41.44 -ObservableFromArray.java,35.1,25.11 -ObservableFromCallable.java,13.6,16.65 -ObservableFromCallableTest.java,99.8,60.39 -ObservableFromFuture.java,14.3,17.16 -ObservableFromIterable.java,41.0,34.2 -ObservableFromIterableTest.java,113.1,72.13 -ObservableFromPublisher.java,19.3,17.1 -ObservableFromTest.java,28.5,21.48 -ObservableFromUnsafeSource.java,4.1,10.63 -ObservableFuseableTest.java,41.0,33.36 -ObservableGenerate.java,45.8,37.87 -ObservableGenerateTest.java,50.8,43.07 -ObservableGroupBy.java,122.3,79.98 -ObservableGroupByTest.java,586.5,317.68 -ObservableGroupByTests.java,23.9,21.53 -ObservableGroupJoin.java,140.6,92.01 -ObservableGroupJoinTest.java,271.7,169.56 -ObservableHide.java,15.4,16.36 -ObservableHideTest.java,26.7,22.53 -ObservableIgnoreElements.java,11.0,14.67 -ObservableIgnoreElementsCompletable.java,15.0,16.32 -ObservableIgnoreElementsTest.java,59.6,48.33 -ObservableInternalHelper.java,98.8,70.12 -ObservableInternalHelperTest.java,6.8,12.81 -ObservableInterval.java,23.2,21.53 -ObservableIntervalRange.java,30.8,25.61 -ObservableIntervalRangeTest.java,33.0,25.95 -ObservableIntervalTest.java,13.0,15.1 -ObservableJoin.java,121.3,75.31 -ObservableJoinTest.java,187.3,134.01 -ObservableJust.java,7.9,12.64 -ObservableLastMaybe.java,24.2,20.1 -ObservableLastSingle.java,26.4,22.58 -ObservableLastTest.java,137.9,89.16 -ObservableLift.java,15.5,14.93 -ObservableLiftTest.java,11.5,12.96 -ObservableMap.java,22.9,20.07 -ObservableMapNotification.java,41.4,30.63 -ObservableMapNotificationTest.java,42.0,28.73 -ObservableMapTest.java,125.3,81.3 -ObservableMaterialize.java,28.4,18.91 -ObservableMaterializeTest.java,55.7,54.16 -ObservableMergeDelayErrorTest.java,293.0,183.43 -ObservableMergeMaxConcurrentTest.java,123.4,87.41 -ObservableMergeTest.java,504.1,279.83 -ObservableMergeTests.java,37.3,31.73 -ObservableMergeWithCompletable.java,34.0,27.74 -ObservableMergeWithCompletableTest.java,41.4,31.96 -ObservableMergeWithMaybe.java,61.6,56.86 -ObservableMergeWithMaybeTest.java,106.1,58.13 -ObservableMergeWithSingle.java,56.7,56.94 -ObservableMergeWithSingleTest.java,88.2,56.47 -ObservableMulticastTest.java,1.9,8.72 -ObservableNever.java,3.9,10.82 -ObservableNullTests.java,1404.7,496.25 -ObservableObserveOn.java,93.4,63.47 -ObservableObserveOnTest.java,325.4,191.99 -ObservableOnErrorNext.java,35.9,29 -ObservableOnErrorResumeNextViaFunctionTest.java,130.6,84.61 -ObservableOnErrorResumeNextViaObservableTest.java,110.3,57.88 -ObservableOnErrorReturn.java,30.3,22.66 -ObservableOnErrorReturnTest.java,86.3,60.42 -ObservableOnExceptionResumeNextViaObservableTest.java,120.0,80.69 -ObservableOnSubscribe.java,3.4,9.03 -ObservableOperator.java,4.4,9.31 -ObservablePublish.java,109.8,63.64 -ObservablePublishSelector.java,35.9,28.35 -ObservablePublishTest.java,265.4,155.49 -ObservableQueueDrain.java,4.3,9.7 -ObservableRange.java,32.3,27.44 -ObservableRangeLong.java,31.5,23.75 -ObservableRangeLongTest.java,58.7,54.26 -ObservableRangeTest.java,50.6,46.76 -ObservableRedoTest.java,14.9,15.21 -ObservableReduceMaybe.java,33.0,27.28 -ObservableReduceSeedSingle.java,32.0,24.26 -ObservableReduceTest.java,133.5,92.14 -ObservableReduceTests.java,40.6,36.79 -ObservableReduceWithSingle.java,11.1,14.29 -ObservableRefCount.java,53.2,55.22 -ObservableRefCountTest.java,475.9,275.85 -ObservableRepeat.java,30.0,72.35 -ObservableRepeatTest.java,122.9,80.71 -ObservableRepeatUntil.java,30.8,24.1 -ObservableRepeatWhen.java,43.4,36.85 -ObservableReplay.java,274.6,171.17 -ObservableReplayTest.java,802.8,416.93 -ObservableResourceWrapperTest.java,19.0,19.46 -ObservableRetryBiPredicate.java,33.5,24.58 -ObservableRetryPredicate.java,36.1,27.77 -ObservableRetryTest.java,439.2,236.11 -ObservableRetryWhen.java,44.0,37.42 -ObservableRetryWithPredicateTest.java,185.6,132.12 -ObservableSampleTest.java,187.7,134.29 -ObservableSampleTimed.java,43.3,37.1 -ObservableSampleWithObservable.java,49.4,44.48 -ObservableScalarXMap.java,55.6,51.78 -ObservableScalarXMapTest.java,55.1,53.44 -ObservableScan.java,33.4,25.41 -ObservableScanSeed.java,37.2,27.87 -ObservableScanTest.java,135.9,86.41 -ObservableScanTests.java,10.9,13.95 -ObservableSequenceEqual.java,80.7,51.75 -ObservableSequenceEqualSingle.java,77.7,53.61 -ObservableSequenceEqualTest.java,147.8,99.26 -ObservableSerializeTest.java,118.6,81.93 -ObservableSerialized.java,5.0,10.89 -ObservableSingleMaybe.java,29.7,23.18 -ObservableSingleSingle.java,33.3,23.73 -ObservableSingleTest.java,203.6,144.98 -ObservableSkip.java,17.3,18.37 -ObservableSkipLast.java,19.1,18.38 -ObservableSkipLastTest.java,55.5,49.87 -ObservableSkipLastTimed.java,48.7,44.28 -ObservableSkipLastTimedTest.java,106.4,60.01 -ObservableSkipTest.java,79.5,53.14 -ObservableSkipTimedTest.java,59.9,55.17 -ObservableSkipUntil.java,34.8,26.79 -ObservableSkipUntilTest.java,69.6,60.72 -ObservableSkipWhile.java,23.1,22.23 -ObservableSkipWhileTest.java,78.5,59.88 -ObservableSource.java,2.9,9.15 -ObservableStartWithTests.java,27.1,23.66 -ObservableSubscribeOn.java,24.9,21.18 -ObservableSubscribeOnTest.java,54.0,53.1 -ObservableSubscriberTest.java,54.6,46.52 -ObservableSwitchIfEmpty.java,19.3,18.23 -ObservableSwitchIfEmptyTest.java,32.9,24.96 -ObservableSwitchMap.java,126.6,79.06 -ObservableSwitchMapCompletable.java,54.1,51.84 -ObservableSwitchMapCompletablePerf.java,27.7,22.92 -ObservableSwitchMapCompletableTest.java,131.3,98.25 -ObservableSwitchMapMaybe.java,70.3,52.71 -ObservableSwitchMapMaybeEmptyPerf.java,28.5,23.07 -ObservableSwitchMapMaybePerf.java,28.6,23.24 -ObservableSwitchMapMaybeTest.java,200.3,140.04 -ObservableSwitchMapSingle.java,76.5,60.16 -ObservableSwitchMapSinglePerf.java,29.2,24.49 -ObservableSwitchMapSingleTest.java,211.3,136.46 -ObservableSwitchTest.java,553.7,292.88 -ObservableTake.java,28.1,25.21 -ObservableTakeLast.java,28.5,23.14 -ObservableTakeLastOne.java,20.7,18.18 -ObservableTakeLastOneTest.java,35.6,27.96 -ObservableTakeLastTest.java,92.6,61.38 -ObservableTakeLastTimed.java,46.6,44.04 -ObservableTakeLastTimedTest.java,128.3,80.22 -ObservableTakeTest.java,156.0,109.83 -ObservableTakeTimedTest.java,48.1,43.32 -ObservableTakeUntil.java,36.1,27.49 -ObservableTakeUntilPredicate.java,32.3,24.64 -ObservableTakeUntilPredicateTest.java,61.2,55.99 -ObservableTakeUntilTest.java,170.8,115.55 -ObservableTakeWhile.java,33.4,25.15 -ObservableTakeWhileTest.java,126.7,81.64 -ObservableTest.java,567.2,311.08 -ObservableThrottleFirstTest.java,81.1,58.87 -ObservableThrottleFirstTimed.java,33.1,27.73 -ObservableThrottleLastTests.java,21.7,20.58 -ObservableThrottleLatest.java,47.7,42.76 -ObservableThrottleLatestTest.java,54.1,54.19 -ObservableThrottleWithTimeoutTests.java,28.2,22.63 -ObservableTimeInterval.java,23.3,21.71 -ObservableTimeIntervalTest.java,42.5,37.67 -ObservableTimeout.java,121.1,78.62 -ObservableTimeoutTests.java,242.9,163.58 -ObservableTimeoutTimed.java,91.6,57.52 -ObservableTimeoutWithSelectorTest.java,338.3,196.28 -ObservableTimer.java,17.0,18.5 -ObservableTimerTest.java,128.6,86.35 -ObservableTimestampTest.java,46.9,42.74 -ObservableToFlowabeTestSync.java,48.1,40.1 -ObservableToFutureTest.java,52.2,45.91 -ObservableToList.java,33.1,24.16 -ObservableToListSingle.java,35.2,23.94 -ObservableToListTest.java,124.2,89.59 -ObservableToMapTest.java,163.6,121.41 -ObservableToMultimapTest.java,245.4,156.9 -ObservableToSortedListTest.java,72.8,50.92 -ObservableToXTest.java,20.6,19.91 -ObservableTransformer.java,2.9,9.26 -ObservableUnsubscribeOn.java,26.1,22.19 -ObservableUnsubscribeOnTest.java,80.1,60.8 -ObservableUsing.java,45.5,40.87 -ObservableUsingTest.java,187.5,131.08 -ObservableWindow.java,56.6,55.52 -ObservableWindowBoundary.java,82.8,54.29 -ObservableWindowBoundarySelector.java,115.9,71.85 -ObservableWindowBoundarySupplier.java,104.9,60.93 -ObservableWindowTests.java,17.0,17.25 -ObservableWindowTimed.java,233.6,138.04 -ObservableWindowWithObservableTest.java,465.2,272.06 -ObservableWindowWithSizeTest.java,138.2,104.58 -ObservableWindowWithStartEndObservableTest.java,163.9,113.63 -ObservableWindowWithTimeTest.java,272.2,171.36 -ObservableWithLatestFrom.java,37.5,34.57 -ObservableWithLatestFromMany.java,91.8,60.64 -ObservableWithLatestFromTest.java,230.7,158.78 -ObservableZip.java,98.6,64.28 -ObservableZipCompletionTest.java,38.1,33.77 -ObservableZipIterable.java,43.7,38.07 -ObservableZipIterableTest.java,156.7,104.72 -ObservableZipTest.java,692.7,374.62 -ObservableZipTests.java,44.7,40.68 -ObserveOnTckTest.java,7.9,11.5 -Observer.java,3.5,9.56 -ObserverFusion.java,33.5,23.22 -ObserverResourceWrapper.java,16.3,16.86 -OnBackpressureBufferTckTest.java,7.0,10.58 -OnErrorNotImplementedException.java,7.3,12.28 -OnErrorNotImplementedExceptionTest.java,35.9,27.03 -OnErrorResumeNextTckTest.java,5.9,10.92 -OnErrorReturnItemTckTest.java,5.0,10.72 -OnNextValueTest.java,35.6,27.28 -OpenHashSet.java,53.3,50.72 -OpenHashSetTest.java,11.3,14.89 -OperatorFlatMapPerf.java,22.9,21.31 -OperatorMergePerf.java,55.0,50.02 -OperatorsAreFinal.java,34.8,26.96 -ParallelCollect.java,40.9,33.14 -ParallelCollectTest.java,48.9,37.91 -ParallelConcatMap.java,18.1,17.76 -ParallelDoOnNextTry.java,77.4,60.26 -ParallelDoOnNextTryTest.java,124.6,74.61 -ParallelFailureHandling.java,4.7,9.8 -ParallelFilter.java,46.3,43.78 -ParallelFilterTest.java,33.2,26.09 -ParallelFilterTry.java,78.9,59.6 -ParallelFilterTryTest.java,117.4,73.82 -ParallelFlatMap.java,15.2,17.67 -ParallelFlowable.java,184.1,127.58 -ParallelFlowableConverter.java,3.7,9.25 -ParallelFlowableTest.java,515.7,294.03 -ParallelFromArray.java,7.8,14.26 -ParallelFromPublisher.java,132.1,91.04 -ParallelFromPublisherTest.java,48.4,45.07 -ParallelInvalid.java,5.9,13.47 -ParallelJoin.java,179.5,126 -ParallelJoinTest.java,87.6,58.07 -ParallelMap.java,51.8,49.02 -ParallelMapTest.java,47.0,38.64 -ParallelMapTry.java,77.1,53.24 -ParallelMapTryTest.java,107.5,70.01 -ParallelPeek.java,53.5,49 -ParallelPeekTest.java,49.1,41.6 -ParallelPerf.java,35.2,28.18 -ParallelReduce.java,40.9,34.07 -ParallelReduceFull.java,65.8,60.54 -ParallelReduceFullTest.java,45.2,36.5 -ParallelReduceTest.java,46.2,41.33 -ParallelRunOn.java,129.1,89.98 -ParallelRunOnTest.java,103.5,61.12 -ParallelSortedJoin.java,86.1,63.31 -ParallelSortedJoinTest.java,52.8,51.98 -ParallelTransformer.java,3.2,9.36 -ParamValidationCheckerTest.java,973.1,498.31 -PerfAsyncConsumer.java,12.2,17.42 -PerfBoundedSubscriber.java,10.3,13.42 -PerfConsumer.java,7.5,14.42 -PerfInteropConsumer.java,7.7,14.41 -PerfObserver.java,5.4,13.32 -PerfSubscriber.java,11.1,13.47 -Pow2.java,4.5,12.18 -Predicate.java,3.6,9.18 -ProtocolViolationException.java,3.0,9.76 -PublicFinalMethods.java,13.5,16.27 -PublishProcessor.java,108.1,59.33 -PublishProcessorAsPublisherTckTest.java,17.1,17.67 -PublishProcessorPerf.java,32.0,24.49 -PublishProcessorTest.java,231.8,154.21 -PublishSelectorTckTest.java,5.2,11.85 -PublishSubject.java,68.2,58.92 -PublishSubjectTest.java,197.3,141.94 -PublishTckTest.java,6.5,10.84 -QueueDisposable.java,1.9,9.19 -QueueDrain.java,5.7,10.19 -QueueDrainHelper.java,127.2,74.12 -QueueDrainHelperTest.java,208.4,148.14 -QueueDrainObserver.java,36.9,30.34 -QueueDrainObserverTest.java,46.5,41.05 -QueueDrainSubscriber.java,46.6,41.31 -QueueDrainSubscriberTest.java,117.1,75.09 -QueueFuseable.java,5.4,10.3 -QueueSubscription.java,4.1,9.11 -QueueSubscriptionTest.java,17.8,18.41 -RangePerf.java,26.2,22.26 -RangeTckTest.java,6.3,10.49 -RebatchRequestsTckTest.java,3.3,10.78 -ReducePerf.java,22.1,21.3 -ReduceTckTest.java,10.0,12.62 -ReduceWithTckTest.java,7.4,13.14 -RefCountProcessor.java,57.8,49.85 -ReferenceDisposable.java,12.9,14.47 -RepeatTckTest.java,4.7,10.48 -ReplayProcessor.java,333.0,204.86 -ReplayProcessorBoundedConcurrencyTest.java,174.7,131.88 -ReplayProcessorConcurrencyTest.java,150.9,105.31 -ReplayProcessorSizeBoundAsPublisherTckTest.java,16.5,88.72 -ReplayProcessorTest.java,686.1,375.48 -ReplayProcessorTimeBoundAsPublisherTckTest.java,12.2,16.88 -ReplayProcessorUnboundedAsPublisherTckTest.java,12.5,15.4 -ReplaySelectorTckTest.java,7.7,11.88 -ReplaySubject.java,368.5,219.95 -ReplaySubjectBoundedConcurrencyTest.java,182.2,132.01 -ReplaySubjectConcurrencyTest.java,144.2,108.51 -ReplaySubjectTest.java,513.1,291.56 -ReplayTckTest.java,6.0,10.9 -ResettableConnectable.java,4.0,9.35 -ResourceCompletableObserver.java,16.1,16.03 -ResourceCompletableObserverTest.java,54.9,47.56 -ResourceMaybeObserver.java,12.4,14.96 -ResourceMaybeObserverTest.java,80.5,53.16 -ResourceObserver.java,12.2,15.64 -ResourceObserverTest.java,54.5,51.52 -ResourceSingleObserver.java,12.4,14.96 -ResourceSingleObserverTest.java,49.9,51.39 -ResourceSubscriber.java,22.5,18.16 -ResourceSubscriberTest.java,64.5,59.36 -ResumeSingleObserver.java,6.4,13.44 -Retry.java,25.6,20.15 -RetryTckTest.java,3.6,10.8 -RunnableDisposable.java,4.9,12.02 -RxJavaPlugins.java,253.8,169.62 -RxJavaPluginsTest.java,535.7,310.45 -RxThreadFactory.java,16.5,17.66 -RxThreadFactoryTest.java,7.6,12.66 -RxVsStreamPerf.java,35.5,26.19 -SafeObserver.java,53.1,47.94 -SafeObserverTest.java,308.6,198.69 -SafeSubscriber.java,51.0,53.88 -SafeSubscriberTest.java,397.5,238.97 -SafeSubscriberWithPluginTest.java,70.8,61.41 -ScalarCallable.java,3.0,9.27 -ScalarSubscription.java,25.3,21.72 -ScalarSubscriptionTest.java,14.1,14.25 -ScalarXMapZHelper.java,38.4,34.14 -ScalarXMapZHelperTest.java,4.1,9.87 -ScanTckTest.java,9.3,12.09 -ScheduledDirectPeriodicTask.java,8.8,12.95 -ScheduledDirectPeriodicTaskTest.java,9.3,13.37 -ScheduledDirectTask.java,6.3,12.51 -ScheduledRunnable.java,43.8,37.09 -ScheduledRunnableTest.java,140.5,100.61 -Scheduler.java,66.5,59.41 -SchedulerLifecycleTest.java,50.6,40.9 -SchedulerMultiWorkerSupport.java,2.4,9.68 -SchedulerMultiWorkerSupportTest.java,47.6,38 -SchedulerPoolFactory.java,45.1,33.18 -SchedulerPoolFactoryTest.java,40.8,32.14 -SchedulerRunnableIntrospection.java,3.8,9.31 -SchedulerSupport.java,6.9,11.68 -SchedulerTest.java,124.4,74.24 -SchedulerTestHelper.java,39.2,34.51 -SchedulerWhen.java,54.3,49.97 -SchedulerWhenTest.java,122.1,91.87 -SchedulerWorkerTest.java,46.6,44.19 -Schedulers.java,35.0,27.8 -SequenceEqualTckTest.java,7.2,11.92 -SequentialDisposable.java,7.4,14.22 -SequentialDisposableTest.java,58.1,53.19 -SerialDisposable.java,12.3,15.84 -SerialDisposableTests.java,80.9,50.51 -SerializedObserver.java,46.5,42.41 -SerializedObserverTest.java,451.2,267.03 -SerializedProcessor.java,46.7,43.55 -SerializedProcessorTest.java,381.8,232.9 -SerializedSubject.java,47.4,46.98 -SerializedSubjectTest.java,395.2,233.23 -SerializedSubscriber.java,45.1,41.59 -SerializedSubscriberTest.java,461.1,260.71 -ShareTckTest.java,3.7,10.7 -SimplePlainQueue.java,2.4,9.4 -SimpleQueue.java,3.4,9.98 -SimpleQueueTest.java,53.0,55.02 -Single.java,585.6,330.03 -SingleAmb.java,41.9,35.7 -SingleAmbTest.java,110.1,71.71 -SingleCache.java,50.9,47.2 -SingleCacheTest.java,29.2,23.26 -SingleConcatPublisherTest.java,5.5,13.34 -SingleConcatTest.java,54.0,51.69 -SingleContains.java,14.0,16.86 -SingleContainstTest.java,5.3,13.13 -SingleConverter.java,3.1,9.41 -SingleCreate.java,36.5,31.57 -SingleCreateTest.java,93.9,61.8 -SingleDefer.java,8.4,14.23 -SingleDeferTest.java,10.3,13.13 -SingleDelay.java,23.7,75.57 -SingleDelayTest.java,99.8,59.83 -SingleDelayWithCompletable.java,17.9,18 -SingleDelayWithObservable.java,22.6,21.84 -SingleDelayWithPublisher.java,27.6,80.53 -SingleDelayWithSingle.java,19.0,17.36 -SingleDetach.java,25.3,19.22 -SingleDetachTest.java,39.9,30.82 -SingleDoAfterSuccess.java,19.0,18.58 -SingleDoAfterSuccessTest.java,34.5,29.01 -SingleDoAfterTerminate.java,25.1,19.16 -SingleDoAfterTerminateTest.java,33.4,26.51 -SingleDoFinally.java,22.0,20.89 -SingleDoFinallyTest.java,22.8,20.8 -SingleDoOnDispose.java,22.9,20.38 -SingleDoOnError.java,22.1,16.03 -SingleDoOnEvent.java,18.7,16.88 -SingleDoOnSubscribe.java,19.9,18.44 -SingleDoOnSuccess.java,14.7,15.5 -SingleDoOnTest.java,126.5,67.43 -SingleEmitter.java,4.0,10.24 -SingleEquals.java,30.8,23.5 -SingleEqualsTest.java,12.0,13.73 -SingleError.java,12.2,13.71 -SingleErrorTest.java,7.9,11.43 -SingleFlatMap.java,32.8,25.27 -SingleFlatMapCompletable.java,25.7,21.86 -SingleFlatMapCompletableTest.java,7.8,11.65 -SingleFlatMapFlowableTckTest.java,10.0,12.51 -SingleFlatMapIterableFlowable.java,63.3,60.58 -SingleFlatMapIterableFlowableTest.java,186.2,122.94 -SingleFlatMapIterableObservable.java,48.8,39.72 -SingleFlatMapIterableObservableTest.java,121.7,66.39 -SingleFlatMapMaybe.java,33.0,28.82 -SingleFlatMapMaybeTest.java,43.6,33.92 -SingleFlatMapObservable.java,27.1,22.95 -SingleFlatMapObservableTest.java,46.7,35.47 -SingleFlatMapPublisher.java,31.2,25.06 -SingleFlatMapTest.java,114.7,64.91 -SingleFromCallable.java,15.8,16.54 -SingleFromCallableTest.java,67.3,58.09 -SingleFromPublisher.java,32.5,25.4 -SingleFromPublisherTest.java,33.1,25.12 -SingleFromTest.java,18.4,13.52 -SingleFromUnsafeSource.java,6.9,10.88 -SingleHide.java,16.8,15.96 -SingleHideTest.java,11.3,14.16 -SingleInternalHelper.java,36.1,23.71 -SingleInternalHelperTest.java,21.1,18.03 -SingleJust.java,8.0,11.54 -SingleLift.java,13.8,12.96 -SingleLiftTest.java,11.6,14.26 -SingleMap.java,23.9,17.86 -SingleMapTest.java,21.3,19.18 -SingleMergeTest.java,49.0,35.11 -SingleMiscTest.java,92.9,53.41 -SingleNever.java,6.5,11.03 -SingleNullTests.java,333.3,192.98 -SingleObserveOn.java,23.7,23.52 -SingleObserveOnTest.java,14.2,13.45 -SingleObserver.java,4.8,9.74 -SingleOnErrorReturn.java,23.7,20.55 -SingleOnErrorXTest.java,28.1,22.3 -SingleOnSubscribe.java,3.7,9.35 -SingleOperator.java,4.5,9.6 -SinglePostCompleteSubscriber.java,38.6,26.17 -SinglePostCompleteSubscriberTest.java,16.2,15.84 -SingleResumeNext.java,30.5,22.64 -SingleRetryTest.java,38.3,29.41 -SingleScheduler.java,60.9,54.51 -SingleSchedulerTest.java,45.3,33.86 -SingleSource.java,3.3,9.38 -SingleSubject.java,69.0,57.6 -SingleSubjectTest.java,98.1,56.64 -SingleSubscribeOn.java,24.2,19.84 -SingleSubscribeOnTest.java,16.4,16.61 -SingleSubscribeTest.java,102.9,59.6 -SingleTakeUntil.java,43.8,35.57 -SingleTakeUntilTest.java,230.3,155.4 -SingleTckTest.java,6.4,11.25 -SingleTest.java,197.5,135.28 -SingleTimeout.java,47.3,37.75 -SingleTimeoutTest.java,59.7,54.27 -SingleTimer.java,14.7,17.16 -SingleTimerTest.java,20.8,20 -SingleToFlowable.java,20.0,15.61 -SingleToFlowableTest.java,10.2,12.91 -SingleToObservable.java,17.9,16.66 -SingleToObservableTest.java,8.4,12.75 -SingleTransformer.java,4.7,9.47 -SingleUnsubscribeOn.java,22.2,19.43 -SingleUnsubscribeOnTest.java,39.0,28.55 -SingleUsing.java,50.0,44.29 -SingleUsingTest.java,118.7,78.13 -SingleZipArray.java,50.3,48.27 -SingleZipArrayTest.java,60.6,50.87 -SingleZipIterable.java,32.0,26.9 -SingleZipIterableTest.java,93.9,58.07 -SingleZipTest.java,91.5,61.17 -SkipLastTckTest.java,6.5,11.22 -SkipTckTest.java,6.8,11.08 -SkipUntilTckTest.java,5.2,11.22 -SkipWhileTckTest.java,4.4,11.28 -SortedTckTest.java,4.9,10.79 -SorterFunction.java,4.3,11.79 -SpscArrayQueue.java,41.6,30.97 -SpscLinkedArrayQueue.java,115.4,76.39 -StrictPerf.java,34.2,26.81 -StrictSubscriber.java,28.8,23.37 -StrictSubscriberTest.java,113.6,67.8 -Subject.java,8.1,11.82 -SubjectTest.java,13.9,13.97 -SubscribeOnTckTest.java,7.7,11.24 -SubscribeWithTest.java,19.0,18.03 -SubscriberCompletableObserver.java,10.8,14.82 -SubscriberFusion.java,40.5,26.71 -SubscriberResourceWrapper.java,21.1,19.21 -SubscriberResourceWrapperTest.java,41.4,27.47 -SubscriptionArbiter.java,83.1,61.87 -SubscriptionArbiterTest.java,47.1,40.48 -SubscriptionDisposable.java,5.9,10.93 -SubscriptionHelper.java,51.5,44.6 -SubscriptionHelperTest.java,96.9,57.28 -SuppressAnimalSniffer.java,4.9,10.33 -SwitchIfEmptyTckTest.java,7.5,11.19 -SwitchMapDelayErrorTckTest.java,7.8,11.53 -SwitchMapTckTest.java,8.1,11.53 -SwitchOnNextTckTest.java,7.4,11.2 -TakeLastTckTest.java,7.7,11.25 -TakeTckTest.java,7.4,11.11 -TakeUntilPerf.java,39.4,26.2 -TakeUntilTckTest.java,7.0,11.17 -TakeWhileTckTest.java,4.9,11.25 -TestException.java,3.9,11.83 -TestHelper.java,2177.6,510.61 -TestObserver.java,94.4,64.15 -TestObserverTest.java,565.2,318.88 -TestScheduler.java,47.6,38.14 -TestSchedulerTest.java,112.1,72.68 -TestSubscriber.java,108.8,67.83 -TestSubscriberTest.java,772.0,411.51 -TestingHelper.java,13.9,15.28 -TextualAorAn.java,93.7,55.54 -TimeIntervalTckTest.java,5.9,11.16 -Timed.java,24.0,21.85 -TimedTest.java,45.5,34.74 -TimeoutTckTest.java,6.3,11.3 -TimerTckTest.java,7.8,11.49 -TimestampTckTest.java,7.2,11.12 -ToFlowablePerf.java,42.6,28.69 -ToListTckTest.java,6.5,11.64 -ToMapTckTest.java,8.8,12.12 -ToMultimapTckTest.java,5.0,12.23 -ToSortedListTckTest.java,3.4,11.64 -TooManyEmptyNewLines.java,46.0,37.76 -TrampolineScheduler.java,54.2,44.9 -TrampolineSchedulerInternalTest.java,56.6,51.35 -TrampolineSchedulerTest.java,49.4,43.08 -TransformerTest.java,50.4,39.9 -UndeliverableException.java,5.4,10.48 -UnicastProcessor.java,120.3,78.53 -UnicastProcessorAsPublisherTckTest.java,12.7,16.35 -UnicastProcessorTckTest.java,16.1,14.64 -UnicastProcessorTest.java,144.5,100.91 -UnicastSubject.java,119.8,70.16 -UnicastSubjectTest.java,154.4,107.2 -UnsubscribeOnTckTest.java,5.4,11.62 -UsingTckTest.java,9.0,12.1 -VolatileSizeArrayList.java,50.8,41.13 -VolatileSizeArrayListTest.java,57.6,52.49 -WindowBoundaryTckTest.java,11.6,13.28 -WindowExactSizeTckTest.java,9.6,12.42 -WithLatestFromTckTest.java,9.0,12.71 -XFlatMapTest.java,203.4,135.82 -XMapYPerf.java,134.4,87.26 -ZipIterableTckTest.java,10.2,14.39 -ZipTckTest.java,9.8,13 -ZipWithIterableTckTest.java,10.5,12.84 -ZipWithTckTest.java,11.0,13.28 -package-info.java,3.3,9 \ No newline at end of file diff --git a/benchmarks/src/test/result/UcfsOn/UcfsOn_java_correct_junit-4-12.csv b/benchmarks/src/test/result/UcfsOn/UcfsOn_java_correct_junit-4-12.csv deleted file mode 100644 index 7d1160917..000000000 --- a/benchmarks/src/test/result/UcfsOn/UcfsOn_java_correct_junit-4-12.csv +++ /dev/null @@ -1,353 +0,0 @@ -fileName,processing_tim_avg_20_times_millis,max_heap_size_mbMb -ActiveTestSuite.java,28.65,15.95 -ActiveTestTest.java,30.7,23.18 -After.java,4.05,8.61 -AfterClass.java,4.05,8.66 -AllDefaultPossibilitiesBuilder.java,15.5,16.07 -AllMembersSupplier.java,69.35,53.97 -AllMembersSupplierTest.java,47.65,47.26 -AllTests.java,42.25,38.93 -AllTestsTest.java,26.3,76.2 -Annotatable.java,2.8,8.17 -AnnotatedBuilder.java,24.15,17.74 -AnnotatedBuilderTest.java,38.85,34.6 -AnnotatedDescriptionTest.java,26.65,21.06 -AnnotationTest.java,134.9,114.38 -AnnotationValidator.java,6.95,10.84 -AnnotationValidatorFactory.java,11.5,14.22 -AnnotationValidatorFactoryTest.java,17.25,18.67 -AnnotationsValidator.java,31.25,27.15 -AnnotationsValidatorTest.java,23.45,21.6 -ArrayComparisonFailure.java,16.6,16.14 -Assert.java,140.2,95.19 -AssertTest.java,36.95,35.68 -AssertionFailedError.java,5.45,10.2 -AssertionFailedErrorTest.java,10.5,12.57 -AssertionTest.java,216.8,159.68 -Assignments.java,46.25,46.9 -Assume.java,20.05,18.14 -AssumingInTheoriesTest.java,10.75,12.86 -AssumptionTest.java,74.8,51.94 -AssumptionViolatedException.java,26.3,21.64 -AssumptionViolatedExceptionTest.java,36.05,30.84 -BadlyFormedClassesTest.java,16.9,16.61 -BaseTestRunner.java,114.45,66.48 -BaseTestRunnerTest.java,10.7,13.73 -Before.java,3.15,8.56 -BeforeClass.java,3.95,8.56 -BlockJUnit4ClassRunner.java,111.3,72.91 -BlockJUnit4ClassRunnerOverrideTest.java,25.95,21.78 -BlockJUnit4ClassRunnerTest.java,6.85,12.62 -BlockJUnit4ClassRunnerWithParameters.java,44.95,42.44 -BlockJUnit4ClassRunnerWithParametersFactory.java,4.05,8.74 -BooleanSupplier.java,5.6,10.22 -Categories.java,115.45,73.6 -CategoriesAndParameterizedTest.java,30.35,26.68 -Category.java,4.75,8.75 -CategoryFilterFactory.java,11.25,12.75 -CategoryFilterFactoryTest.java,16.15,16.73 -CategoryTest.java,145.05,111.41 -CategoryValidator.java,16.9,15.75 -CategoryValidatorTest.java,30.3,25.36 -ClassLevelMethodsWithIgnoredTestsTest.java,35.25,29.09 -ClassRequest.java,11.2,12.13 -ClassRequestTest.java,4.35,9.94 -ClassRoadie.java,24.05,83.08 -ClassRule.java,3.85,8.9 -ClassRulesTest.java,50.4,49.86 -Classes.java,4.9,9.44 -CommandLineTest.java,18.25,19.12 -ComparisonCompactor.java,41.05,35.16 -ComparisonCompactorTest.java,42.6,36.96 -ComparisonCriteria.java,31.9,22.87 -ComparisonFailure.java,44.45,40.46 -ComparisonFailureTest.java,20.05,18.16 -Computer.java,8.65,12.26 -ConcurrentRunNotifierTest.java,46.55,44.23 -Correspondent.java,3.45,7.96 -CouldNotReadCoreException.java,4.4,8.71 -DataPoint.java,5.85,9.59 -DataPoints.java,4.55,9.59 -Describable.java,2.35,7.86 -Description.java,54.05,53.97 -DescriptionTest.java,48.15,48.12 -DisableOnDebug.java,14.8,15.13 -DisableOnDebugTest.java,39.7,35.14 -DoublePrecisionAssertTest.java,16.35,16.03 -EachTestNotifier.java,14.1,15.18 -Enclosed.java,11.65,12.96 -EnclosedTest.java,16.0,15.6 -EnumSupplier.java,8.15,12.89 -ErrorCollector.java,13.8,14.33 -ErrorReportingRunner.java,31.8,21.41 -ErrorReportingRunnerTest.java,4.3,9.19 -EventCollector.java,47.7,47.11 -ExactComparisonCriteria.java,4.05,8.82 -ExcludeCategories.java,8.1,12.32 -ExpectException.java,12.25,14.83 -ExpectedException.java,29.2,24.04 -ExpectedExceptionMatcherBuilder.java,15.75,15.69 -ExpectedExceptionTest.java,111.1,65.19 -ExpectedTest.java,29.0,21.07 -ExperimentalTests.java,10.95,12.28 -ExtensionTest.java,30.4,23.92 -ExternalResource.java,9.15,11.86 -ExternalResourceRuleTest.java,12.4,11.83 -Fail.java,5.45,9.33 -FailOnTimeout.java,71.3,52.5 -FailOnTimeoutTest.java,46.4,44.16 -FailedBefore.java,3.2,8.22 -FailedConstructionTest.java,7.95,12.91 -FailingDataPointMethods.java,31.9,29.55 -Failure.java,3.95,8.41 -FailureList.java,6.95,12.49 -Filter.java,25.85,20.46 -FilterFactories.java,22.8,82.57 -FilterFactoriesTest.java,35.75,32.71 -FilterFactory.java,4.35,9.25 -FilterFactoryParams.java,4.5,11.46 -FilterOptionIntegrationTest.java,53.05,54.47 -FilterRequest.java,10.05,11.85 -FilterTest.java,17.3,17.95 -Filterable.java,2.9,7.89 -FilterableTest.java,16.85,15.69 -FixMethodOrder.java,5.85,9.18 -FloatAssertTest.java,18.05,18.16 -ForwardCompatibilityPrintingTest.java,33.45,27.58 -ForwardCompatibilityTest.java,71.95,51.9 -FrameworkField.java,16.5,17.26 -FrameworkFieldTest.java,22.1,18.74 -FrameworkMember.java,10.85,13.34 -FrameworkMethod.java,43.5,39.8 -FrameworkMethodTest.java,18.7,18.71 -FromDataPoints.java,4.6,9.11 -Guesser.java,36.55,34.67 -GuesserQueue.java,15.75,15.01 -IMoney.java,4.5,8.99 -Ignore.java,5.75,9.23 -IgnoreClassTest.java,10.7,12.45 -IgnoredBuilder.java,7.2,10.18 -IgnoredClassRunner.java,6.5,10.93 -IncludeCategories.java,7.3,12.35 -InexactComparisonCriteria.java,10.0,12.3 -InheritedTestCase.java,3.45,8.02 -InheritedTestTest.java,11.45,12.93 -InitializationError.java,9.2,11.65 -InitializationErrorForwardCompatibilityTest.java,28.9,22.31 -InvokeMethod.java,6.4,10.19 -JUnit38ClassRunner.java,55.1,57.74 -JUnit38ClassRunnerTest.java,41.4,36.74 -JUnit38SortingTest.java,16.75,15.19 -JUnit3Builder.java,5.95,11.12 -JUnit4.java,3.6,8.64 -JUnit4Builder.java,4.1,9.04 -JUnit4ClassRunner.java,45.95,42.35 -JUnit4ClassRunnerTest.java,17.45,16.68 -JUnit4TestAdapter.java,28.2,22.15 -JUnit4TestAdapterCache.java,29.2,24.52 -JUnit4TestCaseFacade.java,7.8,11.52 -JUnitCommandLineParseResult.java,44.1,41.48 -JUnitCommandLineParseResultTest.java,47.9,44.62 -JUnitCore.java,32.05,25.66 -JUnitCoreReturnsCorrectExitCodeTest.java,10.8,14.2 -JUnitCoreTest.java,10.35,12.25 -JUnitMatchers.java,19.0,18.84 -JUnitSystem.java,3.45,8.15 -JavadocTest.java,26.5,20.03 -ListTest.java,35.75,26.7 -ListenerTest.java,11.0,12.32 -LoggingTestWatcher.java,7.15,12.9 -MainRunner.java,71.7,51.9 -MatcherTest.java,15.05,14.86 -MaxCore.java,43.35,41.83 -MaxHistory.java,40.7,37.59 -MaxStarterTest.java,109.2,78.22 -MethodCall.java,19.85,19.28 -MethodRoadie.java,43.85,45.24 -MethodRule.java,4.2,8.36 -MethodRulesTest.java,80.25,56.43 -MethodSorter.java,24.45,83.1 -MethodSorterTest.java,42.85,39.64 -MethodSorters.java,6.75,10.36 -MethodValidator.java,34.9,29.59 -Money.java,34.2,25.03 -MoneyBag.java,48.25,45.13 -MoneyTest.java,96.0,62.22 -MultiCategoryTest.java,84.2,60.53 -MultipleFailureException.java,3.7,9.01 -MultipleFailureExceptionTest.java,30.3,19.91 -NameRulesTest.java,11.0,14.28 -NoArgTestCaseTest.java,3.8,8.18 -NoGenericTypeParametersValidator.java,25.4,19.98 -NoTestCaseClass.java,3.55,8.09 -NoTestCases.java,3.7,8.18 -NoTestsRemainException.java,3.2,8.18 -NotPublicTestCase.java,3.4,8.38 -NotVoidTestCase.java,3.1,8.7 -NullBuilder.java,4.0,8.76 -ObjectContractTest.java,16.85,15.24 -OldTestClassAdaptingListenerTest.java,11.2,11.82 -OldTests.java,4.7,9.28 -OneTestCase.java,4.7,8.68 -OverrideTestCase.java,3.95,8.19 -ParallelClassTest.java,29.05,26.35 -ParallelComputer.java,25.7,20.2 -ParallelMethodTest.java,19.1,18.8 -ParameterSignature.java,46.2,46.81 -ParameterSignatureTest.java,29.9,25.28 -ParameterSupplier.java,3.4,8.24 -Parameterized.java,47.05,45.79 -ParameterizedAssertionError.java,20.6,19.26 -ParameterizedAssertionErrorTest.java,31.25,27.77 -ParameterizedNamesTest.java,16.1,16.22 -ParameterizedTestMethodTest.java,31.15,27.74 -ParameterizedTestTest.java,130.2,101.84 -ParametersRunnerFactory.java,3.75,8.2 -ParametersSuppliedBy.java,5.6,9.17 -ParentRunner.java,107.45,70.17 -ParentRunnerFilteringTest.java,48.45,46.2 -ParentRunnerTest.java,63.85,59.88 -PotentialAssignment.java,15.7,16.36 -PotentialAssignmentTest.java,20.05,18.28 -PrintableResult.java,12.3,14.13 -PrintableResultTest.java,17.4,16.46 -Protectable.java,3.4,7.97 -PublicClassValidator.java,8.0,11.54 -PublicClassValidatorTest.java,14.7,13.43 -RealSystem.java,5.3,9.42 -ReflectiveCallable.java,4.25,9.82 -ReguessableValue.java,3.65,8.94 -RepeatedTest.java,13.25,12.75 -RepeatedTestTest.java,25.9,19.22 -Request.java,24.35,21.25 -Result.java,46.4,43.67 -ResultMatchers.java,17.45,16.81 -ResultMatchersTest.java,8.0,11.55 -ResultPrinter.java,41.0,35.26 -ResultTest.java,41.85,34.63 -Rule.java,3.9,9.03 -RuleChain.java,12.95,14.38 -RuleChainTest.java,16.3,15.89 -RuleMemberValidator.java,58.05,57.76 -RuleMemberValidatorTest.java,85.7,58.3 -RunAfters.java,13.05,14.8 -RunBefores.java,7.65,12.07 -RunListener.java,7.4,11.71 -RunNotifier.java,42.2,36.14 -RunNotifierTest.java,44.95,41.68 -RunRules.java,8.45,12.59 -RunWith.java,4.3,9.01 -RunWithTest.java,22.35,19.84 -Runner.java,4.95,9.3 -RunnerBuilder.java,27.05,18.47 -RunnerBuilderStub.java,4.65,9.12 -RunnerScheduler.java,2.5,8.11 -RunnerSpy.java,7.9,12.74 -RunnerTest.java,20.2,19.12 -SimpleTest.java,12.35,13.41 -SingleMethodTest.java,42.55,40.87 -Sortable.java,3.4,8.03 -SortableTest.java,45.4,41.32 -Sorter.java,9.45,13.58 -SortingRequest.java,7.65,11.6 -SpecificDataPointsSupplier.java,37.6,30.31 -SpecificDataPointsSupplierTest.java,46.9,44.74 -StackFilterTest.java,17.65,18.85 -StacktracePrintingMatcher.java,16.05,15.73 -StacktracePrintingMatcherTest.java,13.85,13.9 -Statement.java,2.95,8.12 -StoppedByUserException.java,3.7,8.24 -Stopwatch.java,28.95,23.54 -StopwatchTest.java,58.2,58.11 -StringableObject.java,12.55,12.32 -Stub.java,3.55,8.36 -StubbedTheories.java,21.25,19.85 -StubbedTheoriesTest.java,5.8,10.21 -Sub.java,3.1,7.88 -Success.java,4.35,8.6 -SuccessfulWithDataPointFields.java,39.8,35.93 -Suite.java,31.05,21.83 -SuiteDescriptionTest.java,19.55,18.36 -SuiteMethod.java,10.6,13.41 -SuiteMethodBuilder.java,7.4,11.72 -SuiteMethodTest.java,36.7,29.75 -SuiteTest.java,46.75,45.8 -Super.java,3.3,8.27 -SynchronizedRunListener.java,26.95,19.44 -SynchronizedRunListenerTest.java,45.5,45.84 -SystemExitTest.java,15.8,14.85 -TempFolderRuleTest.java,92.45,60.54 -TemporaryFolder.java,36.1,31.49 -TemporaryFolderUsageTest.java,53.6,55.85 -Test.java,6.5,10.27 -TestCase.java,101.1,63.61 -TestCaseTest.java,47.15,48.09 -TestClass.java,39.2,32.35 -TestClassTest.java,55.2,56.47 -TestClassValidator.java,3.35,8.33 -TestDecorator.java,9.5,12.57 -TestDescriptionMethodNameTest.java,15.35,14.61 -TestDescriptionTest.java,13.25,13.05 -TestFailure.java,12.55,13.92 -TestImplementorTest.java,19.15,16.79 -TestListener.java,4.2,8.75 -TestListenerTest.java,20.9,19.88 -TestMethod.java,21.65,19.84 -TestMethodTest.java,41.6,41.26 -TestName.java,5.5,9.61 -TestResult.java,38.55,32.53 -TestRule.java,2.85,8.28 -TestRuleTest.java,159.75,120.61 -TestRunListener.java,4.65,9.73 -TestRunner.java,51.35,48.01 -TestSetup.java,9.15,12.06 -TestSuite.java,76.8,55.58 -TestSystem.java,8.4,11.78 -TestTimedOutException.java,9.75,12.12 -TestWatcher.java,35.8,64.09 -TestWatcherTest.java,47.75,43.1 -TestWatchman.java,11.0,12.88 -TestWatchmanTest.java,17.9,17.36 -TestWithParameters.java,30.75,22.76 -TestWithParametersTest.java,42.7,39.24 -TestedOn.java,5.15,9.22 -TestedOnSupplier.java,7.2,12.49 -TestedOnSupplierTest.java,14.65,12.94 -TextFeedbackTest.java,44.45,38.48 -TextListener.java,35.55,29.03 -TextListenerTest.java,31.2,21.28 -TextRunnerSingleMethodTest.java,7.9,13.31 -TextRunnerTest.java,30.7,20.32 -Theories.java,92.3,61.92 -TheoriesPerformanceTest.java,10.4,13.63 -Theory.java,4.7,8.97 -TheoryTestUtils.java,9.85,12.33 -ThreeTestCases.java,4.6,8.79 -ThrowableCauseMatcher.java,12.85,13.17 -ThrowableCauseMatcherTest.java,6.4,10.62 -ThrowableMessageMatcher.java,13.2,12.96 -Throwables.java,7.55,10.59 -Timeout.java,31.75,26.4 -TimeoutRuleTest.java,50.8,48.89 -TimeoutTest.java,115.9,88.45 -TypeMatchingBetweenMultiDataPointsMethod.java,14.7,15.74 -TypeSafeMatcher.java,16.35,16.89 -UnsuccessfulWithDataPointFields.java,53.55,50.84 -UseSuiteAsASuperclassTest.java,10.15,14.06 -UserStopTest.java,9.45,12.94 -ValidateWith.java,3.45,8.66 -ValidationError.java,5.55,10.23 -ValidationTest.java,10.2,12.51 -Verifier.java,5.4,10.31 -VerifierRuleTest.java,41.65,38.84 -Version.java,4.5,9.76 -WasRun.java,4.55,8.91 -WhenNoParametersMatch.java,15.8,15.85 -WithAutoGeneratedDataPoints.java,20.6,17.08 -WithDataPointMethod.java,27.9,23.98 -WithExtendedParameterSources.java,43.65,40.83 -WithNamedDataPoints.java,18.35,18.95 -WithOnlyTestAnnotations.java,25.85,22.33 -WithParameterSupplier.java,33.1,29.85 -WithUnresolvedGenericTypeVariablesOnTheoryParms.java,47.9,44.03 -package-info.java,2.95,7.79 \ No newline at end of file diff --git a/benchmarks/src/test/result/UcfsOn/UcfsOn_java_correct_rxjava-2-2-2.csv b/benchmarks/src/test/result/UcfsOn/UcfsOn_java_correct_rxjava-2-2-2.csv deleted file mode 100644 index d2b51734c..000000000 --- a/benchmarks/src/test/result/UcfsOn/UcfsOn_java_correct_rxjava-2-2-2.csv +++ /dev/null @@ -1,1614 +0,0 @@ -fileName,processing_tim_avg_10_times_millis,max_heap_size_mbMb -AbstractDirectTask.java,48.4,21.41 -AbstractDirectTaskTest.java,79.3,59.86 -AbstractFlowableWithUpstream.java,5.0,10.8 -AbstractFlowableWithUpstreamTest.java,4.7,11.68 -AbstractMaybeWithUpstream.java,6.8,10.2 -AbstractMaybeWithUpstreamTest.java,4.4,11.68 -AbstractObservableWithUpstream.java,3.2,10.16 -AbstractObservableWithUpstreamTest.java,4.3,11.68 -AbstractSchedulerConcurrencyTests.java,127.7,80.84 -AbstractSchedulerTests.java,258.1,170.64 -Action.java,2.2,8.22 -ActionDisposable.java,4.1,11.17 -AllTckTest.java,5.2,11.81 -AmbArrayTckTest.java,4.0,10.63 -AmbTckTest.java,4.3,10.97 -AnyTckTest.java,4.7,11.81 -AppendOnlyLinkedArrayList.java,42.6,40.89 -ArrayCompositeDisposable.java,23.7,23.98 -ArrayCompositeDisposableTest.java,41.1,32.26 -ArrayCompositeSubscription.java,29.4,21.94 -ArrayCompositeSubscriptionTest.java,39.8,31.62 -ArrayListSupplier.java,8.7,13.66 -AsyncProcessor.java,93.7,61.65 -AsyncProcessorAsPublisherTckTest.java,14.5,15.47 -AsyncProcessorTest.java,215.9,138.79 -AsyncSubject.java,80.7,61.11 -AsyncSubjectTest.java,202.2,137.85 -AsyncSubscription.java,14.4,16.7 -AsyncSubscriptionTest.java,53.0,50.06 -AtomicThrowable.java,4.4,11.44 -AtomicThrowableTest.java,3.8,10.82 -BackpressureEnumTest.java,9.2,11.63 -BackpressureHelper.java,38.2,35.16 -BackpressureHelperTest.java,55.6,50.92 -BackpressureKind.java,2.4,8.18 -BackpressureOverflowStrategy.java,2.4,8.1 -BackpressureStrategy.java,2.4,8.1 -BackpressureSupport.java,5.1,9.21 -BaseTck.java,29.0,23.26 -BaseTypeAnnotations.java,89.0,57.3 -BaseTypeParser.java,64.1,46.19 -BasicFuseableConditionalSubscriber.java,34.9,26.8 -BasicFuseableConditionalSubscriberTest.java,14.8,15.3 -BasicFuseableObserver.java,31.9,28.11 -BasicFuseableObserverTest.java,17.0,16.65 -BasicFuseableSubscriber.java,31.5,26.86 -BasicFuseableSubscriberTest.java,10.2,13.11 -BasicIntQueueDisposable.java,3.7,10.67 -BasicIntQueueSubscription.java,3.3,10.67 -BasicQueueDisposable.java,3.3,10.12 -BasicQueueDisposableTest.java,9.9,13 -BasicQueueSubscription.java,4.7,10.67 -BehaviorProcessor.java,154.1,116.17 -BehaviorProcessorAsPublisherTckTest.java,16.0,16.99 -BehaviorProcessorTest.java,383.6,231.98 -BehaviorSubject.java,129.6,94.87 -BehaviorSubjectTest.java,324.8,208.42 -Beta.java,2.3,8.11 -BiConsumer.java,3.2,8.39 -BiConsumerSingleObserver.java,18.2,16.3 -BiFunction.java,2.3,8.64 -BiPredicate.java,2.4,8.64 -BinaryFlatMapPerf.java,84.0,61.54 -BlockingBaseObserver.java,15.3,18.1 -BlockingBaseSubscriber.java,18.6,18.55 -BlockingFirstObserver.java,5.3,11.81 -BlockingFirstObserverTest.java,17.2,14.47 -BlockingFirstSubscriber.java,9.6,12.61 -BlockingFlowableIterable.java,44.2,39.75 -BlockingFlowableLatest.java,34.2,25.35 -BlockingFlowableLatestTest.java,92.4,60.9 -BlockingFlowableMostRecent.java,26.8,23.08 -BlockingFlowableMostRecentTest.java,45.3,37.33 -BlockingFlowableNext.java,42.6,37.74 -BlockingFlowableNextTest.java,127.6,100.05 -BlockingFlowableToFutureTest.java,39.7,39.4 -BlockingFlowableToIteratorTest.java,52.5,48.18 -BlockingGetPerf.java,19.7,19.23 -BlockingHelper.java,11.9,14.57 -BlockingHelperTest.java,16.3,16.01 -BlockingIgnoringReceiver.java,4.0,10.75 -BlockingLastObserver.java,7.4,10.33 -BlockingLastSubscriber.java,5.5,10.33 -BlockingMultiObserver.java,39.9,35.4 -BlockingMultiObserverTest.java,37.6,32.26 -BlockingObservableIterable.java,38.0,31.95 -BlockingObservableLatest.java,34.2,24.87 -BlockingObservableLatestTest.java,97.5,61.6 -BlockingObservableMostRecent.java,23.5,23.14 -BlockingObservableMostRecentTest.java,43.5,37.49 -BlockingObservableNext.java,39.7,36.48 -BlockingObservableNextTest.java,134.3,99.92 -BlockingObservableToFutureTest.java,41.9,38.78 -BlockingObservableToIteratorTest.java,40.7,33.79 -BlockingObserver.java,14.2,15.72 -BlockingObserverTest.java,7.7,12.11 -BlockingPerf.java,17.2,15.03 -BlockingSubscriber.java,17.2,16.53 -BlockingSubscriberTest.java,33.9,27.31 -BooleanSubscription.java,5.2,11.91 -BooleanSupplier.java,3.6,8.31 -BoundedSubscriber.java,40.7,31.05 -BoundedSubscriberTest.java,128.0,91.86 -BufferBoundaryTckTest.java,7.7,11.74 -BufferExactSizeTckTest.java,4.8,10.28 -BufferUntilSubscriberTest.java,33.3,27.92 -Burst.java,18.6,17.27 -CacheTckTest.java,5.4,9.88 -CachedThreadSchedulerTest.java,43.4,37.17 -CallableAsyncPerf.java,48.6,45.39 -CallbackCompletableObserver.java,20.0,19.66 -CallbackCompletableObserverTest.java,6.0,11.88 -Cancellable.java,2.7,8.31 -CancellableDisposable.java,10.1,12.6 -CancellableDisposableTest.java,29.6,24.98 -CapturingUncaughtExceptionHandler.java,4.1,10.39 -CheckLocalVariablesInTests.java,96.0,64.7 -CheckReturnValue.java,4.0,9.23 -CollectTckTest.java,9.8,12.87 -CombineLatestArrayDelayErrorTckTest.java,11.5,12.53 -CombineLatestArrayTckTest.java,8.1,12.53 -CombineLatestIterableDelayErrorTckTest.java,9.7,12.89 -CombineLatestIterableTckTest.java,6.2,12.91 -Completable.java,358.9,211.48 -CompletableAmb.java,40.6,36.82 -CompletableAmbTest.java,99.5,65.74 -CompletableAndThenObservable.java,19.5,20.4 -CompletableAndThenObservableTest.java,39.4,33.13 -CompletableAndThenPublisher.java,30.0,22.65 -CompletableAndThenPublisherTckTest.java,4.3,10.58 -CompletableAndThenPublisherTest.java,25.8,21.14 -CompletableAndThenTest.java,30.0,23.12 -CompletableAwaitTest.java,25.2,22.6 -CompletableCache.java,46.3,41.22 -CompletableCacheTest.java,62.3,59.76 -CompletableConcat.java,56.0,56.02 -CompletableConcatArray.java,22.2,20.6 -CompletableConcatIterable.java,31.0,25.17 -CompletableConcatTest.java,112.9,63.15 -CompletableConverter.java,1.9,8.57 -CompletableCreate.java,35.5,28.52 -CompletableCreateTest.java,89.0,55.04 -CompletableDefer.java,11.3,13.23 -CompletableDelay.java,30.7,24.79 -CompletableDelayTest.java,36.4,28.54 -CompletableDetach.java,16.9,18.71 -CompletableDetachTest.java,40.7,29.04 -CompletableDisposeOn.java,27.3,19.19 -CompletableDisposeOnTest.java,37.1,28.56 -CompletableDoFinally.java,18.8,20.23 -CompletableDoFinallyTest.java,22.1,20.71 -CompletableDoOnEvent.java,15.9,15.57 -CompletableDoOnTest.java,35.5,26.24 -CompletableEmitter.java,2.9,9.42 -CompletableEmpty.java,3.1,9.95 -CompletableError.java,3.1,10.19 -CompletableErrorSupplier.java,7.7,12.95 -CompletableFromAction.java,10.4,12.75 -CompletableFromActionTest.java,33.8,26.77 -CompletableFromCallable.java,10.2,13.75 -CompletableFromCallableTest.java,44.3,36.04 -CompletableFromMaybeTest.java,10.7,13.61 -CompletableFromObservable.java,12.7,12.78 -CompletableFromObservableTest.java,10.9,13.65 -CompletableFromPublisher.java,18.1,15.45 -CompletableFromPublisherTest.java,15.2,14.66 -CompletableFromRunnable.java,10.0,13.19 -CompletableFromRunnableTest.java,36.6,28.7 -CompletableFromSingle.java,8.8,13.79 -CompletableFromSingleTest.java,5.0,12.44 -CompletableFromUnsafeSource.java,3.9,9.93 -CompletableHide.java,10.7,15.33 -CompletableHideTest.java,17.2,17.51 -CompletableLift.java,7.9,13.11 -CompletableLiftTest.java,4.9,12.81 -CompletableMerge.java,52.7,51.04 -CompletableMergeArray.java,27.2,21.22 -CompletableMergeDelayErrorArray.java,31.9,25.04 -CompletableMergeDelayErrorIterable.java,30.4,22.84 -CompletableMergeIterable.java,35.1,29.89 -CompletableMergeIterableTest.java,32.9,26.96 -CompletableMergeTest.java,185.8,129.99 -CompletableNever.java,6.8,10.09 -CompletableObserveOn.java,20.9,20.21 -CompletableObserveOnTest.java,5.0,12.3 -CompletableObserver.java,4.5,8.85 -CompletableOnErrorComplete.java,18.4,15.39 -CompletableOnErrorXTest.java,14.3,13.4 -CompletableOnSubscribe.java,4.0,8.57 -CompletableOperator.java,2.6,8.58 -CompletablePeek.java,37.0,30.99 -CompletablePeekTest.java,9.3,14.4 -CompletableRepeatWhenTest.java,10.0,13.24 -CompletableResumeNext.java,24.6,21.75 -CompletableResumeNextTest.java,16.2,16.6 -CompletableRetryTest.java,34.5,27.83 -CompletableSource.java,2.1,8.48 -CompletableSubject.java,52.9,50.92 -CompletableSubjectTest.java,69.2,59.73 -CompletableSubscribeOn.java,20.7,18.73 -CompletableSubscribeOnTest.java,18.8,16.26 -CompletableSubscribeTest.java,8.3,12.81 -CompletableTakeUntilCompletable.java,33.6,29.11 -CompletableTakeUntilTest.java,59.5,57.59 -CompletableTest.java,java.lang.OutOfMemoryError,OOM -CompletableTimeout.java,34.6,28.25 -CompletableTimeoutTest.java,49.1,41.28 -CompletableTimer.java,14.7,16.03 -CompletableTimerTest.java,18.6,18.92 -CompletableToFlowable.java,5.7,10.68 -CompletableToFlowableTest.java,4.7,10.39 -CompletableToObservable.java,20.1,17.38 -CompletableToObservableTest.java,19.0,18.38 -CompletableToSingle.java,17.8,18.42 -CompletableTransformer.java,2.2,8.31 -CompletableUnsafeTest.java,26.4,18.49 -CompletableUsing.java,47.4,44.31 -CompletableUsingTest.java,158.6,101.73 -CompositeDisposable.java,52.6,51.66 -CompositeDisposableTest.java,248.7,159.45 -CompositeException.java,62.1,60.45 -CompositeExceptionTest.java,127.4,100.18 -ComputationScheduler.java,65.1,58.62 -ComputationSchedulerInternalTest.java,12.6,12.04 -ComputationSchedulerTests.java,79.7,53.2 -ConcatArrayEagerTckTest.java,4.7,11.51 -ConcatIterableEagerTckTest.java,5.8,11.1 -ConcatMapIterableTckTest.java,4.9,11.57 -ConcatMapMaybeTckTest.java,7.0,11.51 -ConcatMapSingleTckTest.java,6.0,11.51 -ConcatMapTckTest.java,7.9,11.48 -ConcatPublisherEagerTckTest.java,9.0,11.18 -ConcatPublisherTckTest.java,8.9,11.19 -ConcatTckTest.java,5.0,10.83 -ConcatWithCompletableTckTest.java,3.6,10.17 -ConcatWithMaybeEmptyTckTest.java,3.8,10.16 -ConcatWithMaybeTckTest.java,4.4,10.94 -ConcatWithSingleTckTest.java,6.3,10.94 -ConditionalSubscriber.java,2.5,8.27 -ConnectConsumer.java,4.7,9.14 -ConnectableFlowable.java,39.2,29.7 -ConnectableObservable.java,33.7,26.82 -Consumer.java,2.8,8.17 -ConsumerSingleObserver.java,17.9,18.44 -ConsumerSingleObserverTest.java,6.0,12.46 -ConverterTest.java,80.0,61.97 -CrashingIterable.java,17.0,15.9 -CrashingMappedIterable.java,18.6,18.98 -CreateTckTest.java,10.7,12.58 -DefaultIfEmptyTckTest.java,6.9,9.95 -DefaultObserver.java,10.8,12.72 -DefaultSubscriber.java,13.2,14.71 -DefaultSubscriberTest.java,11.2,13.06 -DeferTckTest.java,4.6,11.07 -DeferredScalarDisposable.java,37.9,31.74 -DeferredScalarObserver.java,13.1,14.57 -DeferredScalarObserverTest.java,149.7,110.17 -DeferredScalarSubscriber.java,13.8,14.56 -DeferredScalarSubscriberTest.java,127.6,99.32 -DeferredScalarSubscription.java,46.2,39.48 -DeferredScalarSubscriptionTest.java,42.1,33.25 -DelaySubscriptionTckTest.java,4.0,10.75 -DelayTckTest.java,4.7,10.75 -Disposable.java,2.1,8.15 -DisposableCompletableObserver.java,10.2,13.32 -DisposableCompletableObserverTest.java,35.7,26.22 -DisposableContainer.java,3.5,8.58 -DisposableHelper.java,40.9,32.8 -DisposableHelperTest.java,43.2,36.49 -DisposableLambdaObserver.java,25.3,21.97 -DisposableLambdaObserverTest.java,16.1,15.97 -DisposableMaybeObserver.java,11.6,13.35 -DisposableMaybeObserverTest.java,35.9,29 -DisposableObserver.java,11.8,13.39 -DisposableObserverTest.java,36.6,28.56 -DisposableSingleObserver.java,12.5,13.38 -DisposableSingleObserverTest.java,33.4,27.5 -DisposableSubscriber.java,11.7,13.94 -DisposableSubscriberTest.java,36.8,29 -Disposables.java,17.1,16.59 -DisposablesTest.java,45.5,39.89 -DisposeOnCancel.java,6.9,12.68 -DisposeOnCancelTest.java,10.3,13.05 -DistinctTckTest.java,6.4,10.75 -DistinctUntilChangedTckTest.java,6.5,9.91 -DoAfterNextTckTest.java,7.4,10.33 -DoFinallyTckTest.java,3.5,10.19 -DoOnNextTckTest.java,6.3,10.33 -EachTypeFlatMapPerf.java,38.4,29.95 -ElementAtTckTest.java,5.5,10.54 -Emitter.java,4.5,8.53 -EmptyCompletableObserver.java,13.5,13.07 -EmptyCompletableObserverTest.java,6.7,9.62 -EmptyComponent.java,15.4,15.31 -EmptyComponentTest.java,19.2,16.49 -EmptyDisposable.java,23.3,21 -EmptyDisposableTest.java,10.1,12.51 -EmptySubscription.java,12.1,15.07 -EmptyTckTest.java,6.6,9.98 -EndConsumerHelper.java,32.6,70.65 -EndConsumerHelperTest.java,162.3,120.75 -ErrorMode.java,2.9,8 -ExceptionHelper.java,41.1,31.69 -ExceptionHelperTest.java,11.8,13.65 -Exceptions.java,10.4,12.52 -ExceptionsNullTest.java,5.3,13.77 -ExceptionsTest.java,119.7,82.52 -ExecutorScheduler.java,112.6,72.11 -ExecutorSchedulerDelayedRunnableTest.java,9.5,13.52 -ExecutorSchedulerTest.java,191.6,133.18 -Experimental.java,3.0,8.01 -FailOnBlockingTest.java,192.1,125.55 -FilterTckTest.java,7.9,11.55 -FirstTckTest.java,4.8,10.51 -FixLicenseHeaders.java,44.5,42.63 -FlatMapJustPerf.java,16.8,17.21 -FlatMapTckTest.java,6.7,11.51 -FlattenCrossMapPerf.java,23.1,19.99 -FlattenJustPerf.java,19.9,19.03 -FlattenRangePerf.java,21.2,19.03 -Flowable.java,java.lang.OutOfMemoryError,OOM -FlowableAll.java,32.0,22.22 -FlowableAllSingle.java,32.7,27.02 -FlowableAllTest.java,161.3,106.25 -FlowableAmb.java,69.0,61.93 -FlowableAmbTest.java,297.8,179.68 -FlowableAny.java,29.8,24.7 -FlowableAnySingle.java,33.3,26.85 -FlowableAnyTest.java,255.6,160.81 -FlowableAsObservableTest.java,20.2,20.16 -FlowableAutoConnect.java,14.0,13.63 -FlowableAutoConnectTest.java,5.1,10.5 -FlowableBackpressureTests.java,344.2,214.8 -FlowableBlockingSubscribe.java,37.3,29.31 -FlowableBlockingTest.java,167.1,126.92 -FlowableBuffer.java,118.8,85.17 -FlowableBufferBoundary.java,120.2,88.06 -FlowableBufferBoundarySupplier.java,69.4,61.81 -FlowableBufferExactBoundary.java,50.8,45.37 -FlowableBufferTest.java,java.lang.OutOfMemoryError,OOM -FlowableBufferTimed.java,149.9,114.24 -FlowableCache.java,123.4,75.53 -FlowableCacheTest.java,194.6,138.85 -FlowableCastTest.java,29.7,22.85 -FlowableCollect.java,32.9,24.95 -FlowableCollectSingle.java,38.5,28.86 -FlowableCollectTest.java,129.8,95.35 -FlowableCombineLatest.java,153.8,118.33 -FlowableCombineLatestTest.java,765.5,418.26 -FlowableCombineLatestTests.java,32.2,23.92 -FlowableConcatArray.java,40.7,36.07 -FlowableConcatDelayErrorTest.java,117.0,73.65 -FlowableConcatMap.java,156.8,122.66 -FlowableConcatMapCompletable.java,70.4,60.53 -FlowableConcatMapCompletablePerf.java,27.5,21.33 -FlowableConcatMapCompletableTest.java,121.6,79.96 -FlowableConcatMapEager.java,125.9,72.09 -FlowableConcatMapEagerPublisher.java,12.1,13.82 -FlowableConcatMapEagerTest.java,519.3,304.63 -FlowableConcatMapMaybe.java,87.1,62.33 -FlowableConcatMapMaybeEmptyPerf.java,28.6,78.29 -FlowableConcatMapMaybePerf.java,28.5,77 -FlowableConcatMapMaybeTest.java,121.8,88.34 -FlowableConcatMapPublisher.java,10.5,14.38 -FlowableConcatMapSingle.java,89.5,70.47 -FlowableConcatMapSinglePerf.java,28.3,22.53 -FlowableConcatMapSingleTest.java,122.1,70.51 -FlowableConcatMapTest.java,38.3,32.19 -FlowableConcatTest.java,732.6,404.12 -FlowableConcatTests.java,89.0,60.71 -FlowableConcatWithCompletable.java,23.9,21.77 -FlowableConcatWithCompletableTest.java,36.7,30.2 -FlowableConcatWithMaybe.java,25.9,20.26 -FlowableConcatWithMaybeTest.java,34.9,30.3 -FlowableConcatWithSingle.java,19.3,19.25 -FlowableConcatWithSingleTest.java,33.5,26.13 -FlowableConversionTest.java,84.5,52.7 -FlowableConverter.java,3.3,8.55 -FlowableCount.java,16.3,15.81 -FlowableCountSingle.java,18.8,19.26 -FlowableCountTest.java,27.1,22.11 -FlowableCovarianceTest.java,72.2,59.61 -FlowableCreate.java,170.7,131.36 -FlowableCreateTest.java,354.7,236.54 -FlowableDebounce.java,50.8,46.22 -FlowableDebounceTest.java,190.6,138.68 -FlowableDebounceTimed.java,49.2,47.47 -FlowableDefaultIfEmptyTest.java,41.6,33.12 -FlowableDefer.java,9.6,13.57 -FlowableDeferTest.java,34.7,29.21 -FlowableDelay.java,35.8,28.85 -FlowableDelaySubscriptionOther.java,29.6,23.78 -FlowableDelaySubscriptionOtherTest.java,119.5,85.59 -FlowableDelayTest.java,487.1,292.12 -FlowableDematerialize.java,28.4,23.78 -FlowableDematerializeTest.java,66.2,59.43 -FlowableDetach.java,21.5,19.74 -FlowableDetachTest.java,47.2,43.16 -FlowableDistinct.java,42.3,33.29 -FlowableDistinctTest.java,122.7,69.95 -FlowableDistinctUntilChanged.java,57.3,52.97 -FlowableDistinctUntilChangedTest.java,185.8,140.41 -FlowableDoAfterNext.java,36.3,27.32 -FlowableDoAfterNextTest.java,101.1,63.87 -FlowableDoAfterTerminateTest.java,28.3,22.92 -FlowableDoFinally.java,54.1,52.56 -FlowableDoFinallyTest.java,148.4,108.15 -FlowableDoOnEach.java,100.4,64.3 -FlowableDoOnEachTest.java,316.9,195.28 -FlowableDoOnLifecycle.java,36.5,28.98 -FlowableDoOnLifecycleTest.java,44.3,36.95 -FlowableDoOnRequestTest.java,17.7,17.41 -FlowableDoOnSubscribeTest.java,37.5,29.78 -FlowableDoOnTest.java,35.6,24.85 -FlowableDoOnUnsubscribeTest.java,47.1,39.64 -FlowableElementAt.java,36.2,25.02 -FlowableElementAtMaybe.java,35.0,24.28 -FlowableElementAtSingle.java,36.2,28.02 -FlowableElementAtTest.java,104.2,76.86 -FlowableEmitter.java,3.1,9.6 -FlowableEmpty.java,5.9,10.93 -FlowableError.java,13.6,12.39 -FlowableErrorHandlingTests.java,31.3,21.92 -FlowableEventStream.java,29.8,22.05 -FlowableEventStreamTest.java,4.4,9.14 -FlowableFilter.java,46.5,37.8 -FlowableFilterTest.java,189.8,137.7 -FlowableFirstTest.java,238.1,161.18 -FlowableFlatMap.java,242.5,173.86 -FlowableFlatMapCompletable.java,49.9,48.87 -FlowableFlatMapCompletableAsyncPerf.java,25.8,20.89 -FlowableFlatMapCompletableCompletable.java,49.4,46.76 -FlowableFlatMapCompletablePerf.java,25.7,22.4 -FlowableFlatMapCompletableSyncPerf.java,20.8,18.81 -FlowableFlatMapCompletableTest.java,170.7,123.73 -FlowableFlatMapMaybe.java,131.9,91.4 -FlowableFlatMapMaybeEmptyPerf.java,24.9,71.76 -FlowableFlatMapMaybePerf.java,29.0,22.88 -FlowableFlatMapMaybeTest.java,195.6,142.94 -FlowableFlatMapPublisher.java,9.2,14.94 -FlowableFlatMapSingle.java,119.4,83.67 -FlowableFlatMapSinglePerf.java,30.4,23.05 -FlowableFlatMapSingleTest.java,172.6,123.36 -FlowableFlatMapTest.java,470.7,285.81 -FlowableFlattenIterable.java,129.5,97.35 -FlowableFlattenIterableTest.java,335.4,221.48 -FlowableForEachTest.java,22.6,18.89 -FlowableFromArray.java,79.1,62.95 -FlowableFromArrayTest.java,51.4,49.55 -FlowableFromCallable.java,17.4,15.77 -FlowableFromCallableTest.java,82.3,61.71 -FlowableFromFuture.java,17.9,16.38 -FlowableFromIterable.java,123.0,75 -FlowableFromIterableTest.java,276.1,183.3 -FlowableFromObservable.java,13.4,15.01 -FlowableFromObservableTest.java,8.7,11.28 -FlowableFromPublisher.java,6.3,10.31 -FlowableFromSourceTest.java,228.8,164.38 -FlowableFuseableTest.java,39.9,35 -FlowableGenerate.java,50.5,44.19 -FlowableGenerateTest.java,89.1,55.03 -FlowableGroupBy.java,214.2,155.7 -FlowableGroupByTest.java,805.3,440.47 -FlowableGroupByTests.java,31.6,28.46 -FlowableGroupJoin.java,135.3,94.88 -FlowableGroupJoinTest.java,261.4,173.48 -FlowableHide.java,15.2,16.23 -FlowableHideTest.java,29.0,78.46 -FlowableIgnoreElements.java,21.7,19.78 -FlowableIgnoreElementsCompletable.java,17.9,18.51 -FlowableIgnoreElementsTest.java,122.7,68.59 -FlowableInternalHelper.java,105.8,68.56 -FlowableInternalHelperTest.java,6.1,10.11 -FlowableInterval.java,31.9,24.63 -FlowableIntervalRange.java,34.0,29.74 -FlowableIntervalRangeTest.java,40.3,33.91 -FlowableIntervalTest.java,13.7,14.87 -FlowableJoin.java,120.4,83.69 -FlowableJoinTest.java,192.4,141.29 -FlowableJust.java,8.7,11.5 -FlowableLastMaybe.java,22.5,20.32 -FlowableLastSingle.java,28.6,22.98 -FlowableLastTest.java,123.0,88.11 -FlowableLift.java,16.3,14.47 -FlowableLiftTest.java,15.4,13.41 -FlowableLimit.java,36.0,60.16 -FlowableLimitTest.java,60.6,54.13 -FlowableMap.java,44.1,33.4 -FlowableMapNotification.java,34.0,24.34 -FlowableMapNotificationTest.java,51.4,48.98 -FlowableMapPublisher.java,6.6,11.76 -FlowableMapTest.java,199.0,144.74 -FlowableMaterialize.java,14.9,15.6 -FlowableMaterializeTest.java,116.4,78.13 -FlowableMergeDelayErrorTest.java,345.4,239.76 -FlowableMergeMaxConcurrentTest.java,135.3,97.04 -FlowableMergeTest.java,713.6,401.54 -FlowableMergeTests.java,37.7,31.73 -FlowableMergeWithCompletable.java,34.8,28.26 -FlowableMergeWithCompletableTest.java,37.6,31.89 -FlowableMergeWithMaybe.java,121.0,86.89 -FlowableMergeWithMaybeTest.java,125.4,91.06 -FlowableMergeWithSingle.java,109.3,70.39 -FlowableMergeWithSingleTest.java,120.9,87 -FlowableNever.java,5.4,10.41 -FlowableNotificationTest.java,33.9,29.2 -FlowableNullTests.java,java.lang.OutOfMemoryError,OOM -FlowableObserveOn.java,178.7,144.7 -FlowableObserveOnTest.java,702.2,396.71 -FlowableOnBackpressureBuffer.java,71.9,59.49 -FlowableOnBackpressureBufferStrategy.java,58.5,58.45 -FlowableOnBackpressureBufferStrategyTest.java,61.6,57.31 -FlowableOnBackpressureBufferTest.java,119.5,68.83 -FlowableOnBackpressureDrop.java,33.1,26.09 -FlowableOnBackpressureDropTest.java,51.9,48.81 -FlowableOnBackpressureError.java,28.2,23.05 -FlowableOnBackpressureErrorTest.java,15.5,14.4 -FlowableOnBackpressureLatest.java,43.8,40 -FlowableOnBackpressureLatestTest.java,47.2,41.98 -FlowableOnErrorNext.java,36.2,27.39 -FlowableOnErrorResumeNextViaFlowableTest.java,99.6,65.09 -FlowableOnErrorResumeNextViaFunctionTest.java,125.5,92.43 -FlowableOnErrorReturn.java,17.1,17.91 -FlowableOnErrorReturnTest.java,97.8,60.91 -FlowableOnExceptionResumeNextViaFlowableTest.java,117.0,90.64 -FlowableOnSubscribe.java,3.3,8.6 -FlowableOperator.java,3.5,8.88 -FlowableProcessor.java,6.9,11.37 -FlowableProcessorTest.java,12.1,13.69 -FlowablePublish.java,155.7,117.24 -FlowablePublishFunctionTest.java,171.5,128.91 -FlowablePublishMulticast.java,147.7,110.94 -FlowablePublishMulticastTest.java,53.8,52.78 -FlowablePublishTest.java,469.9,280.55 -FlowableRange.java,54.4,54.2 -FlowableRangeLong.java,51.8,52.15 -FlowableRangeLongTest.java,175.5,125.28 -FlowableRangeTest.java,171.3,137.49 -FlowableReduce.java,30.4,26.15 -FlowableReduceMaybe.java,32.8,27.69 -FlowableReduceSeedSingle.java,33.6,25.79 -FlowableReduceTest.java,176.0,131.1 -FlowableReduceTests.java,41.6,33.49 -FlowableReduceWithSingle.java,11.7,14.4 -FlowableReduceWithSingleTest.java,10.2,12.66 -FlowableRefCount.java,55.2,54.77 -FlowableRefCountTest.java,468.6,280.54 -FlowableRepeat.java,29.6,26.53 -FlowableRepeatTest.java,122.3,93.63 -FlowableRepeatUntil.java,30.1,24.24 -FlowableRepeatWhen.java,44.4,39.31 -FlowableReplay.java,327.8,206.34 -FlowableReplayTest.java,880.8,479.78 -FlowableRetryBiPredicate.java,33.1,27 -FlowableRetryPredicate.java,34.1,29.48 -FlowableRetryTest.java,407.4,259.17 -FlowableRetryWhen.java,23.7,21.37 -FlowableRetryWithPredicateTest.java,188.4,136.03 -FlowableSamplePublisher.java,49.4,49.27 -FlowableSampleTest.java,180.8,138.04 -FlowableSampleTimed.java,45.0,41.36 -FlowableScalarXMap.java,41.9,34.38 -FlowableScalarXMapTest.java,57.7,56.19 -FlowableScan.java,30.4,24.63 -FlowableScanSeed.java,59.0,55.39 -FlowableScanTest.java,224.4,162 -FlowableSequenceEqual.java,105.9,69.02 -FlowableSequenceEqualSingle.java,65.5,60.97 -FlowableSequenceEqualTest.java,191.2,151.42 -FlowableSerializeTest.java,122.4,85.95 -FlowableSerialized.java,4.1,10.52 -FlowableSingle.java,33.0,28.04 -FlowableSingleMaybe.java,30.4,25.02 -FlowableSingleSingle.java,31.7,27.63 -FlowableSingleTest.java,279.1,174.07 -FlowableSkip.java,18.8,18.8 -FlowableSkipLast.java,18.9,19.55 -FlowableSkipLastTest.java,54.0,48.75 -FlowableSkipLastTimed.java,52.3,50.27 -FlowableSkipLastTimedTest.java,95.0,62.33 -FlowableSkipTest.java,91.4,61 -FlowableSkipTimedTest.java,54.9,54.29 -FlowableSkipUntil.java,38.4,28.7 -FlowableSkipUntilTest.java,67.0,60.12 -FlowableSkipWhile.java,31.7,22.66 -FlowableSkipWhileTest.java,65.4,60.11 -FlowableStartWithTests.java,28.6,23.16 -FlowableSubscribeOn.java,45.4,34.18 -FlowableSubscribeOnTest.java,132.1,96.35 -FlowableSubscriber.java,3.8,8.79 -FlowableSubscriberTest.java,212.8,153.58 -FlowableSwitchIfEmpty.java,19.9,17.86 -FlowableSwitchIfEmptyTest.java,56.3,54.85 -FlowableSwitchMap.java,126.8,93.79 -FlowableSwitchMapCompletable.java,54.2,51.96 -FlowableSwitchMapCompletablePerf.java,28.0,22.11 -FlowableSwitchMapCompletableTest.java,122.3,86.85 -FlowableSwitchMapMaybe.java,82.1,64.46 -FlowableSwitchMapMaybeEmptyPerf.java,29.4,22.62 -FlowableSwitchMapMaybePerf.java,27.3,21.02 -FlowableSwitchMapMaybeTest.java,193.0,136.65 -FlowableSwitchMapSingle.java,75.1,62.56 -FlowableSwitchMapSinglePerf.java,27.1,22.62 -FlowableSwitchMapSingleTest.java,173.0,130.29 -FlowableSwitchTest.java,508.1,310.86 -FlowableTake.java,31.1,27.07 -FlowableTakeLast.java,37.4,28.79 -FlowableTakeLastOne.java,19.5,17.57 -FlowableTakeLastOneTest.java,43.5,35.89 -FlowableTakeLastTest.java,118.7,71.39 -FlowableTakeLastTimed.java,64.5,59.66 -FlowableTakeLastTimedTest.java,129.1,99.71 -FlowableTakePublisher.java,6.1,11.36 -FlowableTakeTest.java,176.4,132.12 -FlowableTakeTimedTest.java,46.9,41.31 -FlowableTakeUntil.java,32.0,26.8 -FlowableTakeUntilPredicate.java,35.2,24.13 -FlowableTakeUntilPredicateTest.java,64.1,61.08 -FlowableTakeUntilTest.java,173.0,129.98 -FlowableTakeWhile.java,25.7,24.63 -FlowableTakeWhileTest.java,121.4,81.42 -FlowableTests.java,512.4,303.63 -FlowableThrottleFirstTest.java,73.9,61.99 -FlowableThrottleFirstTimed.java,42.8,33.1 -FlowableThrottleLastTests.java,20.1,20.08 -FlowableThrottleLatest.java,51.7,52.25 -FlowableThrottleLatestTest.java,95.6,60.55 -FlowableThrottleWithTimeoutTests.java,24.5,22.08 -FlowableTimeInterval.java,27.7,20.61 -FlowableTimeIntervalTest.java,42.3,36.45 -FlowableTimeout.java,122.2,79.69 -FlowableTimeoutTests.java,233.5,167.49 -FlowableTimeoutTimed.java,85.3,56.84 -FlowableTimeoutWithSelectorTest.java,330.9,204.82 -FlowableTimer.java,22.5,20.63 -FlowableTimerTest.java,122.9,92.59 -FlowableTimestampTest.java,47.4,44.3 -FlowableToCompletableTest.java,33.4,25.97 -FlowableToFutureTest.java,79.4,55 -FlowableToList.java,24.1,21.68 -FlowableToListSingle.java,30.8,24.54 -FlowableToListTest.java,198.1,142.25 -FlowableToMapTest.java,159.0,120.82 -FlowableToMultimapTest.java,236.2,170.03 -FlowableToSingleTest.java,32.9,26.1 -FlowableToSortedListTest.java,122.1,90.54 -FlowableTransformer.java,3.1,8.97 -FlowableUnsubscribeOn.java,26.7,23.6 -FlowableUnsubscribeOnTest.java,82.6,53.94 -FlowableUsing.java,44.6,43.56 -FlowableUsingTest.java,194.9,147.37 -FlowableWindow.java,136.3,109.7 -FlowableWindowBoundary.java,85.4,57.52 -FlowableWindowBoundarySelector.java,123.5,74.17 -FlowableWindowBoundarySupplier.java,110.1,67.8 -FlowableWindowTests.java,15.4,17.38 -FlowableWindowTimed.java,259.6,173.63 -FlowableWindowWithFlowableTest.java,466.6,291.88 -FlowableWindowWithSizeTest.java,169.0,127.78 -FlowableWindowWithStartEndFlowableTest.java,157.7,115.18 -FlowableWindowWithTimeTest.java,349.6,222.59 -FlowableWithLatestFrom.java,40.7,36.68 -FlowableWithLatestFromMany.java,94.5,63.41 -FlowableWithLatestFromTest.java,350.6,210.99 -FlowableZip.java,124.9,87.78 -FlowableZipCompletionTest.java,36.4,34.72 -FlowableZipIterable.java,42.9,36.11 -FlowableZipIterableTest.java,150.6,104.42 -FlowableZipTest.java,894.1,483.21 -FlowableZipTests.java,45.2,38.96 -ForEachWhileObserver.java,27.0,23.61 -ForEachWhileSubscriber.java,31.2,24.22 -FromArrayTckTest.java,3.7,10.58 -FromCallableTckTest.java,5.9,11.24 -FromFutureTckTest.java,9.9,12.24 -FromIterableTckTest.java,6.2,9.84 -Function.java,3.6,8.75 -Function3.java,3.6,8.99 -Function4.java,4.9,9.11 -Function5.java,4.3,9.24 -Function6.java,3.9,9.36 -Function7.java,5.4,9.48 -Function8.java,4.4,9.61 -Function9.java,3.9,9.72 -Functions.java,253.3,167.15 -FunctionsTest.java,90.6,61.06 -FuseToFlowable.java,3.3,8.72 -FuseToMaybe.java,3.1,8.72 -FuseToObservable.java,3.1,8.72 -FutureDisposable.java,7.1,13.66 -FutureDisposableTest.java,23.3,20.13 -FutureObserver.java,45.2,39.29 -FutureObserverTest.java,122.4,78.7 -FutureSingleObserver.java,40.9,34.5 -FutureSingleObserverTest.java,53.1,46.71 -FutureSubscriber.java,43.4,37.84 -FutureSubscriberTest.java,84.4,54.9 -GenerateTckTest.java,7.9,13.29 -GroupByTckTest.java,8.5,12.77 -GroupedFlowable.java,5.6,10.12 -GroupedObservable.java,3.7,10.12 -HalfSerializer.java,35.1,30.02 -HalfSerializerObserverTest.java,80.6,62.74 -HalfSerializerSubscriberTest.java,75.5,55.03 -HasUpstreamCompletableSource.java,2.3,8.65 -HasUpstreamMaybeSource.java,3.8,8.73 -HasUpstreamObservableSource.java,4.0,8.73 -HasUpstreamPublisher.java,3.8,8.73 -HasUpstreamSingleSource.java,3.5,8.73 -HashMapSupplier.java,8.3,11.37 -HideTckTest.java,4.7,10.14 -IgnoreElementsTckTest.java,5.6,10.79 -ImmediateThinScheduler.java,19.6,17.52 -ImmediateThinSchedulerTest.java,21.2,20.64 -InnerQueuedObserver.java,29.9,23.19 -InnerQueuedObserverSupport.java,3.1,9.24 -InnerQueuedSubscriber.java,36.1,30.59 -InnerQueuedSubscriberSupport.java,2.9,9.26 -InnerQueuedSubscriberTest.java,13.6,15.8 -InputWithIncrementingInteger.java,26.7,22.24 -InstantPeriodicTask.java,37.9,26.31 -InstantPeriodicTaskTest.java,87.7,56.82 -IntFunction.java,3.1,8.79 -InternalWrongNaming.java,47.6,43.96 -IntervalRangeTckTest.java,6.1,10.64 -IntervalTckTest.java,6.5,11.13 -IoScheduler.java,64.3,56.66 -IsEmptyTckTest.java,6.8,10.81 -JavadocFindUnescapedAngleBrackets.java,47.3,42.5 -JavadocForAnnotations.java,97.1,62.35 -JavadocWording.java,491.1,299.69 -JustAsyncPerf.java,47.2,42.56 -JustTckTest.java,6.5,10.26 -LambdaConsumerIntrospection.java,3.5,8.47 -LambdaObserver.java,29.9,24.6 -LambdaObserverTest.java,124.1,93.77 -LambdaSubscriber.java,35.4,26.55 -LambdaSubscriberTest.java,120.2,86.52 -LastTckTest.java,4.5,10.79 -LatchedSingleObserver.java,5.7,12.69 -LimitTckTest.java,6.6,10.44 -LinkedArrayList.java,26.2,20.08 -ListAddBiConsumer.java,5.4,11.79 -ListCompositeDisposable.java,48.7,45.08 -ListCompositeDisposableTest.java,120.4,82 -LongConsumer.java,3.3,8.54 -MapTckTest.java,5.2,10.65 -Maybe.java,689.6,382.24 -MaybeAmb.java,40.9,34.58 -MaybeAmbTest.java,41.7,34.46 -MaybeCache.java,52.8,50.59 -MaybeCacheTest.java,93.8,63.57 -MaybeCallbackObserver.java,21.8,21.31 -MaybeCallbackObserverTest.java,44.1,34.68 -MaybeConcatArray.java,39.4,34.22 -MaybeConcatArrayDelayError.java,44.9,37.91 -MaybeConcatArrayTest.java,50.2,47.78 -MaybeConcatIterable.java,46.8,41.48 -MaybeConcatIterableTest.java,48.1,39.91 -MaybeConcatPublisherTest.java,7.3,12.84 -MaybeContains.java,21.6,20.18 -MaybeContainsTest.java,23.3,22.23 -MaybeConverter.java,3.4,8.83 -MaybeCount.java,19.1,17.77 -MaybeCountTest.java,20.1,20.68 -MaybeCreate.java,40.8,32.95 -MaybeCreateTest.java,75.5,60.61 -MaybeDefer.java,5.3,13.86 -MaybeDelay.java,31.3,24.97 -MaybeDelayOtherPublisher.java,40.2,32 -MaybeDelayOtherTest.java,77.9,50.04 -MaybeDelaySubscriptionOtherPublisher.java,35.5,29.44 -MaybeDelaySubscriptionTest.java,40.5,31.87 -MaybeDelayTest.java,33.0,25.6 -MaybeDelayWithCompletable.java,27.4,22.27 -MaybeDetach.java,25.3,21.72 -MaybeDetachTest.java,43.1,38.71 -MaybeDoAfterSuccess.java,21.4,18.52 -MaybeDoAfterSuccessTest.java,37.9,32.51 -MaybeDoFinally.java,21.6,21.27 -MaybeDoFinallyTest.java,39.6,35.23 -MaybeDoOnEvent.java,29.5,23.41 -MaybeDoOnEventTest.java,20.5,20.19 -MaybeEmitter.java,3.7,9.93 -MaybeEmpty.java,5.1,10.88 -MaybeEmptyTest.java,6.8,11.79 -MaybeEqualSingle.java,40.5,36.36 -MaybeEqualTest.java,6.1,13.58 -MaybeError.java,5.2,11.02 -MaybeErrorCallable.java,9.6,13.76 -MaybeErrorTest.java,7.7,10.93 -MaybeFilter.java,28.1,21.82 -MaybeFilterSingle.java,22.2,21.32 -MaybeFilterSingleTest.java,9.2,14.58 -MaybeFlatMapBiSelector.java,40.4,33.81 -MaybeFlatMapBiSelectorTest.java,52.1,52.47 -MaybeFlatMapCompletable.java,25.9,21.36 -MaybeFlatMapCompletableTest.java,17.8,13.94 -MaybeFlatMapIterableFlowable.java,67.8,61.91 -MaybeFlatMapIterableFlowableTest.java,158.2,116.83 -MaybeFlatMapIterableObservable.java,44.9,40.57 -MaybeFlatMapIterableObservableTest.java,111.0,67.14 -MaybeFlatMapNotification.java,40.2,34.72 -MaybeFlatMapNotificationTest.java,43.3,33.22 -MaybeFlatMapObservable.java,26.1,22.95 -MaybeFlatMapObservableTest.java,28.6,21.46 -MaybeFlatMapPublisher.java,29.4,24.8 -MaybeFlatMapPublisherTckTest.java,8.4,12.03 -MaybeFlatMapPublisherTest.java,29.9,23.23 -MaybeFlatMapSingle.java,31.7,69.21 -MaybeFlatMapSingleElement.java,31.2,24.66 -MaybeFlatMapSingleElementTest.java,41.1,34.04 -MaybeFlatMapSingleTest.java,40.9,34.04 -MaybeFlatten.java,29.7,26.43 -MaybeFlattenTest.java,25.9,20.77 -MaybeFromAction.java,14.5,15.82 -MaybeFromActionTest.java,49.2,41.15 -MaybeFromCallable.java,15.2,17.31 -MaybeFromCallableTest.java,50.2,47.6 -MaybeFromCompletable.java,14.4,17.25 -MaybeFromCompletableTest.java,15.5,16.75 -MaybeFromFuture.java,19.3,19.23 -MaybeFromFutureTest.java,32.6,28.89 -MaybeFromRunnable.java,12.8,15.75 -MaybeFromRunnableTest.java,47.1,42.15 -MaybeFromSingle.java,16.7,17.43 -MaybeFromSingleTest.java,16.6,17.26 -MaybeHide.java,13.3,16.49 -MaybeHideTest.java,19.8,18.84 -MaybeIgnoreElement.java,16.9,17.32 -MaybeIgnoreElementCompletable.java,19.9,18.12 -MaybeIgnoreElementTest.java,9.7,13.05 -MaybeIsEmpty.java,12.0,15.99 -MaybeIsEmptySingle.java,20.1,19.8 -MaybeIsEmptySingleTest.java,6.2,11.4 -MaybeIsEmptyTest.java,33.2,28.16 -MaybeJust.java,6.6,11.89 -MaybeJustTest.java,6.0,12.52 -MaybeLift.java,10.4,14.25 -MaybeMap.java,23.2,21.36 -MaybeMapTest.java,8.3,11.27 -MaybeMergeArray.java,127.7,85.28 -MaybeMergeArrayTest.java,81.8,60 -MaybeMergeTest.java,39.2,32.68 -MaybeMergeWithTest.java,4.3,10.27 -MaybeNever.java,5.0,10.25 -MaybeNo2Dot0Since.java,36.7,25.22 -MaybeObserveOn.java,32.3,21.39 -MaybeObserver.java,3.1,9.28 -MaybeOfTypeTest.java,28.6,21.02 -MaybeOnErrorComplete.java,20.9,21.36 -MaybeOnErrorNext.java,35.9,30.36 -MaybeOnErrorReturn.java,22.2,20.82 -MaybeOnErrorXTest.java,54.3,46.88 -MaybeOnSubscribe.java,3.2,8.85 -MaybeOperator.java,4.5,9.15 -MaybePeek.java,43.6,36.51 -MaybePeekTest.java,43.9,35.1 -MaybeRetryTest.java,33.6,28.59 -MaybeSource.java,3.3,8.85 -MaybeSubject.java,80.9,61.79 -MaybeSubjectTest.java,116.7,70.27 -MaybeSubscribeOn.java,22.0,20.83 -MaybeSubscribeOnTest.java,4.6,10.27 -MaybeSwitchIfEmpty.java,30.6,24.83 -MaybeSwitchIfEmptySingle.java,29.3,23.56 -MaybeSwitchIfEmptySingleTest.java,37.2,28.84 -MaybeSwitchIfEmptyTest.java,38.0,29.29 -MaybeTakeUntilMaybe.java,40.5,30.44 -MaybeTakeUntilPublisher.java,40.0,31.28 -MaybeTakeUntilPublisherTest.java,55.6,53.62 -MaybeTakeUntilTest.java,174.6,126.57 -MaybeTest.java,java.lang.OutOfMemoryError,OOM -MaybeTimeoutMaybe.java,45.2,40.53 -MaybeTimeoutPublisher.java,48.4,41.8 -MaybeTimeoutPublisherTest.java,88.2,58.59 -MaybeTimeoutTest.java,121.3,86.15 -MaybeTimer.java,12.9,16.52 -MaybeTimerTest.java,21.2,19.45 -MaybeToCompletableTest.java,13.7,14.45 -MaybeToFlowable.java,17.3,17.01 -MaybeToFlowableTest.java,7.5,13.72 -MaybeToObservable.java,18.5,17.37 -MaybeToObservableTest.java,12.2,13.72 -MaybeToPublisher.java,5.3,11.72 -MaybeToSingle.java,23.8,21.34 -MaybeToSingleTest.java,13.0,15.1 -MaybeTransformer.java,3.5,9.03 -MaybeUnsafeCreate.java,4.0,10.28 -MaybeUnsubscribeOn.java,22.3,20.1 -MaybeUnsubscribeOnTest.java,37.0,30.26 -MaybeUsing.java,52.0,50.72 -MaybeUsingTest.java,153.7,112.35 -MaybeZipArray.java,50.0,48.53 -MaybeZipArrayTest.java,51.2,44.69 -MaybeZipIterable.java,31.9,26.43 -MaybeZipIterableTest.java,77.8,61.62 -MemoryPerf.java,170.3,128.36 -MergeIterableTckTest.java,7.5,11.94 -MergePublisherTckTest.java,6.4,11.68 -MergeTckTest.java,8.3,11.29 -MergeWithCompletableTckTest.java,6.6,10.45 -MergeWithMaybeEmptyTckTest.java,6.4,10.45 -MergeWithMaybeTckTest.java,7.3,12.16 -MergeWithSingleTckTest.java,4.9,11.73 -MergerBiFunction.java,31.0,21.88 -MergerBiFunctionTest.java,36.3,27.84 -MiscUtilTest.java,83.0,57.31 -MissingBackpressureException.java,4.3,9.82 -MpscLinkedQueue.java,37.5,33.68 -MulticastProcessor.java,159.6,108.66 -MulticastProcessorAsPublisherTckTest.java,16.8,18.14 -MulticastProcessorRefCountedTckTest.java,15.1,14.4 -MulticastProcessorTckTest.java,10.5,14.47 -MulticastProcessorTest.java,265.6,168.74 -NewLinesBeforeAnnotation.java,48.6,42.92 -NewThreadScheduler.java,12.5,14.65 -NewThreadSchedulerTest.java,28.8,23.79 -NewThreadWorker.java,43.7,39.76 -NoAnonymousInnerClassesTest.java,30.3,24.23 -NonBlockingThread.java,2.1,8.56 -NonNull.java,3.9,10.7 -Notification.java,35.1,27.18 -NotificationLite.java,50.2,48.93 -NotificationLiteTest.java,37.0,31.33 -NotificationTest.java,24.3,22.83 -Nullable.java,3.9,10.67 -ObjectHelper.java,29.7,21.43 -ObjectHelperTest.java,26.8,23.3 -Observable.java,java.lang.OutOfMemoryError,OOM -ObservableAll.java,26.4,24.94 -ObservableAllSingle.java,27.8,23.78 -ObservableAllTest.java,125.2,85.55 -ObservableAmb.java,54.6,55.47 -ObservableAmbTest.java,143.3,104.47 -ObservableAny.java,27.9,22.43 -ObservableAnySingle.java,30.4,71.69 -ObservableAnyTest.java,228.2,163.09 -ObservableAutoConnect.java,9.7,13.87 -ObservableAutoConnectTest.java,6.0,10.89 -ObservableBlockingSubscribe.java,31.1,25.14 -ObservableBlockingTest.java,109.2,65.74 -ObservableBuffer.java,55.0,52.08 -ObservableBufferBoundary.java,119.4,78.22 -ObservableBufferBoundarySupplier.java,59.6,57.54 -ObservableBufferExactBoundary.java,45.5,42.21 -ObservableBufferTest.java,1173.7,472.77 -ObservableBufferTimed.java,151.1,114.72 -ObservableBufferUntilSubscriberTest.java,30.1,26.35 -ObservableCache.java,104.2,63.37 -ObservableCacheTest.java,132.9,100.04 -ObservableCastTest.java,15.0,17.91 -ObservableCollect.java,29.4,25.5 -ObservableCollectSingle.java,31.9,25.52 -ObservableCollectTest.java,134.0,88.96 -ObservableCombineLatest.java,103.0,72.49 -ObservableCombineLatestTest.java,600.8,327 -ObservableCombineLatestTests.java,28.3,25.91 -ObservableConcatMap.java,154.8,106.18 -ObservableConcatMapCompletable.java,79.9,56.82 -ObservableConcatMapCompletablePerf.java,22.6,22.59 -ObservableConcatMapCompletableTest.java,122.1,88.73 -ObservableConcatMapEager.java,114.2,73.11 -ObservableConcatMapEagerTest.java,438.2,241.9 -ObservableConcatMapMaybe.java,73.0,53.02 -ObservableConcatMapMaybeEmptyPerf.java,27.7,21.83 -ObservableConcatMapMaybePerf.java,28.4,23.02 -ObservableConcatMapMaybeTest.java,128.4,94.86 -ObservableConcatMapSingle.java,66.5,51.69 -ObservableConcatMapSinglePerf.java,28.9,22.92 -ObservableConcatMapSingleTest.java,120.9,80.03 -ObservableConcatMapTest.java,160.3,107.25 -ObservableConcatTest.java,505.1,292.06 -ObservableConcatTests.java,87.3,60.04 -ObservableConcatWithCompletable.java,19.2,20.6 -ObservableConcatWithCompletableTest.java,38.8,36.37 -ObservableConcatWithMaybe.java,22.4,21.91 -ObservableConcatWithMaybeTest.java,44.6,44.37 -ObservableConcatWithSingle.java,21.0,20.91 -ObservableConcatWithSingleTest.java,42.9,38.81 -ObservableConverter.java,3.7,9.05 -ObservableCount.java,14.1,16.17 -ObservableCountSingle.java,20.1,18.52 -ObservableCountTest.java,12.8,15.25 -ObservableCovarianceTest.java,70.0,60.54 -ObservableCreate.java,67.8,50.03 -ObservableCreateTest.java,190.4,137.76 -ObservableDebounce.java,45.4,43.08 -ObservableDebounceTest.java,183.5,126.71 -ObservableDebounceTimed.java,45.0,43.32 -ObservableDefaultIfEmptyTest.java,29.4,23.76 -ObservableDefer.java,9.2,14.02 -ObservableDeferTest.java,35.6,28.36 -ObservableDelay.java,36.8,29.93 -ObservableDelaySubscriptionOther.java,22.8,21.88 -ObservableDelaySubscriptionOtherTest.java,68.8,60.44 -ObservableDelayTest.java,466.4,279.59 -ObservableDematerialize.java,26.2,23.86 -ObservableDematerializeTest.java,60.2,59.32 -ObservableDetach.java,20.7,19.88 -ObservableDetachTest.java,35.5,30.86 -ObservableDistinct.java,35.9,30.9 -ObservableDistinctTest.java,118.7,71.81 -ObservableDistinctUntilChanged.java,31.1,26.48 -ObservableDistinctUntilChangedTest.java,120.8,88.84 -ObservableDoAfterNext.java,14.8,17.5 -ObservableDoAfterNextTest.java,112.8,66.31 -ObservableDoFinally.java,32.9,30.66 -ObservableDoFinallyTest.java,152.9,110.55 -ObservableDoOnEach.java,34.8,32.7 -ObservableDoOnEachTest.java,227.4,158.91 -ObservableDoOnLifecycle.java,10.0,12.51 -ObservableDoOnSubscribeTest.java,41.1,37.8 -ObservableDoOnTest.java,30.8,25.2 -ObservableDoOnUnsubscribeTest.java,42.1,39.45 -ObservableElementAt.java,31.2,25.94 -ObservableElementAtMaybe.java,29.9,21.92 -ObservableElementAtSingle.java,29.6,25.49 -ObservableElementAtTest.java,95.7,60.89 -ObservableEmitter.java,2.7,9.9 -ObservableEmpty.java,4.0,11.4 -ObservableError.java,5.6,13.4 -ObservableErrorHandlingTests.java,32.9,24.56 -ObservableEventStream.java,28.7,22.4 -ObservableFilter.java,18.0,18.62 -ObservableFilterTest.java,40.0,36.12 -ObservableFinallyTest.java,10.6,14.05 -ObservableFirstTest.java,236.0,163.75 -ObservableFlatMap.java,169.7,144.07 -ObservableFlatMapCompletable.java,44.8,42.75 -ObservableFlatMapCompletableCompletable.java,46.2,40.77 -ObservableFlatMapCompletablePerf.java,23.9,22.45 -ObservableFlatMapCompletableTest.java,146.9,104.16 -ObservableFlatMapMaybe.java,94.7,70.19 -ObservableFlatMapMaybeEmptyPerf.java,27.1,23.02 -ObservableFlatMapMaybePerf.java,25.5,23.02 -ObservableFlatMapMaybeTest.java,146.3,103.1 -ObservableFlatMapPerf.java,14.8,18.73 -ObservableFlatMapSingle.java,92.0,60.56 -ObservableFlatMapSinglePerf.java,25.3,23.27 -ObservableFlatMapSingleTest.java,118.6,87.17 -ObservableFlatMapTest.java,462.5,267.85 -ObservableFlattenIterable.java,37.4,30.96 -ObservableFlattenIterableTest.java,21.5,22.47 -ObservableForEachTest.java,43.5,41.95 -ObservableFromArray.java,34.4,23.98 -ObservableFromCallable.java,13.1,16.59 -ObservableFromCallableTest.java,83.8,59.65 -ObservableFromFuture.java,12.5,16.3 -ObservableFromIterable.java,45.1,35.8 -ObservableFromIterableTest.java,113.3,72.39 -ObservableFromPublisher.java,17.4,17.48 -ObservableFromTest.java,28.1,22.26 -ObservableFromUnsafeSource.java,7.0,10.64 -ObservableFuseableTest.java,42.9,33.29 -ObservableGenerate.java,43.7,38.15 -ObservableGenerateTest.java,50.3,43.19 -ObservableGroupBy.java,121.6,79.87 -ObservableGroupByTest.java,541.2,311.71 -ObservableGroupByTests.java,23.3,22.41 -ObservableGroupJoin.java,129.4,95.21 -ObservableGroupJoinTest.java,261.5,170.32 -ObservableHide.java,15.6,17.63 -ObservableHideTest.java,27.0,22.38 -ObservableIgnoreElements.java,11.8,14.54 -ObservableIgnoreElementsCompletable.java,13.7,16.23 -ObservableIgnoreElementsTest.java,55.4,48.66 -ObservableInternalHelper.java,101.4,69.11 -ObservableInternalHelperTest.java,8.9,12.82 -ObservableInterval.java,25.9,22.62 -ObservableIntervalRange.java,31.6,25.44 -ObservableIntervalRangeTest.java,32.0,25.82 -ObservableIntervalTest.java,15.0,14.96 -ObservableJoin.java,121.7,72.4 -ObservableJoinTest.java,182.9,133.26 -ObservableJust.java,5.7,12.68 -ObservableLastMaybe.java,21.6,19.98 -ObservableLastSingle.java,26.8,22.09 -ObservableLastTest.java,122.7,87.81 -ObservableLift.java,11.9,14.67 -ObservableLiftTest.java,8.4,13 -ObservableMap.java,21.6,20.1 -ObservableMapNotification.java,40.3,30.9 -ObservableMapNotificationTest.java,40.6,28.45 -ObservableMapTest.java,122.3,81.96 -ObservableMaterialize.java,18.8,17.48 -ObservableMaterializeTest.java,59.6,53.59 -ObservableMergeDelayErrorTest.java,286.4,182.24 -ObservableMergeMaxConcurrentTest.java,119.0,88.78 -ObservableMergeTest.java,461.7,280.71 -ObservableMergeTests.java,37.4,33.07 -ObservableMergeWithCompletable.java,37.9,27.39 -ObservableMergeWithCompletableTest.java,43.8,32.27 -ObservableMergeWithMaybe.java,59.5,56.96 -ObservableMergeWithMaybeTest.java,96.8,57.98 -ObservableMergeWithSingle.java,57.2,57.37 -ObservableMergeWithSingleTest.java,91.3,55.56 -ObservableMulticastTest.java,3.0,8.77 -ObservableNever.java,6.8,10.83 -ObservableNullTests.java,1286.4,496.93 -ObservableObserveOn.java,98.2,63.56 -ObservableObserveOnTest.java,307.3,192.48 -ObservableOnErrorNext.java,30.4,27.14 -ObservableOnErrorResumeNextViaFunctionTest.java,127.9,89.48 -ObservableOnErrorResumeNextViaObservableTest.java,81.9,58.23 -ObservableOnErrorReturn.java,28.1,23.02 -ObservableOnErrorReturnTest.java,75.7,60.76 -ObservableOnExceptionResumeNextViaObservableTest.java,121.1,79.61 -ObservableOnSubscribe.java,3.3,9.02 -ObservableOperator.java,4.6,9.34 -ObservablePublish.java,98.1,64.31 -ObservablePublishSelector.java,32.1,28.48 -ObservablePublishTest.java,243.9,170.21 -ObservableQueueDrain.java,5.1,9.7 -ObservableRange.java,34.3,26.37 -ObservableRangeLong.java,30.6,26.02 -ObservableRangeLongTest.java,62.6,55.87 -ObservableRangeTest.java,51.1,46.84 -ObservableRedoTest.java,12.1,15.13 -ObservableReduceMaybe.java,34.0,27.55 -ObservableReduceSeedSingle.java,31.1,24.16 -ObservableReduceTest.java,128.8,93.79 -ObservableReduceTests.java,39.0,36.48 -ObservableReduceWithSingle.java,11.5,14.28 -ObservableRefCount.java,57.2,55.42 -ObservableRefCountTest.java,467.2,276.31 -ObservableRepeat.java,26.3,25.08 -ObservableRepeatTest.java,121.6,79.37 -ObservableRepeatUntil.java,26.0,74.93 -ObservableRepeatWhen.java,42.6,37.21 -ObservableReplay.java,267.4,180.44 -ObservableReplayTest.java,761.4,417.04 -ObservableResourceWrapperTest.java,18.6,18.62 -ObservableRetryBiPredicate.java,35.3,24.67 -ObservableRetryPredicate.java,33.1,28.13 -ObservableRetryTest.java,405.1,241.37 -ObservableRetryWhen.java,44.5,37.49 -ObservableRetryWithPredicateTest.java,177.9,131.1 -ObservableSampleTest.java,175.6,134.83 -ObservableSampleTimed.java,40.7,36.63 -ObservableSampleWithObservable.java,49.7,43.99 -ObservableScalarXMap.java,54.3,51.94 -ObservableScalarXMapTest.java,54.7,53.58 -ObservableScan.java,33.4,25.04 -ObservableScanSeed.java,31.2,27.81 -ObservableScanTest.java,131.1,93.94 -ObservableScanTests.java,12.4,13.63 -ObservableSequenceEqual.java,92.7,53.29 -ObservableSequenceEqualSingle.java,86.9,62.38 -ObservableSequenceEqualTest.java,132.2,99.67 -ObservableSerializeTest.java,116.6,80.57 -ObservableSerialized.java,7.1,10.92 -ObservableSingleMaybe.java,30.3,23.5 -ObservableSingleSingle.java,29.7,25.6 -ObservableSingleTest.java,201.0,146.32 -ObservableSkip.java,21.3,17.93 -ObservableSkipLast.java,20.6,18.64 -ObservableSkipLastTest.java,56.3,49.45 -ObservableSkipLastTimed.java,51.9,44.36 -ObservableSkipLastTimedTest.java,105.2,60.43 -ObservableSkipTest.java,80.4,62.24 -ObservableSkipTimedTest.java,56.8,53.37 -ObservableSkipUntil.java,34.8,26.98 -ObservableSkipUntilTest.java,65.0,61.11 -ObservableSkipWhile.java,24.1,22.55 -ObservableSkipWhileTest.java,68.1,61.89 -ObservableSource.java,3.8,9.18 -ObservableStartWithTests.java,32.1,22.96 -ObservableSubscribeOn.java,22.1,21.05 -ObservableSubscribeOnTest.java,50.8,53.47 -ObservableSubscriberTest.java,48.2,47.15 -ObservableSwitchIfEmpty.java,18.5,18.23 -ObservableSwitchIfEmptyTest.java,28.9,24.89 -ObservableSwitchMap.java,122.0,80.03 -ObservableSwitchMapCompletable.java,52.2,53.47 -ObservableSwitchMapCompletablePerf.java,24.8,22.6 -ObservableSwitchMapCompletableTest.java,130.6,97.86 -ObservableSwitchMapMaybe.java,72.3,53.27 -ObservableSwitchMapMaybeEmptyPerf.java,28.4,21.87 -ObservableSwitchMapMaybePerf.java,25.8,23.11 -ObservableSwitchMapMaybeTest.java,196.3,145.24 -ObservableSwitchMapSingle.java,63.0,62.11 -ObservableSwitchMapSinglePerf.java,29.5,23.02 -ObservableSwitchMapSingleTest.java,184.1,136.53 -ObservableSwitchTest.java,499.2,293.29 -ObservableTake.java,29.0,24.02 -ObservableTakeLast.java,29.3,23.02 -ObservableTakeLastOne.java,20.1,18 -ObservableTakeLastOneTest.java,34.8,27.82 -ObservableTakeLastTest.java,84.6,61.77 -ObservableTakeLastTimed.java,48.2,45.69 -ObservableTakeLastTimedTest.java,124.0,79.61 -ObservableTakeTest.java,145.0,106.4 -ObservableTakeTimedTest.java,46.6,41.45 -ObservableTakeUntil.java,33.7,27.16 -ObservableTakeUntilPredicate.java,30.0,24.74 -ObservableTakeUntilPredicateTest.java,59.3,56.53 -ObservableTakeUntilTest.java,167.7,121.93 -ObservableTakeWhile.java,27.6,22.88 -ObservableTakeWhileTest.java,121.8,68.53 -ObservableTest.java,526.4,311.05 -ObservableThrottleFirstTest.java,71.3,61.08 -ObservableThrottleFirstTimed.java,35.5,28.53 -ObservableThrottleLastTests.java,20.3,20.53 -ObservableThrottleLatest.java,45.4,42.42 -ObservableThrottleLatestTest.java,59.4,55.85 -ObservableThrottleWithTimeoutTests.java,23.8,22.54 -ObservableTimeInterval.java,22.3,22.08 -ObservableTimeIntervalTest.java,43.7,35.98 -ObservableTimeout.java,118.9,75.07 -ObservableTimeoutTests.java,230.7,169.29 -ObservableTimeoutTimed.java,87.1,56.52 -ObservableTimeoutWithSelectorTest.java,326.1,197.81 -ObservableTimer.java,17.6,18.61 -ObservableTimerTest.java,120.4,86.18 -ObservableTimestampTest.java,48.1,44.22 -ObservableToFlowabeTestSync.java,49.8,39.51 -ObservableToFutureTest.java,51.5,45.23 -ObservableToList.java,31.0,23.45 -ObservableToListSingle.java,31.0,23.79 -ObservableToListTest.java,123.3,86.86 -ObservableToMapTest.java,160.1,120.19 -ObservableToMultimapTest.java,240.3,168.53 -ObservableToSortedListTest.java,83.6,53.75 -ObservableToXTest.java,20.5,19.91 -ObservableTransformer.java,3.7,9.28 -ObservableUnsubscribeOn.java,26.5,22.09 -ObservableUnsubscribeOnTest.java,81.1,53.28 -ObservableUsing.java,48.6,40.01 -ObservableUsingTest.java,189.1,137.4 -ObservableWindow.java,57.0,55.07 -ObservableWindowBoundary.java,79.7,63.39 -ObservableWindowBoundarySelector.java,115.1,70.85 -ObservableWindowBoundarySupplier.java,96.6,63.81 -ObservableWindowTests.java,14.4,17.26 -ObservableWindowTimed.java,221.4,156.08 -ObservableWindowWithObservableTest.java,444.3,275.1 -ObservableWindowWithSizeTest.java,138.5,98.74 -ObservableWindowWithStartEndObservableTest.java,155.6,113.87 -ObservableWindowWithTimeTest.java,275.7,176.21 -ObservableWithLatestFrom.java,38.2,34.55 -ObservableWithLatestFromMany.java,90.9,60.62 -ObservableWithLatestFromTest.java,238.0,159.54 -ObservableZip.java,95.0,64.24 -ObservableZipCompletionTest.java,38.8,35.24 -ObservableZipIterable.java,47.7,37.5 -ObservableZipIterableTest.java,149.2,110.17 -ObservableZipTest.java,659.2,368.5 -ObservableZipTests.java,45.0,40.98 -ObserveOnTckTest.java,6.4,11.52 -Observer.java,5.2,9.57 -ObserverFusion.java,33.6,22.84 -ObserverResourceWrapper.java,18.5,17.13 -OnBackpressureBufferTckTest.java,5.5,10.57 -OnErrorNotImplementedException.java,9.3,12.27 -OnErrorNotImplementedExceptionTest.java,35.0,29.07 -OnErrorResumeNextTckTest.java,5.1,10.93 -OnErrorReturnItemTckTest.java,5.9,10.71 -OnNextValueTest.java,36.6,27.56 -OpenHashSet.java,52.7,50.88 -OpenHashSetTest.java,17.0,15.22 -OperatorFlatMapPerf.java,22.5,21.3 -OperatorMergePerf.java,53.3,50.17 -OperatorsAreFinal.java,37.8,27.01 -ParallelCollect.java,43.2,32.63 -ParallelCollectTest.java,46.3,37.96 -ParallelConcatMap.java,20.0,17.72 -ParallelDoOnNextTry.java,76.1,61.99 -ParallelDoOnNextTryTest.java,123.6,76.92 -ParallelFailureHandling.java,4.1,9.84 -ParallelFilter.java,49.9,44.06 -ParallelFilterTest.java,36.5,26.45 -ParallelFilterTry.java,61.4,60.06 -ParallelFilterTryTest.java,114.0,74.06 -ParallelFlatMap.java,14.6,17.32 -ParallelFlowable.java,183.5,129.05 -ParallelFlowableConverter.java,3.9,9.26 -ParallelFlowableTest.java,497.4,291.41 -ParallelFromArray.java,9.9,14.24 -ParallelFromPublisher.java,126.9,86.83 -ParallelFromPublisherTest.java,47.0,42.73 -ParallelInvalid.java,9.7,13.53 -ParallelJoin.java,189.6,120.95 -ParallelJoinTest.java,89.3,57.86 -ParallelMap.java,50.0,49.9 -ParallelMapTest.java,45.8,38.73 -ParallelMapTry.java,80.1,61.2 -ParallelMapTryTest.java,121.1,69.29 -ParallelPeek.java,50.6,49.13 -ParallelPeekTest.java,46.9,42.07 -ParallelPerf.java,37.9,28.01 -ParallelReduce.java,40.3,33.83 -ParallelReduceFull.java,70.5,60.31 -ParallelReduceFullTest.java,47.0,37.71 -ParallelReduceTest.java,48.0,41.08 -ParallelRunOn.java,135.9,86.22 -ParallelRunOnTest.java,95.7,60.89 -ParallelSortedJoin.java,103.0,62.59 -ParallelSortedJoinTest.java,54.0,53.48 -ParallelTransformer.java,4.0,9.3 -ParamValidationCheckerTest.java,931.9,497.77 -PerfAsyncConsumer.java,13.4,18.85 -PerfBoundedSubscriber.java,11.2,13.45 -PerfConsumer.java,12.8,14.45 -PerfInteropConsumer.java,12.4,14.45 -PerfObserver.java,10.9,13.41 -PerfSubscriber.java,11.3,13.45 -Pow2.java,9.3,12.27 -Predicate.java,3.8,9.2 -ProtocolViolationException.java,3.8,9.75 -PublicFinalMethods.java,12.3,16.19 -PublishProcessor.java,89.4,61.1 -PublishProcessorAsPublisherTckTest.java,18.3,18.72 -PublishProcessorPerf.java,32.7,25.56 -PublishProcessorTest.java,216.9,154.63 -PublishSelectorTckTest.java,6.5,11.88 -PublishSubject.java,71.6,60.2 -PublishSubjectTest.java,194.2,144.5 -PublishTckTest.java,6.9,10.87 -QueueDisposable.java,3.9,9.21 -QueueDrain.java,5.7,10.18 -QueueDrainHelper.java,118.9,75.6 -QueueDrainHelperTest.java,194.1,146.46 -QueueDrainObserver.java,40.2,29.29 -QueueDrainObserverTest.java,48.6,40.55 -QueueDrainSubscriber.java,47.5,40.96 -QueueDrainSubscriberTest.java,110.2,76.63 -QueueFuseable.java,4.5,10.33 -QueueSubscription.java,3.9,9.08 -QueueSubscriptionTest.java,17.4,19.03 -RangePerf.java,25.6,22.17 -RangeTckTest.java,5.4,10.54 -RebatchRequestsTckTest.java,6.2,10.77 -ReducePerf.java,26.8,21.21 -ReduceTckTest.java,5.2,12.61 -ReduceWithTckTest.java,10.4,13.19 -RefCountProcessor.java,56.1,51.18 -ReferenceDisposable.java,10.0,14.56 -RepeatTckTest.java,6.4,10.47 -ReplayProcessor.java,331.6,200.75 -ReplayProcessorBoundedConcurrencyTest.java,172.7,135 -ReplayProcessorConcurrencyTest.java,135.7,98.98 -ReplayProcessorSizeBoundAsPublisherTckTest.java,11.7,15.73 -ReplayProcessorTest.java,660.6,374.36 -ReplayProcessorTimeBoundAsPublisherTckTest.java,12.3,16.86 -ReplayProcessorUnboundedAsPublisherTckTest.java,18.4,15.78 -ReplaySelectorTckTest.java,8.4,11.92 -ReplaySubject.java,348.2,212.18 -ReplaySubjectBoundedConcurrencyTest.java,178.1,133.38 -ReplaySubjectConcurrencyTest.java,134.7,104.5 -ReplaySubjectTest.java,489.5,296.37 -ReplayTckTest.java,5.6,10.96 -ResettableConnectable.java,4.1,9.37 -ResourceCompletableObserver.java,13.3,16.65 -ResourceCompletableObserverTest.java,53.0,47.24 -ResourceMaybeObserver.java,16.1,15.3 -ResourceMaybeObserverTest.java,80.4,53.15 -ResourceObserver.java,11.5,16.65 -ResourceObserverTest.java,55.9,51.45 -ResourceSingleObserver.java,14.7,15.37 -ResourceSingleObserverTest.java,51.7,51.88 -ResourceSubscriber.java,17.2,18.13 -ResourceSubscriberTest.java,66.1,59.59 -ResumeSingleObserver.java,10.0,13.47 -Retry.java,22.3,20.15 -RetryTckTest.java,6.4,10.79 -RunnableDisposable.java,7.7,12.07 -RxJavaPlugins.java,261.3,173.7 -RxJavaPluginsTest.java,500.0,311.7 -RxThreadFactory.java,13.5,18.66 -RxThreadFactoryTest.java,9.0,12.8 -RxVsStreamPerf.java,33.9,26.57 -SafeObserver.java,51.2,48.03 -SafeObserverTest.java,315.1,194.31 -SafeSubscriber.java,51.6,52.29 -SafeSubscriberTest.java,394.5,239.78 -SafeSubscriberWithPluginTest.java,66.3,60.72 -ScalarCallable.java,3.7,9.32 -ScalarSubscription.java,22.6,22.74 -ScalarSubscriptionTest.java,15.3,14.31 -ScalarXMapZHelper.java,41.5,35.24 -ScalarXMapZHelperTest.java,5.1,9.83 -ScanTckTest.java,9.3,12.16 -ScheduledDirectPeriodicTask.java,9.9,12.95 -ScheduledDirectPeriodicTaskTest.java,11.1,13.47 -ScheduledDirectTask.java,9.5,12.51 -ScheduledRunnable.java,41.8,37.35 -ScheduledRunnableTest.java,130.5,101.95 -Scheduler.java,64.4,58.92 -SchedulerLifecycleTest.java,45.1,41.4 -SchedulerMultiWorkerSupport.java,4.3,9.66 -SchedulerMultiWorkerSupportTest.java,43.4,38.17 -SchedulerPoolFactory.java,40.9,33.38 -SchedulerPoolFactoryTest.java,37.2,32.48 -SchedulerRunnableIntrospection.java,2.7,9.36 -SchedulerSupport.java,6.3,11.81 -SchedulerTest.java,117.2,76.67 -SchedulerTestHelper.java,42.5,35.67 -SchedulerWhen.java,53.0,50.55 -SchedulerWhenTest.java,121.8,88.1 -SchedulerWorkerTest.java,46.3,41.81 -Schedulers.java,34.4,27.52 -SequenceEqualTckTest.java,6.4,11.91 -SequentialDisposable.java,12.0,14.24 -SequentialDisposableTest.java,60.8,55.12 -SerialDisposable.java,13.8,15.76 -SerialDisposableTests.java,74.8,60.93 -SerializedObserver.java,46.6,41.22 -SerializedObserverTest.java,422.1,263.88 -SerializedProcessor.java,47.1,43.39 -SerializedProcessorTest.java,376.2,232.59 -SerializedSubject.java,49.7,44.48 -SerializedSubjectTest.java,372.4,231.76 -SerializedSubscriber.java,44.0,40.83 -SerializedSubscriberTest.java,427.4,257.78 -ShareTckTest.java,3.8,10.79 -SimplePlainQueue.java,4.1,9.42 -SimpleQueue.java,5.1,9.97 -SimpleQueueTest.java,57.0,54.61 -Single.java,543.5,321.63 -SingleAmb.java,37.6,37.11 -SingleAmbTest.java,108.9,70.9 -SingleCache.java,49.6,47.81 -SingleCacheTest.java,27.0,23.75 -SingleConcatPublisherTest.java,4.9,13.35 -SingleConcatTest.java,57.3,51.7 -SingleContains.java,19.6,17.08 -SingleContainstTest.java,10.2,13.22 -SingleConverter.java,4.2,9.43 -SingleCreate.java,36.6,31.28 -SingleCreateTest.java,87.7,64.61 -SingleDefer.java,9.4,14.34 -SingleDeferTest.java,10.6,13.12 -SingleDelay.java,23.6,21.99 -SingleDelayTest.java,96.7,60.28 -SingleDelayWithCompletable.java,17.5,18.65 -SingleDelayWithObservable.java,21.7,21.79 -SingleDelayWithPublisher.java,30.4,23.31 -SingleDelayWithSingle.java,17.6,18.32 -SingleDetach.java,21.2,20.14 -SingleDetachTest.java,36.9,31.85 -SingleDoAfterSuccess.java,20.7,18.42 -SingleDoAfterSuccessTest.java,37.1,28.66 -SingleDoAfterTerminate.java,20.2,19.15 -SingleDoAfterTerminateTest.java,32.0,26.93 -SingleDoFinally.java,22.0,21.25 -SingleDoFinallyTest.java,19.6,21.21 -SingleDoOnDispose.java,23.4,20.3 -SingleDoOnError.java,13.8,16.02 -SingleDoOnEvent.java,23.2,17.29 -SingleDoOnSubscribe.java,21.9,18.36 -SingleDoOnSuccess.java,17.3,16.02 -SingleDoOnTest.java,111.5,70.53 -SingleEmitter.java,5.7,10.25 -SingleEquals.java,30.8,22.83 -SingleEqualsTest.java,8.7,13.85 -SingleError.java,10.0,13.72 -SingleErrorTest.java,6.5,11.42 -SingleFlatMap.java,33.7,24.95 -SingleFlatMapCompletable.java,23.9,21.85 -SingleFlatMapCompletableTest.java,7.1,11.65 -SingleFlatMapFlowableTckTest.java,9.7,12.53 -SingleFlatMapIterableFlowable.java,73.0,61.01 -SingleFlatMapIterableFlowableTest.java,166.4,122.36 -SingleFlatMapIterableObservable.java,43.5,38.81 -SingleFlatMapIterableObservableTest.java,111.0,64.9 -SingleFlatMapMaybe.java,32.7,27.42 -SingleFlatMapMaybeTest.java,41.8,34.1 -SingleFlatMapObservable.java,29.7,23.36 -SingleFlatMapObservableTest.java,47.7,35.68 -SingleFlatMapPublisher.java,35.8,25.44 -SingleFlatMapTest.java,120.1,62.43 -SingleFromCallable.java,16.0,16.33 -SingleFromCallableTest.java,61.3,59.04 -SingleFromPublisher.java,33.4,25.29 -SingleFromPublisherTest.java,37.9,24.22 -SingleFromTest.java,17.5,15.53 -SingleFromUnsafeSource.java,5.7,10.97 -SingleHide.java,13.3,15.96 -SingleHideTest.java,5.6,14.16 -SingleInternalHelper.java,30.4,23.21 -SingleInternalHelperTest.java,19.2,18.45 -SingleJust.java,7.1,11.58 -SingleLift.java,12.7,12.95 -SingleLiftTest.java,12.3,14.3 -SingleMap.java,19.9,17.85 -SingleMapTest.java,26.8,20.17 -SingleMergeTest.java,44.2,37.21 -SingleMiscTest.java,83.5,63.11 -SingleNever.java,5.4,11.02 -SingleNullTests.java,322.8,201.77 -SingleObserveOn.java,25.4,22.29 -SingleObserveOnTest.java,19.6,15.4 -SingleObserver.java,4.7,9.75 -SingleOnErrorReturn.java,22.9,20.29 -SingleOnErrorXTest.java,25.3,22.3 -SingleOnSubscribe.java,3.2,9.35 -SingleOperator.java,4.8,9.62 -SinglePostCompleteSubscriber.java,34.6,26.1 -SinglePostCompleteSubscriberTest.java,17.5,15.9 -SingleResumeNext.java,24.3,72.47 -SingleRetryTest.java,36.4,28.96 -SingleScheduler.java,57.1,53.29 -SingleSchedulerTest.java,39.4,33.98 -SingleSource.java,4.3,9.33 -SingleSubject.java,63.2,57.7 -SingleSubjectTest.java,86.4,57.13 -SingleSubscribeOn.java,27.0,20.26 -SingleSubscribeOnTest.java,13.6,16.98 -SingleSubscribeTest.java,93.0,59.33 -SingleTakeUntil.java,39.2,35.26 -SingleTakeUntilTest.java,225.2,153.08 -SingleTckTest.java,5.7,11.28 -SingleTest.java,195.5,138.69 -SingleTimeout.java,44.9,37.22 -SingleTimeoutTest.java,55.2,53.46 -SingleTimer.java,13.3,17.07 -SingleTimerTest.java,19.2,19.92 -SingleToFlowable.java,12.8,15.92 -SingleToFlowableTest.java,10.4,12.9 -SingleToObservable.java,15.5,16.57 -SingleToObservableTest.java,9.6,12.75 -SingleTransformer.java,4.0,9.5 -SingleUnsubscribeOn.java,23.9,19.21 -SingleUnsubscribeOnTest.java,35.2,28.18 -SingleUsing.java,51.4,44.35 -SingleUsingTest.java,123.7,78.78 -SingleZipArray.java,47.5,45.2 -SingleZipArrayTest.java,56.1,50.87 -SingleZipIterable.java,32.2,24.27 -SingleZipIterableTest.java,98.0,57.89 -SingleZipTest.java,75.6,62.74 -SkipLastTckTest.java,6.6,11.28 -SkipTckTest.java,7.0,11.07 -SkipUntilTckTest.java,6.9,11.21 -SkipWhileTckTest.java,7.2,11.29 -SortedTckTest.java,6.2,10.8 -SorterFunction.java,7.4,11.78 -SpscArrayQueue.java,38.5,33.89 -SpscLinkedArrayQueue.java,118.9,71.32 -StrictPerf.java,33.0,26.29 -StrictSubscriber.java,26.8,23.31 -StrictSubscriberTest.java,110.9,67.53 -Subject.java,6.1,11.97 -SubjectTest.java,15.3,14.89 -SubscribeOnTckTest.java,7.4,11.27 -SubscribeWithTest.java,18.9,18.37 -SubscriberCompletableObserver.java,11.7,13.41 -SubscriberFusion.java,32.8,27.09 -SubscriberResourceWrapper.java,19.8,19.1 -SubscriberResourceWrapperTest.java,33.7,27.89 -SubscriptionArbiter.java,59.6,60.8 -SubscriptionArbiterTest.java,42.3,39.73 -SubscriptionDisposable.java,4.2,10.94 -SubscriptionHelper.java,46.5,44.81 -SubscriptionHelperTest.java,94.1,66.22 -SuppressAnimalSniffer.java,2.8,10.3 -SwitchIfEmptyTckTest.java,7.1,11.19 -SwitchMapDelayErrorTckTest.java,3.9,11.53 -SwitchMapTckTest.java,4.1,11.52 -SwitchOnNextTckTest.java,7.0,11.24 -TakeLastTckTest.java,3.0,11.29 -TakeTckTest.java,5.4,11.1 -TakeUntilPerf.java,30.7,25.02 -TakeUntilTckTest.java,4.0,11.18 -TakeWhileTckTest.java,3.5,11.32 -TestException.java,4.5,11.96 -TestHelper.java,2184.2,510.72 -TestObserver.java,83.5,62.73 -TestObserverTest.java,537.3,320.37 -TestScheduler.java,41.5,36.98 -TestSchedulerTest.java,116.3,69.82 -TestSubscriber.java,96.7,65.08 -TestSubscriberTest.java,739.1,412.96 -TestingHelper.java,9.1,15.28 -TextualAorAn.java,83.5,54.56 -TimeIntervalTckTest.java,6.2,11.15 -Timed.java,22.5,21.33 -TimedTest.java,41.9,36.83 -TimeoutTckTest.java,7.4,11.3 -TimerTckTest.java,7.7,11.53 -TimestampTckTest.java,7.1,11.11 -ToFlowablePerf.java,36.3,28.15 -ToListTckTest.java,4.8,11.68 -ToMapTckTest.java,8.3,12.12 -ToMultimapTckTest.java,8.0,12.27 -ToSortedListTckTest.java,6.4,11.68 -TooManyEmptyNewLines.java,43.2,37.69 -TrampolineScheduler.java,49.9,44.56 -TrampolineSchedulerInternalTest.java,54.4,51.34 -TrampolineSchedulerTest.java,47.3,42.84 -TransformerTest.java,45.1,40 -UndeliverableException.java,4.9,10.44 -UnicastProcessor.java,124.2,75.64 -UnicastProcessorAsPublisherTckTest.java,10.7,15.81 -UnicastProcessorTckTest.java,13.0,14.92 -UnicastProcessorTest.java,141.0,101.16 -UnicastSubject.java,114.8,72.68 -UnicastSubjectTest.java,144.8,105.28 -UnsubscribeOnTckTest.java,5.6,11.63 -UsingTckTest.java,7.7,12.13 -VolatileSizeArrayList.java,47.8,42.56 -VolatileSizeArrayListTest.java,56.2,52.12 -WindowBoundaryTckTest.java,7.6,13.35 -WindowExactSizeTckTest.java,5.5,12.41 -WithLatestFromTckTest.java,9.6,12.69 -XFlatMapTest.java,190.6,132.48 -XMapYPerf.java,127.6,94.12 -ZipIterableTckTest.java,10.0,14.42 -ZipTckTest.java,9.5,12.99 -ZipWithIterableTckTest.java,7.1,12.84 -ZipWithTckTest.java,10.8,13.28 -package-info.java,3.1,9.03 \ No newline at end of file diff --git a/benchmarks/src/test/result/UcfsSimple/UcfsSimple_java_correct_junit-4-12.csv b/benchmarks/src/test/result/UcfsSimple/UcfsSimple_java_correct_junit-4-12.csv deleted file mode 100644 index 5b299b55d..000000000 --- a/benchmarks/src/test/result/UcfsSimple/UcfsSimple_java_correct_junit-4-12.csv +++ /dev/null @@ -1,5 +0,0 @@ -fileName,processing_tim_avg_20_times_millis,max_heap_size_mbMb -ActiveTestSuite.java,27.95,15.87 -ActiveTestTest.java,33.0,24.41 -After.java,3.2,8.62 -AfterClass.java,3.65,8.66 \ No newline at end of file diff --git a/benchmarks/tokens_count.csv b/benchmarks/tokens_count.csv deleted file mode 100644 index 2e996c1b5..000000000 --- a/benchmarks/tokens_count.csv +++ /dev/null @@ -1 +0,0 @@ -filename,tokens diff --git a/docs/docs/dsl.md b/docs/docs/dsl.md new file mode 100644 index 000000000..5a2a84100 --- /dev/null +++ b/docs/docs/dsl.md @@ -0,0 +1,117 @@ +# Domain Specific Language +The Universal Context-Free Solver provides an intuitive Kotlin-based inner DSL for defining and working with context-free grammars. +It enables developers to describe grammars using natural Kotlin syntax while benefiting from: + +* development tools and syntax analysis from scratch; +* simple (for now) compile-time checks for rules. + +## Grammar + + +Each grammar is defined as a Kotlin class extending the base `Grammar` type and contains information about **non-terminals**, **terminals**, and **production rules**. + + +For example, the following grammar defines a simple language that recognizes a single word "a": + +```kotlin +class AGrammar : Grammar() { + val S by Nt("a").asStart() +} +``` + +The start non-terminal can be set using the `setStart(nt)` method or directly during initialization with `Nt(...).asStart()`. +Currently, only one start non-terminal is supported. + + +## Non-terminals +* Designed as field of `Grammar` for easy monitoring and reuse. +* **Declared** using Kotlin property delegates, e.g., `val S by Nt()`. +* **Initialization**: +* * in corresponds delegate constructor `val AB by Nt(A or B)`; +* * inside the `init` block using the `/=` operator, e.g., `AB /= A or B`. +* * Each non-terminal must be initialized exactly once. + + + +## Terminals +* `Term` is a generic class that can store terminals of any type. For example: +```kotlin +val A = Term("a") +val B = Term(42) +``` +* Terminals are compared based on their content value. +* Initialization: + * * as fields of grammar class, can be reused `val a = Temr("A")`; + * * directly in production `BA \= Term("B") * Term("A")`. +* Strings can be handled without wrapping. For instance, `digit \= "1" or "0"`. + + +## Operations + +| Operation | EBNF | DSL | +|---------------|----------------------------|----------------------------------------------------------------------------| +| Production | A ::= B | val A by Nt(B)  //in grammar class body
A \\= B               //in init block | +| Concatenation | A B | A * B | +| Alternatve | A \| B | A or B | +| Kleene Star | $A^*$ | many(A) | +| Kleene Star+ | $A^+$ | some(A) | +| Optional | A \| $\varepsilon$
A? | opt(A) | + + +Epsilon ($\varepsilon$) - constant terminal with behavior corresponding to the empty string. + + +## Examples + +### Dyck language +These grammars define the Dyck language — all correctly nested parentheses, brackets, and braces. + +#### *EBNF* + +``` +S = S1 | S2 | S3 | ε +S1 = '(' S ')' S +S2 = '[' S ']' S +S3 = '{' S '}' S +``` + +#### *DSL* +```kotlin +class DyckGrammar : Grammar() { + val S by Nt().asStart() + val Round by Nt("(" * S * ")") + val Quadrat by Nt("[" * S * "]") + val Curly by Nt("{" * S * "}") + + init { + //recursive initialization can be only in `init` block + S /= S * (Round or Quadrat or Curly) or Epsilon + } +} +``` + +### A* language + +#### *EBNF* +``` +A = "a" +S = A* +``` +#### *DSL* +Grammar for this language can be described in various ways. + +```kotlin +class AStar : Grammar() { + var A = Term("a") + val S by Nt().asStart(many(A)) + } +``` +or +```kotlin +class AStar : Grammar() { + val S by Nt().asStart() + init { + S /= many("a") + } + } +``` diff --git a/docs/docs/index.md b/docs/docs/index.md new file mode 100644 index 000000000..013b207c9 --- /dev/null +++ b/docs/docs/index.md @@ -0,0 +1,44 @@ +# UCFS + +> Note: project under heavy development! + +## What is UCFS? + +UCFS is an **U**niversal **C**ontext-**F**ree **S**olver: a GLL‑based tool for problems at the intersection of context‑free languages +over edge‑labeled directed graphs. Examples of such problems: + +- Parsing +- Context-free path querying (CFPQ) +- Context-free language reachability (CFL-R) +- static code analysis + +**Highlights** + +* Kotlin implementation with a concise Grammar DSL (EBNF‑friendly). +* Input: arbitrary edge‑labeled directed graphs. +* Output: SPPF -- finite structure for all‑paths queries. + + + +### Repository layout (high‑level) +``` +docs/ # documentation pages +generator/ # Parser & AST node‑class generator +solver/ # Core UCFS logic (GLL + RSM) +test-shared/ # Testcases, grammars, inputs, ANTLR4 comparison + # grammar examples and experiments +``` + +### Requirements +- JDK 11+ (toolchain targets 11). +- Gradle Wrapper included (`./gradlew`). + +### Typical workflow +1) **Describe grammar** in Kotlin DSL. +2) **Load graph** (for now `dot` format is supported). +3) **Run query**. +4) **Inspect results**. + + +## Core Algorithm +UCFS is based on Generalized LL (GLL) parsing algorithm modified to handle language specification in form of Recursive State Machines (RSM-s) and input in form of arbitratry directed edge-labelled graph. Basic ideas described [here](https://arxiv.org/pdf/2312.11925.pdf). \ No newline at end of file diff --git a/docs/mkdocs.yml b/docs/mkdocs.yml new file mode 100644 index 000000000..4cbe86a6e --- /dev/null +++ b/docs/mkdocs.yml @@ -0,0 +1,20 @@ +site_name: Universal Context-Free Solver +site_url: https://formallanguageconstrainedpathquerying.github.io/UCFS/ +theme: + name: material + +markdown_extensions: + - pymdownx.arithmatex: + generic: true + - pymdownx.highlight: + anchor_linenums: true + line_spans: __span + pygments_lang_class: true + - pymdownx.inlinehilite + - pymdownx.snippets + - pymdownx.superfences + + +extra_javascript: + - javascripts/mathjax.js + - https://unpkg.com/mathjax@3/es5/tex-mml-chtml.js diff --git a/docs/run.sh b/docs/run.sh new file mode 100644 index 000000000..237594080 --- /dev/null +++ b/docs/run.sh @@ -0,0 +1 @@ +mkdocs serve --livereload \ No newline at end of file diff --git a/examples/build.gradle.kts b/examples/build.gradle.kts deleted file mode 100644 index 888751046..000000000 --- a/examples/build.gradle.kts +++ /dev/null @@ -1,19 +0,0 @@ -plugins { - java - kotlin("jvm") version "1.9.20" - application -} - -application{ - mainClass = "java8.GeneratorKt" -} -repositories { - mavenCentral() -} - -dependencies { - implementation(project(":solver")) - implementation(project(":generator")) -} - -kotlin { jvmToolchain(11) } diff --git a/examples/src/main/kotlin/dyck/DyckGrammar.kt b/examples/src/main/kotlin/dyck/DyckGrammar.kt deleted file mode 100644 index 7b67f7308..000000000 --- a/examples/src/main/kotlin/dyck/DyckGrammar.kt +++ /dev/null @@ -1,22 +0,0 @@ -package dyck - -import org.ucfs.grammar.combinator.Grammar -import org.ucfs.grammar.combinator.extension.StringExtension.times -import org.ucfs.grammar.combinator.regexp.Epsilon -import org.ucfs.grammar.combinator.regexp.Nt -import org.ucfs.grammar.combinator.regexp.or -import org.ucfs.grammar.combinator.regexp.times - -class DyckGrammar : Grammar() { - val S by Nt().asStart() - val Round by Nt("(" * S * ")") - val Quadrat by Nt() - val Curly by Nt("{" * S * "}") - - init { - S /= S * (Round or Quadrat or Curly) or Epsilon - Round /= "(" * S * ")" - Quadrat /= "[" * S * "]" - Curly /= "{" * S * "}" - } -} \ No newline at end of file diff --git a/runTests.sh b/runTests.sh deleted file mode 100644 index e69de29bb..000000000 diff --git a/settings.gradle.kts b/settings.gradle.kts index 9d660d937..a77d71c5f 100644 --- a/settings.gradle.kts +++ b/settings.gradle.kts @@ -3,7 +3,5 @@ plugins { } rootProject.name = "ucfs" include("solver") -include("benchmarks") include("generator") -include("test-shared") -include("examples") +include("test-shared") \ No newline at end of file diff --git a/src/main/kotlin/org/kotgll/Main.kt b/src/main/kotlin/org/kotgll/Main.kt deleted file mode 100644 index 72e031827..000000000 --- a/src/main/kotlin/org/kotgll/Main.kt +++ /dev/null @@ -1,117 +0,0 @@ -package org.kotgll - -import kotlinx.cli.ArgParser -import kotlinx.cli.ArgType -import kotlinx.cli.default -import kotlinx.cli.required -import org.kotgll.cfg.grammar.readCFGFromTXT -import org.kotgll.graph.readGraphFromCSV -import org.kotgll.rsm.grammar.readRSMFromTXT -import java.io.File - -enum class InputMode { - STRING, - GRAPH, -} - -enum class GrammarMode { - CFG, - RSM, -} - -enum class SPPFMode { - ON, - OFF, -} - -fun main(args: Array) { - val parser = ArgParser("kotgll") - val inputMode by - parser - .option(ArgType.Choice(), fullName = "input", description = "Input format") - .required() - val grammarMode by - parser - .option( - ArgType.Choice(), fullName = "grammar", description = "Grammar format") - .required() - val sppfMode by - parser - .option(ArgType.Choice(), fullName = "sppf", description = "Sppf mode") - .default(SPPFMode.ON) - val pathToInput by - parser - .option(ArgType.String, fullName = "inputPath", description = "Path to input txt file") - .required() - val pathToGrammar by - parser - .option( - ArgType.String, fullName = "grammarPath", description = "Path to grammar txt file") - .required() - val pathToOutput by - parser - .option(ArgType.String, fullName = "outputPath", description = "Path to output txt file") - .required() - - parser.parse(args) - - if (inputMode == InputMode.STRING) { - val input = File(pathToInput).readText() - if (grammarMode == GrammarMode.CFG) { - val grammar = readCFGFromTXT(pathToGrammar) - if (sppfMode == SPPFMode.ON) { - val result = org.kotgll.cfg.stringinput.withsppf.GLL(grammar, input).parse() - File(pathToOutput).printWriter().use { out -> out.println(result != null) } - } else if (sppfMode == SPPFMode.OFF) { - val result = org.kotgll.cfg.stringinput.withoutsppf.GLL(grammar, input).parse() - File(pathToOutput).printWriter().use { out -> out.println(result) } - } - } else if (grammarMode == GrammarMode.RSM) { - val grammar = readRSMFromTXT(pathToGrammar) - if (sppfMode == SPPFMode.ON) { - val result = org.kotgll.rsm.stringinput.withsppf.GLL(grammar, input).parse() - File(pathToOutput).printWriter().use { out -> out.println(result != null) } - } else if (sppfMode == SPPFMode.OFF) { - val result = org.kotgll.rsm.stringinput.withoutsppf.GLL(grammar, input).parse() - File(pathToOutput).printWriter().use { out -> out.println(result) } - } - } - } else if (inputMode == InputMode.GRAPH) { - val graph = readGraphFromCSV(pathToInput) - if (grammarMode == GrammarMode.CFG) { - val grammar = readCFGFromTXT(pathToGrammar) - if (sppfMode == SPPFMode.ON) { - val result = org.kotgll.cfg.graphinput.withsppf.GLL(grammar, graph).parse() - File(pathToOutput).printWriter().use { out -> - result.keys.forEach { tail -> - result[tail]!!.keys.forEach { head -> out.println("$tail $head") } - } - } - } else if (sppfMode == SPPFMode.OFF) { - val result = org.kotgll.cfg.graphinput.withoutsppf.GLL(grammar, graph).parse() - File(pathToOutput).printWriter().use { out -> - result.keys.forEach { tail -> - result[tail]!!.forEach { head -> out.println("$tail $head") } - } - } - } - } else if (grammarMode == GrammarMode.RSM) { - val grammar = readRSMFromTXT(pathToGrammar) - if (sppfMode == SPPFMode.ON) { - val result = org.kotgll.rsm.graphinput.withsppf.GLL(grammar, graph).parse() - File(pathToOutput).printWriter().use { out -> - result.keys.forEach { tail -> - result[tail]!!.keys.forEach { head -> out.println("$tail $head") } - } - } - } else if (sppfMode == SPPFMode.OFF) { - val result = org.kotgll.rsm.graphinput.withoutsppf.GLL(grammar, graph).parse() - File(pathToOutput).printWriter().use { out -> - result.keys.forEach { tail -> - result[tail]!!.forEach { head -> out.println("$tail $head") } - } - } - } - } - } -} diff --git a/src/main/kotlin/org/kotgll/benchmarks/Benchmarks.kt b/src/main/kotlin/org/kotgll/benchmarks/Benchmarks.kt deleted file mode 100644 index 5f4883901..000000000 --- a/src/main/kotlin/org/kotgll/benchmarks/Benchmarks.kt +++ /dev/null @@ -1,339 +0,0 @@ -package org.kotgll.benchmarks - -import kotlinx.cli.ArgParser -import kotlinx.cli.ArgType -import kotlinx.cli.default -import kotlinx.cli.required -import org.kotgll.cfg.grammar.readCFGFromTXT -import org.kotgll.graph.readGraphFromCSV -import org.kotgll.graph.readStartNodesFromCSV -import org.kotgll.rsm.grammar.readRSMFromTXT -import java.io.File -import kotlin.system.measureNanoTime - -fun getResultPath( - pathToOutput: String, - graph: String, - grammarMode: String = "cfg", - grammarName: String, - sppfMode: String, - chunkSize: Int, -): String { - return pathToOutput + - (if (pathToOutput.endsWith("/")) "" else "/") + - "${graph}_${grammarMode}_${grammarName}_${sppfMode}_${chunkSize}.csv" -} - -enum class GrammarMode { - CFG, - RSM, -} - -enum class SPPFMode { - ON, - OFF, -} - -fun main(args: Array) { - val parser = ArgParser("kotgll.benchmarks") - val grammarMode by - parser - .option( - ArgType.Choice(), fullName = "grammar", description = "Grammar format") - .required() - val sppfMode by - parser - .option(ArgType.Choice(), fullName = "sppf", description = "Sppf mode") - .default(SPPFMode.ON) - val pathToGraphs by - parser - .option( - ArgType.String, fullName = "graphsPath", description = "Path to folder with graphs") - .required() - val pathToStartNodes by - parser - .option( - ArgType.String, - fullName = "startNodesPath", - description = "Path to folder with start nodes for each graph") - .default("") - val pathToGrammar by - parser - .option( - ArgType.String, fullName = "grammarPath", description = "Path to grammar txt file") - .required() - val pathToOutput by - parser - .option( - ArgType.String, fullName = "outputPath", description = "Path to folder with results") - .required() - val warmUpRounds by - parser - .option(ArgType.Int, fullName = "warmUpRounds", description = "Number of warm-up rounds") - .default(3) - val benchmarksRounds by - parser - .option( - ArgType.Int, fullName = "benchmarkRounds", description = "Number of benchmark rounds") - .default(10) - val chunkSize by - parser - .option(ArgType.Int, fullName = "chunkSize", description = "Start nodes chunk size") - .default(10) - - parser.parse(args) - - if (grammarMode == GrammarMode.CFG) { - if (sppfMode == SPPFMode.ON) { - runCFGWithSPPF(pathToGraphs, - pathToStartNodes, pathToGrammar, pathToOutput, warmUpRounds, benchmarksRounds, chunkSize) - } else if (sppfMode == SPPFMode.OFF) { - runCFGWithoutSPPF( - pathToGraphs, - pathToStartNodes, - pathToGrammar, - pathToOutput, - warmUpRounds, - benchmarksRounds, - chunkSize) - } - } else if (grammarMode == GrammarMode.RSM) { - if (sppfMode == SPPFMode.ON) { - runRSMWithSPPF(pathToGraphs, - pathToStartNodes, pathToGrammar, pathToOutput, warmUpRounds, benchmarksRounds, chunkSize) - } else if (sppfMode == SPPFMode.OFF) { - runRSMWithoutSPPF(pathToGraphs, pathToStartNodes, pathToGrammar, pathToOutput, warmUpRounds, benchmarksRounds, - chunkSize) - } - } -} - -fun runCFGWithoutSPPF( - pathToGraphs: String, - pathToStartNodes: String, - pathToCFG: String, - pathToOutput: String, - warmUpRounds: Int, - benchmarkRounds: Int, - chunkSize: Int -) { - val cfg = readCFGFromTXT(pathToCFG) - val cfgName = File(pathToCFG).nameWithoutExtension - File(pathToGraphs) - .walk() - .filter { it.isFile } - .forEach { graphPath -> - val graphName = graphPath.nameWithoutExtension - println("start:: $graphName") - val graph = readGraphFromCSV(graphPath.path) - val startNodes = readStartNodesFromCSV("$pathToStartNodes/$graphName.csv") - - val resultPath = getResultPath(pathToOutput, graphName, "cfg", cfgName, "without_sppf", chunkSize) - File(resultPath).writeText("") - - for (chunkStart in 0..> - val elapsed = measureNanoTime { - result = - org.kotgll.cfg.graphinput.withoutsppf - .GLL(cfg, graph.subList(chunkStart, chunkEnd)) - .parse() - } - val elapsedSeconds = elapsed.toDouble() / 1_000_000_000.0 - - var number = 0 - result.keys.forEach { key -> number += result[key]!!.size } - - println("warmup:: $graphName $cfgName ${number} $elapsedSeconds") - } - - for (benchmarkAttempt in 1..benchmarkRounds) { - var result: HashMap> - val elapsed = measureNanoTime { - result = - org.kotgll.cfg.graphinput.withoutsppf - .GLL(cfg, graph.subList(chunkStart, chunkEnd)) - .parse() - } - val elapsedSeconds = elapsed.toDouble() / 1_000_000_000.0 - - var number = 0 - result.keys.forEach { key -> number += result[key]!!.size } - - println("benchmark:: $graphName $cfgName ${number} $elapsedSeconds") - File(resultPath).appendText(elapsed.toString() + "\n") - } - } - } -} - -fun runCFGWithSPPF( - pathToGraphs: String, - pathToStartNodes: String, - pathToCFG: String, - pathToOutput: String, - warmUpRounds: Int, - benchmarkRounds: Int, - chunkSize: Int -) { - val cfg = readCFGFromTXT(pathToCFG) - val cfgName = File(pathToCFG).nameWithoutExtension - File(pathToGraphs) - .walk() - .filter { it.isFile } - .forEach { graphPath -> - val graphName = graphPath.nameWithoutExtension - println("start:: $graphName") - val graph = readGraphFromCSV(graphPath.path) - val startNodes = readStartNodesFromCSV("$pathToStartNodes/$graphName.csv") - - val resultPath = getResultPath(pathToOutput, graphName, "cfg", cfgName, "with_sppf", chunkSize) - File(resultPath).writeText("") - - for (chunkStart in 0..> - val elapsed = measureNanoTime { - result = org.kotgll.cfg.graphinput.withsppf.GLL(cfg, graph.subList(chunkStart, chunkEnd)).parse() - } - val elapsedSeconds = elapsed.toDouble() / 1_000_000_000.0 - - var number = 0 - result.keys.forEach { key -> number += result[key]!!.keys.size } - - println("warmup:: $graphName $cfgName ${number} $elapsedSeconds") - } - - for (benchmarkAttempt in 1..benchmarkRounds) { - var result: HashMap> - val elapsed = measureNanoTime { - result = org.kotgll.cfg.graphinput.withsppf.GLL(cfg, graph.subList(chunkStart, chunkEnd)).parse() - } - val elapsedSeconds = elapsed.toDouble() / 1_000_000_000.0 - - var number = 0 - result.keys.forEach { key -> number += result[key]!!.keys.size } - - println("benchmark:: $graphName $cfgName ${number} $elapsedSeconds") - File(resultPath).appendText(elapsed.toString() + "\n") - } - } - } -} - -fun runRSMWithoutSPPF( - pathToGraphs: String, - pathToStartNodes: String, - pathToRSM: String, - pathToOutput: String, - warmUpRounds: Int, - benchmarkRounds: Int, - chunkSize: Int, -) { - val rsm = readRSMFromTXT(pathToRSM) - val rsmName = File(pathToRSM).nameWithoutExtension - File(pathToGraphs) - .walk() - .filter { it.isFile } - .forEach { graphPath -> - val graphName = graphPath.nameWithoutExtension - println("start:: $graphName") - val graph = readGraphFromCSV(graphPath.path) - val startNodes = readStartNodesFromCSV("$pathToStartNodes/$graphName.csv") - - val resultPath = getResultPath(pathToOutput, graphName, "rsm", rsmName, "without_sppf", chunkSize) - File(resultPath).writeText("") - - for (chunkStart in 0..> - val elapsed = measureNanoTime { - result = org.kotgll.rsm.graphinput.withoutsppf.GLL(rsm, graph.subList(chunkStart, chunkEnd)).parse() - } - val elapsedSeconds = elapsed.toDouble() / 1_000_000_000.0 - - var number = 0 - result.keys.forEach { key -> number += result[key]!!.size } - - println("warmup:: $graphName $rsmName ${number} $elapsedSeconds") - } - - for (benchmarkAttempt in 1..benchmarkRounds) { - var result: HashMap> - val elapsed = measureNanoTime { - result = org.kotgll.rsm.graphinput.withoutsppf.GLL(rsm, graph.subList(chunkStart, chunkEnd)).parse() - } - val elapsedSeconds = elapsed.toDouble() / 1_000_000_000.0 - - var number = 0 - result.keys.forEach { key -> number += result[key]!!.size } - - println("benchmark:: $graphName $rsmName ${number} $elapsedSeconds") - File(resultPath).appendText(elapsed.toString() + "\n") - } - } - } -} - -fun runRSMWithSPPF( - pathToGraphs: String, - pathToStartNodes: String, - pathToRSM: String, - pathToOutput: String, - warmUpRounds: Int, - benchmarkRounds: Int, - chunkSize: Int, -) { - val rsm = readRSMFromTXT(pathToRSM) - val rsmName = File(pathToRSM).nameWithoutExtension - File(pathToGraphs) - .walk() - .filter { it.isFile } - .forEach { graphPath -> - val graphName = graphPath.nameWithoutExtension - println("start:: $graphName") - val graph = readGraphFromCSV(graphPath.path) - val startNodes = readStartNodesFromCSV("$pathToStartNodes/$graphName.csv") - - val resultPath = getResultPath(pathToOutput, graphName, "rsm", rsmName, "with_sppf", chunkSize) - File(resultPath).writeText("") - - for (chunkStart in 0..> - val elapsed = measureNanoTime { - result = org.kotgll.rsm.graphinput.withsppf.GLL(rsm, graph.subList(chunkStart, chunkEnd)).parse() - } - val elapsedSeconds = elapsed.toDouble() / 1_000_000_000.0 - - var number = 0 - result.keys.forEach { key -> number += result[key]!!.keys.size } - - println("warmup:: $graphName $rsmName ${number} $elapsedSeconds") - } - - for (benchmarkAttempt in 1..benchmarkRounds) { - var result: HashMap> - val elapsed = measureNanoTime { - result = org.kotgll.rsm.graphinput.withsppf.GLL(rsm, graph.subList(chunkStart, chunkEnd)).parse() - } - val elapsedSeconds = elapsed.toDouble() / 1_000_000_000.0 - - var number = 0 - result.keys.forEach { key -> number += result[key]!!.keys.size } - - println("benchmark:: $graphName $rsmName ${number} $elapsedSeconds") - File(resultPath).appendText(elapsed.toString() + "\n") - } - } - } -} diff --git a/src/main/kotlin/org/kotgll/cfg/grammar/Alternative.kt b/src/main/kotlin/org/kotgll/cfg/grammar/Alternative.kt deleted file mode 100644 index 3063f900a..000000000 --- a/src/main/kotlin/org/kotgll/cfg/grammar/Alternative.kt +++ /dev/null @@ -1,25 +0,0 @@ -package org.kotgll.cfg.grammar - -import org.kotgll.cfg.grammar.symbol.Nonterminal -import org.kotgll.cfg.grammar.symbol.Symbol - -class Alternative(val elements: ArrayList) { - constructor(elements: List) : this(ArrayList(elements)) - - lateinit var nonterminal: Nonterminal - - override fun toString() = "Alternative($elements)" - - override fun equals(other: Any?): Boolean { - if (this === other) return true - if (other !is Alternative) return false - - if (elements != other.elements) return false - if (nonterminal != other.nonterminal) return false - - return true - } - - val hashCode = elements.hashCode() - override fun hashCode() = hashCode -} diff --git a/src/main/kotlin/org/kotgll/cfg/grammar/CFGRead.kt b/src/main/kotlin/org/kotgll/cfg/grammar/CFGRead.kt deleted file mode 100644 index 01befdb14..000000000 --- a/src/main/kotlin/org/kotgll/cfg/grammar/CFGRead.kt +++ /dev/null @@ -1,52 +0,0 @@ -package org.kotgll.cfg.grammar - -import org.kotgll.cfg.grammar.symbol.Nonterminal -import org.kotgll.cfg.grammar.symbol.Symbol -import org.kotgll.cfg.grammar.symbol.Terminal -import java.io.File - -fun readCFGFromTXT(pathToTXT: String): Nonterminal { - var startNonterminal = Nonterminal("S") - val nonterminals: HashMap = HashMap() - fun makeNonterminal(name: String): Nonterminal { - val y = Nonterminal(name) - if (!nonterminals.containsKey(y)) nonterminals[y] = y - return nonterminals[y]!! - } - - val startNonterminalRegex = """^StartNonterminal\("(?.*)"\)$""".toRegex() - val terminalRegex = """^Terminal\("(?.*)"\)$""".toRegex() - val nonterminalRegex = """^Nonterminal\("(?.*)"\)$""".toRegex() - - val reader = File(pathToTXT).inputStream().bufferedReader() - while (true) { - val line = reader.readLine() ?: break - - if (startNonterminalRegex.matches(line)) { - startNonterminal = - makeNonterminal(startNonterminalRegex.matchEntire(line)!!.groups["value"]!!.value) - } else { - val lineSplit = line.split(" ->", limit = 2) - val alternativeNonterminal = lineSplit[0] - val alternativeElements = lineSplit.elementAtOrNull(1) ?: "" - - val nonterminal = - makeNonterminal( - nonterminalRegex.matchEntire(alternativeNonterminal)!!.groups["value"]!!.value) - - val elements: ArrayList = ArrayList() - for (element in alternativeElements.split(' ')) { - if (terminalRegex.matches(element)) { - val elementValue = terminalRegex.matchEntire(element)!!.groups["value"]!!.value - elements.add(Terminal(elementValue)) - } else if (nonterminalRegex.matches(element)) { - val elementValue = nonterminalRegex.matchEntire(element)!!.groups["value"]!!.value - val tmpNonterminal = makeNonterminal(elementValue) - elements.add(tmpNonterminal) - } - } - nonterminals[nonterminal]!!.addAlternative(Alternative(elements)) - } - } - return nonterminals[startNonterminal]!! -} diff --git a/src/main/kotlin/org/kotgll/cfg/grammar/CFGWrite.kt b/src/main/kotlin/org/kotgll/cfg/grammar/CFGWrite.kt deleted file mode 100644 index 8e18e378c..000000000 --- a/src/main/kotlin/org/kotgll/cfg/grammar/CFGWrite.kt +++ /dev/null @@ -1,40 +0,0 @@ -package org.kotgll.cfg.grammar - -import org.kotgll.cfg.grammar.symbol.Nonterminal -import org.kotgll.cfg.grammar.symbol.Terminal -import java.io.File - -fun writeCFGToTXT(cfg: Nonterminal, pathToTXT: String) { - val nonterminals: ArrayList = ArrayList() - val queue: ArrayDeque = ArrayDeque(listOf(cfg)) - while (!queue.isEmpty()) { - val nonterminal = queue.removeFirst() - if (!nonterminals.contains(nonterminal)) nonterminals.add(nonterminal) - for (alternative in nonterminal.alternatives) { - for (symbol in alternative.elements) { - if (symbol is Nonterminal) { - if (!nonterminals.contains(symbol)) queue.addLast(symbol) - } - } - } - } - - File(pathToTXT).printWriter().use { out -> - out.println("""StartNonterminal("${cfg.name}")""") - nonterminals.forEach { nonterminal -> - nonterminal.alternatives.forEach { alternative -> - var alternativeString = """Nonterminal("${alternative.nonterminal.name}")""" - alternativeString += " ->" - alternative.elements.forEach { element -> - alternativeString += " " - if (element is Terminal) { - alternativeString += """Terminal("${element.value}")""" - } else if (element is Nonterminal) { - alternativeString += """Nonterminal("${element.name}")""" - } - } - out.println(alternativeString) - } - } - } -} diff --git a/src/main/kotlin/org/kotgll/cfg/grammar/symbol/Nonterminal.kt b/src/main/kotlin/org/kotgll/cfg/grammar/symbol/Nonterminal.kt deleted file mode 100644 index 28ef66137..000000000 --- a/src/main/kotlin/org/kotgll/cfg/grammar/symbol/Nonterminal.kt +++ /dev/null @@ -1,27 +0,0 @@ -package org.kotgll.cfg.grammar.symbol - -import org.kotgll.cfg.grammar.Alternative - -open class Nonterminal( - val name: String, - val alternatives: ArrayList = ArrayList(), -) : Symbol { - override fun toString() = "Nonterminal($name)" - - override fun equals(other: Any?): Boolean { - if (this === other) return true - if (other !is Nonterminal) return false - - if (name != other.name) return false - - return true - } - - open val hashCode: Int = name.hashCode() - override fun hashCode() = hashCode - - fun addAlternative(alternative: Alternative) { - alternatives.add(alternative) - alternative.nonterminal = this - } -} diff --git a/src/main/kotlin/org/kotgll/cfg/grammar/symbol/Optional.kt b/src/main/kotlin/org/kotgll/cfg/grammar/symbol/Optional.kt deleted file mode 100644 index 845e8be8f..000000000 --- a/src/main/kotlin/org/kotgll/cfg/grammar/symbol/Optional.kt +++ /dev/null @@ -1,10 +0,0 @@ -package org.kotgll.cfg.grammar.symbol - -import org.kotgll.cfg.grammar.Alternative - -class Optional(symbol: Symbol) : Regular(symbol, "?") { - init { - addAlternative(Alternative(ArrayList(listOf(symbol)))) - addAlternative(Alternative(ArrayList())) - } -} diff --git a/src/main/kotlin/org/kotgll/cfg/grammar/symbol/Plus.kt b/src/main/kotlin/org/kotgll/cfg/grammar/symbol/Plus.kt deleted file mode 100644 index de972005f..000000000 --- a/src/main/kotlin/org/kotgll/cfg/grammar/symbol/Plus.kt +++ /dev/null @@ -1,10 +0,0 @@ -package org.kotgll.cfg.grammar.symbol - -import org.kotgll.cfg.grammar.Alternative - -class Plus(symbol: Symbol) : Regular(symbol, "+") { - init { - addAlternative(Alternative(ArrayList(listOf(symbol)))) - addAlternative(Alternative(ArrayList(listOf(symbol, this)))) - } -} diff --git a/src/main/kotlin/org/kotgll/cfg/grammar/symbol/Regular.kt b/src/main/kotlin/org/kotgll/cfg/grammar/symbol/Regular.kt deleted file mode 100644 index 0aabf9c7b..000000000 --- a/src/main/kotlin/org/kotgll/cfg/grammar/symbol/Regular.kt +++ /dev/null @@ -1,24 +0,0 @@ -package org.kotgll.cfg.grammar.symbol - -import java.util.* - -open class Regular( - val symbol: Symbol, - val suffix: String, -) : Nonterminal(symbol.toString() + suffix) { - override fun toString() = "${this.javaClass.name}($symbol$suffix)" - - override fun equals(other: Any?): Boolean { - if (this === other) return true - if (other !is Regular) return false - if (!super.equals(other)) return false - - if (symbol != other.symbol) return false - if (suffix != other.suffix) return false - - return true - } - - override val hashCode: Int = Objects.hash(symbol, suffix) - override fun hashCode() = hashCode -} diff --git a/src/main/kotlin/org/kotgll/cfg/grammar/symbol/Star.kt b/src/main/kotlin/org/kotgll/cfg/grammar/symbol/Star.kt deleted file mode 100644 index 281526696..000000000 --- a/src/main/kotlin/org/kotgll/cfg/grammar/symbol/Star.kt +++ /dev/null @@ -1,10 +0,0 @@ -package org.kotgll.cfg.grammar.symbol - -import org.kotgll.cfg.grammar.Alternative - -class Star(symbol: Symbol) : Regular(symbol, "*") { - init { - addAlternative(Alternative(ArrayList())) - addAlternative(Alternative(ArrayList(listOf(symbol, this)))) - } -} diff --git a/src/main/kotlin/org/kotgll/cfg/grammar/symbol/Symbol.kt b/src/main/kotlin/org/kotgll/cfg/grammar/symbol/Symbol.kt deleted file mode 100644 index 0027febda..000000000 --- a/src/main/kotlin/org/kotgll/cfg/grammar/symbol/Symbol.kt +++ /dev/null @@ -1,3 +0,0 @@ -package org.kotgll.cfg.grammar.symbol - -interface Symbol diff --git a/src/main/kotlin/org/kotgll/cfg/grammar/symbol/Terminal.kt b/src/main/kotlin/org/kotgll/cfg/grammar/symbol/Terminal.kt deleted file mode 100644 index dbdf3c12a..000000000 --- a/src/main/kotlin/org/kotgll/cfg/grammar/symbol/Terminal.kt +++ /dev/null @@ -1,20 +0,0 @@ -package org.kotgll.cfg.grammar.symbol - -class Terminal(val value: String) : Symbol { - val size: Int = value.length - fun match(pos: Int, input: String) = input.startsWith(value, pos) - - override fun toString() = "Terminal($value)" - - override fun equals(other: Any?): Boolean { - if (this === other) return true - if (other !is Terminal) return false - - if (value != other.value) return false - - return true - } - - val hashCode: Int = value.hashCode() - override fun hashCode() = hashCode -} diff --git a/src/main/kotlin/org/kotgll/cfg/graphinput/withoutsppf/DescriptorsQueue.kt b/src/main/kotlin/org/kotgll/cfg/graphinput/withoutsppf/DescriptorsQueue.kt deleted file mode 100644 index 20a59e595..000000000 --- a/src/main/kotlin/org/kotgll/cfg/graphinput/withoutsppf/DescriptorsQueue.kt +++ /dev/null @@ -1,45 +0,0 @@ -package org.kotgll.cfg.graphinput.withoutsppf - -import org.kotgll.cfg.grammar.Alternative -import org.kotgll.graph.GraphNode -import java.util.* -import kotlin.collections.ArrayDeque - -class DescriptorsQueue { - val todo: ArrayDeque = ArrayDeque() - val created: HashMap> = HashMap() - - fun add(alternative: Alternative, dot: Int, gssNode: GSSNode, pos: GraphNode) { - val descriptor = Descriptor(alternative, dot, gssNode, pos) - if (!created.containsKey(pos)) created[pos] = HashSet() - if (created[pos]!!.add(descriptor)) todo.addLast(descriptor) - } - - fun next() = todo.removeFirst() - - fun isEmpty() = todo.isEmpty() - - class Descriptor( - val alternative: Alternative, - val dot: Int, - val gssNode: GSSNode, - val pos: GraphNode, - ) { - override fun toString() = - "Descriptor(alternative=$alternative, dot=$dot, gssNode=$gssNode, pos=$pos)" - - override fun equals(other: Any?): Boolean { - if (this === other) return true - if (other !is Descriptor) return false - - if (alternative != other.alternative) return false - if (dot != other.dot) return false - if (gssNode != other.gssNode) return false - - return true - } - - val hashCode: Int = Objects.hash(alternative, dot, gssNode) - override fun hashCode() = hashCode - } -} diff --git a/src/main/kotlin/org/kotgll/cfg/graphinput/withoutsppf/GLL.kt b/src/main/kotlin/org/kotgll/cfg/graphinput/withoutsppf/GLL.kt deleted file mode 100644 index d3d28315c..000000000 --- a/src/main/kotlin/org/kotgll/cfg/graphinput/withoutsppf/GLL.kt +++ /dev/null @@ -1,92 +0,0 @@ -package org.kotgll.cfg.graphinput.withoutsppf - -import org.kotgll.cfg.grammar.Alternative -import org.kotgll.cfg.grammar.symbol.Nonterminal -import org.kotgll.cfg.grammar.symbol.Symbol -import org.kotgll.cfg.grammar.symbol.Terminal -import org.kotgll.graph.GraphNode - -class GLL(val startSymbol: Nonterminal, val startGraphNodes: ArrayList) { - constructor( - startSymbol: Nonterminal, - startGraphNodes: List - ) : this(startSymbol, ArrayList(startGraphNodes)) - - val queue: DescriptorsQueue = DescriptorsQueue() - val poppedGSSNodes: HashMap> = HashMap() - val createdGSSNodes: HashMap = HashMap() - var parseResult: HashMap> = HashMap() - - fun getOrCreateGSSNode(nonterminal: Nonterminal, pos: GraphNode): GSSNode { - val gssNode = GSSNode(nonterminal, pos) - if (!createdGSSNodes.containsKey(gssNode)) createdGSSNodes[gssNode] = gssNode - return createdGSSNodes[gssNode]!! - } - - fun parse(): HashMap> { - for (alternative in startSymbol.alternatives) { - for (graphNode in startGraphNodes) { - queue.add(alternative, 0, getOrCreateGSSNode(startSymbol, graphNode), graphNode) - } - } - - while (!queue.isEmpty()) { - val descriptor: DescriptorsQueue.Descriptor = queue.next() - if (descriptor.dot == 0 && descriptor.alternative.elements.isEmpty()) { - pop(descriptor.gssNode, descriptor.pos) - } else { - parse(descriptor.alternative, descriptor.dot, descriptor.gssNode, descriptor.pos) - } - } - - return parseResult - } - - fun parse(alternative: Alternative, dot: Int, gssNode: GSSNode, pos: GraphNode) { - if (dot < alternative.elements.size) { - val curSymbol: Symbol = alternative.elements[dot] - - if (curSymbol is Terminal && pos.outgoingEdges.containsKey(curSymbol.value)) { - for (head in pos.outgoingEdges[curSymbol.value]!!) { - queue.add(alternative, dot + 1, gssNode, head) - } - } - - if (curSymbol is Nonterminal) { - for (alt in curSymbol.alternatives) { - queue.add(alt, 0, createGSSNode(alternative, dot + 1, gssNode, pos), pos) - } - } - } else { - pop(gssNode, pos) - } - } - - fun pop(gssNode: GSSNode, pos: GraphNode) { - if (gssNode.nonterminal == startSymbol && gssNode.pos.isStart && pos.isFinal) { - if (!parseResult.containsKey(gssNode.pos.id)) parseResult[gssNode.pos.id] = HashSet() - parseResult[gssNode.pos.id]!!.add(pos.id) - } - if (!poppedGSSNodes.containsKey(gssNode)) poppedGSSNodes[gssNode] = HashSet() - poppedGSSNodes[gssNode]!!.add(pos) - for (e in gssNode.edges) { - for (u in e.value) { - queue.add(e.key.first, e.key.second, u, pos) - } - } - } - - fun createGSSNode(alternative: Alternative, dot: Int, gssNode: GSSNode, pos: GraphNode): GSSNode { - val v: GSSNode = getOrCreateGSSNode(alternative.elements[dot - 1] as Nonterminal, pos) - - if (v.addEdge(alternative, dot, gssNode)) { - if (poppedGSSNodes.containsKey(v)) { - for (z in poppedGSSNodes[v]!!) { - queue.add(alternative, dot, gssNode, z) - } - } - } - - return v - } -} diff --git a/src/main/kotlin/org/kotgll/cfg/graphinput/withoutsppf/GSSNode.kt b/src/main/kotlin/org/kotgll/cfg/graphinput/withoutsppf/GSSNode.kt deleted file mode 100644 index 568c84490..000000000 --- a/src/main/kotlin/org/kotgll/cfg/graphinput/withoutsppf/GSSNode.kt +++ /dev/null @@ -1,31 +0,0 @@ -package org.kotgll.cfg.graphinput.withoutsppf - -import org.kotgll.cfg.grammar.Alternative -import org.kotgll.cfg.grammar.symbol.Nonterminal -import org.kotgll.graph.GraphNode -import java.util.* - -class GSSNode(val nonterminal: Nonterminal, val pos: GraphNode) { - val edges: HashMap, HashSet> = HashMap() - - fun addEdge(alternative: Alternative, dot: Int, gssNode: GSSNode): Boolean { - val label = Pair(alternative, dot) - if (!edges.containsKey(label)) edges[label] = HashSet() - return edges[label]!!.add(gssNode) - } - - override fun toString() = "GSSNode(nonterminal=$nonterminal, pos=$pos)" - - override fun equals(other: Any?): Boolean { - if (this === other) return true - if (other !is GSSNode) return false - - if (nonterminal != other.nonterminal) return false - if (pos != other.pos) return false - - return true - } - - val hashCode = Objects.hash(nonterminal, pos) - override fun hashCode() = hashCode -} diff --git a/src/main/kotlin/org/kotgll/cfg/graphinput/withsppf/DescriptorsQueue.kt b/src/main/kotlin/org/kotgll/cfg/graphinput/withsppf/DescriptorsQueue.kt deleted file mode 100644 index 64c78c3ea..000000000 --- a/src/main/kotlin/org/kotgll/cfg/graphinput/withsppf/DescriptorsQueue.kt +++ /dev/null @@ -1,54 +0,0 @@ -package org.kotgll.cfg.graphinput.withsppf - -import org.kotgll.cfg.grammar.Alternative -import org.kotgll.cfg.graphinput.withsppf.sppf.SPPFNode -import org.kotgll.graph.GraphNode -import java.util.* -import kotlin.collections.ArrayDeque - -class DescriptorsQueue { - val todo: ArrayDeque = ArrayDeque() - val created: HashMap> = HashMap() - - fun add( - alternative: Alternative, - dot: Int, - gssNode: GSSNode, - sppfNode: SPPFNode?, - pos: GraphNode, - ) { - val descriptor = Descriptor(alternative, dot, gssNode, sppfNode, pos) - if (!created.containsKey(pos)) created[pos] = HashSet() - if (created[pos]!!.add(descriptor)) todo.addLast(descriptor) - } - - fun next() = todo.removeFirst() - - fun isEmpty() = todo.isEmpty() - - class Descriptor( - val alternative: Alternative, - val dot: Int, - val gssNode: GSSNode, - val sppfNode: SPPFNode?, - val pos: GraphNode, - ) { - override fun toString() = - "Descriptor(alternative=$alternative, dot=$dot, gssNode=$gssNode, sppfNode=$sppfNode, pos=$pos)" - - override fun equals(other: Any?): Boolean { - if (this === other) return true - if (other !is Descriptor) return false - - if (alternative != other.alternative) return false - if (dot != other.dot) return false - if (gssNode != other.gssNode) return false - if (sppfNode != other.sppfNode) return false - - return true - } - - val hashCode: Int = Objects.hash(alternative, dot, gssNode, sppfNode) - override fun hashCode() = hashCode - } -} diff --git a/src/main/kotlin/org/kotgll/cfg/graphinput/withsppf/GLL.kt b/src/main/kotlin/org/kotgll/cfg/graphinput/withsppf/GLL.kt deleted file mode 100644 index 0f874680f..000000000 --- a/src/main/kotlin/org/kotgll/cfg/graphinput/withsppf/GLL.kt +++ /dev/null @@ -1,185 +0,0 @@ -package org.kotgll.cfg.graphinput.withsppf - -import org.kotgll.cfg.grammar.Alternative -import org.kotgll.cfg.grammar.symbol.Nonterminal -import org.kotgll.cfg.grammar.symbol.Symbol -import org.kotgll.cfg.grammar.symbol.Terminal -import org.kotgll.cfg.graphinput.withsppf.sppf.* -import org.kotgll.graph.GraphNode - -class GLL(val startSymbol: Nonterminal, val startGraphNodes: ArrayList) { - constructor( - startSymbol: Nonterminal, - startGraphNodes: List - ) : this(startSymbol, ArrayList(startGraphNodes)) - - val queue: DescriptorsQueue = DescriptorsQueue() - val poppedGSSNodes: HashMap> = HashMap() - val createdGSSNodes: HashMap = HashMap() - val createdSPPFNodes: HashMap = HashMap() - val parseResult: HashMap> = HashMap() - - fun getOrCreateGSSNode(nonterminal: Nonterminal, pos: GraphNode): GSSNode { - val gssNode = GSSNode(nonterminal, pos) - if (!createdGSSNodes.contains(gssNode)) createdGSSNodes[gssNode] = gssNode - return createdGSSNodes[gssNode]!! - } - - fun parse(): HashMap> { - for (alternative in startSymbol.alternatives) { - for (graphNode in startGraphNodes) { - queue.add(alternative, 0, getOrCreateGSSNode(startSymbol, graphNode), null, graphNode) - } - } - - while (!queue.isEmpty()) { - val descriptor: DescriptorsQueue.Descriptor = queue.next() - if (descriptor.dot == 0 && descriptor.alternative.elements.isEmpty()) { - pop( - descriptor.gssNode, - getNodeP( - descriptor.alternative, - 0, - descriptor.sppfNode, - getOrCreateItemSPPFNode(descriptor.alternative, 0, descriptor.pos, descriptor.pos)), - descriptor.pos) - } else { - parse( - descriptor.alternative, - descriptor.dot, - descriptor.gssNode, - descriptor.sppfNode, - descriptor.pos) - } - } - - return parseResult - } - - fun parse( - alternative: Alternative, - dot: Int, - gssNode: GSSNode, - sppfNode: SPPFNode?, - pos: GraphNode - ) { - if (dot < alternative.elements.size) { - val curSymbol: Symbol = alternative.elements[dot] - - if (curSymbol is Terminal && pos.outgoingEdges.containsKey(curSymbol.value)) { - for (head in pos.outgoingEdges[curSymbol.value]!!) { - queue.add( - alternative, - dot + 1, - gssNode, - getNodeP( - alternative, - dot + 1, - sppfNode, - getOrCreateTerminalSPPFNode(curSymbol, pos, head)), - head) - } - } - - if (curSymbol is Nonterminal) { - for (alt in curSymbol.alternatives) { - queue.add(alt, 0, createGSSNode(alternative, dot + 1, gssNode, sppfNode, pos), null, pos) - } - } - } else { - pop(gssNode, sppfNode, pos) - } - } - - fun pop(gssNode: GSSNode, sppfNode: SPPFNode?, pos: GraphNode) { - if (!poppedGSSNodes.containsKey(gssNode)) poppedGSSNodes[gssNode] = HashSet() - poppedGSSNodes[gssNode]!!.add(sppfNode) - for (e in gssNode.edges) { - for (u in e.value) { - queue.add( - e.key.first, - e.key.second, - u, - getNodeP(e.key.first, e.key.second, e.key.third, sppfNode!!), - pos, - ) - } - } - } - - fun createGSSNode( - alternative: Alternative, - dot: Int, - gssNode: GSSNode, - sppfNode: SPPFNode?, - pos: GraphNode, - ): GSSNode { - val v: GSSNode = getOrCreateGSSNode(alternative.elements[dot - 1] as Nonterminal, pos) - - if (v.addEdge(alternative, dot, sppfNode, gssNode)) { - if (poppedGSSNodes.containsKey(v)) { - for (z in poppedGSSNodes[v]!!) { - queue.add( - alternative, dot, gssNode, getNodeP(alternative, dot, sppfNode, z!!), z.rightExtent) - } - } - } - - return v - } - - fun getNodeP( - alternative: Alternative, - dot: Int, - sppfNode: SPPFNode?, - nextSPPFNode: SPPFNode, - ): SPPFNode { - val leftExtent = sppfNode?.leftExtent ?: nextSPPFNode.leftExtent - val rightExtent = nextSPPFNode.rightExtent - - val y = - if (dot == alternative.elements.size) - getOrCreateSymbolSPPFNode(alternative.nonterminal, leftExtent, rightExtent) - else getOrCreateItemSPPFNode(alternative, dot, leftExtent, rightExtent) - - y.kids.add(PackedSPPFNode(nextSPPFNode.leftExtent, alternative, dot, sppfNode, nextSPPFNode)) - - return y - } - - fun getOrCreateTerminalSPPFNode( - terminal: Terminal, - leftExtent: GraphNode, - rightExtent: GraphNode - ): SPPFNode { - val y = TerminalSPPFNode(leftExtent, rightExtent, terminal) - if (!createdSPPFNodes.containsKey(y)) createdSPPFNodes[y] = y - return createdSPPFNodes[y]!! - } - - fun getOrCreateItemSPPFNode( - alternative: Alternative, - dot: Int, - leftExtent: GraphNode, - rightExtent: GraphNode, - ): ItemSPPFNode { - val y = ItemSPPFNode(leftExtent, rightExtent, alternative, dot) - if (!createdSPPFNodes.containsKey(y)) createdSPPFNodes[y] = y - return createdSPPFNodes[y]!! as ItemSPPFNode - } - - fun getOrCreateSymbolSPPFNode( - nonterminal: Nonterminal, - leftExtent: GraphNode, - rightExtent: GraphNode, - ): SymbolSPPFNode { - val y = SymbolSPPFNode(leftExtent, rightExtent, nonterminal) - if (!createdSPPFNodes.containsKey(y)) createdSPPFNodes[y] = y - val result = createdSPPFNodes[y]!! as SymbolSPPFNode - if (nonterminal == startSymbol && leftExtent.isStart && rightExtent.isFinal) { - if (!parseResult.containsKey(leftExtent.id)) parseResult[leftExtent.id] = HashMap() - parseResult[leftExtent.id]!![rightExtent.id] = result - } - return result - } -} diff --git a/src/main/kotlin/org/kotgll/cfg/graphinput/withsppf/GSSNode.kt b/src/main/kotlin/org/kotgll/cfg/graphinput/withsppf/GSSNode.kt deleted file mode 100644 index 2394a7145..000000000 --- a/src/main/kotlin/org/kotgll/cfg/graphinput/withsppf/GSSNode.kt +++ /dev/null @@ -1,32 +0,0 @@ -package org.kotgll.cfg.graphinput.withsppf - -import org.kotgll.cfg.grammar.Alternative -import org.kotgll.cfg.grammar.symbol.Nonterminal -import org.kotgll.cfg.graphinput.withsppf.sppf.SPPFNode -import org.kotgll.graph.GraphNode -import java.util.* - -class GSSNode(val nonterminal: Nonterminal, val pos: GraphNode) { - val edges: HashMap, HashSet> = HashMap() - - fun addEdge(alternative: Alternative, dot: Int, sppfNode: SPPFNode?, gssNode: GSSNode): Boolean { - val label = Triple(alternative, dot, sppfNode) - if (!edges.containsKey(label)) edges[label] = HashSet() - return edges[label]!!.add(gssNode) - } - - override fun toString() = "GSSNode(nonterminal=$nonterminal, pos=$pos)" - - override fun equals(other: Any?): Boolean { - if (this === other) return true - if (other !is GSSNode) return false - - if (nonterminal != other.nonterminal) return false - if (pos != other.pos) return false - - return true - } - - val hashCode = Objects.hash(nonterminal, pos) - override fun hashCode() = hashCode -} diff --git a/src/main/kotlin/org/kotgll/cfg/graphinput/withsppf/sppf/ItemSPPFNode.kt b/src/main/kotlin/org/kotgll/cfg/graphinput/withsppf/sppf/ItemSPPFNode.kt deleted file mode 100644 index 0fe7cc6be..000000000 --- a/src/main/kotlin/org/kotgll/cfg/graphinput/withsppf/sppf/ItemSPPFNode.kt +++ /dev/null @@ -1,29 +0,0 @@ -package org.kotgll.cfg.graphinput.withsppf.sppf - -import org.kotgll.cfg.grammar.Alternative -import org.kotgll.graph.GraphNode -import java.util.* - -class ItemSPPFNode( - leftExtent: GraphNode, - rightExtent: GraphNode, - val alternative: Alternative, - val dot: Int, -) : ParentSPPFNode(leftExtent, rightExtent) { - override fun toString() = - "ItemSPPFNode(leftExtent=$leftExtent, rightExtent=$rightExtent, alternative=$alternative, dot=$dot)" - - override fun equals(other: Any?): Boolean { - if (this === other) return true - if (other !is ItemSPPFNode) return false - if (!super.equals(other)) return false - - if (alternative != other.alternative) return false - if (dot != other.dot) return false - - return true - } - - override val hashCode: Int = Objects.hash(leftExtent, rightExtent, alternative, dot) - override fun hashCode() = hashCode -} diff --git a/src/main/kotlin/org/kotgll/cfg/graphinput/withsppf/sppf/PackedSPPFNode.kt b/src/main/kotlin/org/kotgll/cfg/graphinput/withsppf/sppf/PackedSPPFNode.kt deleted file mode 100644 index 6d1bf0db4..000000000 --- a/src/main/kotlin/org/kotgll/cfg/graphinput/withsppf/sppf/PackedSPPFNode.kt +++ /dev/null @@ -1,32 +0,0 @@ -package org.kotgll.cfg.graphinput.withsppf.sppf - -import org.kotgll.cfg.grammar.Alternative -import org.kotgll.graph.GraphNode -import java.util.* - -open class PackedSPPFNode( - val pivot: GraphNode, - val alternative: Alternative, - val dot: Int, - val leftSPPFNode: SPPFNode? = null, - val rightSPPFNode: SPPFNode? = null, -) { - override fun toString() = - "PackedSPPFNode(pivot=$pivot, alternative=$alternative, dot=$dot, leftSPPFNode=$leftSPPFNode, rightSPPFNode=$rightSPPFNode)" - - override fun equals(other: Any?): Boolean { - if (this === other) return true - if (other !is PackedSPPFNode) return false - - if (pivot != other.pivot) return false - if (alternative != other.alternative) return false - if (dot != other.dot) return false - if (leftSPPFNode != other.leftSPPFNode) return false - if (rightSPPFNode != other.rightSPPFNode) return false - - return true - } - - val hashCode: Int = Objects.hash(pivot, alternative, dot, leftSPPFNode, rightSPPFNode) - override fun hashCode() = hashCode -} diff --git a/src/main/kotlin/org/kotgll/cfg/graphinput/withsppf/sppf/ParentSPPFNode.kt b/src/main/kotlin/org/kotgll/cfg/graphinput/withsppf/sppf/ParentSPPFNode.kt deleted file mode 100644 index 7b5de2c84..000000000 --- a/src/main/kotlin/org/kotgll/cfg/graphinput/withsppf/sppf/ParentSPPFNode.kt +++ /dev/null @@ -1,22 +0,0 @@ -package org.kotgll.cfg.graphinput.withsppf.sppf - -import org.kotgll.graph.GraphNode -import java.util.* - -open class ParentSPPFNode(leftExtent: GraphNode, rightExtent: GraphNode) : - SPPFNode(leftExtent, rightExtent) { - val kids: HashSet = HashSet() - - override fun toString() = "ParentSPPFNode(leftExtent=$leftExtent, rightExtent=$rightExtent)" - - override fun equals(other: Any?): Boolean { - if (this === other) return true - if (other !is ParentSPPFNode) return false - if (!super.equals(other)) return false - - return true - } - - override val hashCode: Int = Objects.hash(leftExtent, rightExtent) - override fun hashCode() = hashCode -} diff --git a/src/main/kotlin/org/kotgll/cfg/graphinput/withsppf/sppf/SPPFNode.kt b/src/main/kotlin/org/kotgll/cfg/graphinput/withsppf/sppf/SPPFNode.kt deleted file mode 100644 index 93ed6a6ce..000000000 --- a/src/main/kotlin/org/kotgll/cfg/graphinput/withsppf/sppf/SPPFNode.kt +++ /dev/null @@ -1,24 +0,0 @@ -package org.kotgll.cfg.graphinput.withsppf.sppf - -import org.kotgll.cfg.grammar.symbol.Symbol -import org.kotgll.graph.GraphNode -import java.util.* - -open class SPPFNode(val leftExtent: GraphNode, val rightExtent: GraphNode) { - override fun toString() = "SPPFNode(leftExtent=$leftExtent, rightExtent=$rightExtent)" - - override fun equals(other: Any?): Boolean { - if (this === other) return true - if (other !is SPPFNode) return false - - if (leftExtent != other.leftExtent) return false - if (rightExtent != other.rightExtent) return false - - return true - } - - open val hashCode: Int = Objects.hash(leftExtent, rightExtent) - override fun hashCode() = hashCode - - open fun hasSymbol(symbol: Symbol) = false -} diff --git a/src/main/kotlin/org/kotgll/cfg/graphinput/withsppf/sppf/SymbolSPPFNode.kt b/src/main/kotlin/org/kotgll/cfg/graphinput/withsppf/sppf/SymbolSPPFNode.kt deleted file mode 100644 index 1cbe35326..000000000 --- a/src/main/kotlin/org/kotgll/cfg/graphinput/withsppf/sppf/SymbolSPPFNode.kt +++ /dev/null @@ -1,30 +0,0 @@ -package org.kotgll.cfg.graphinput.withsppf.sppf - -import org.kotgll.cfg.grammar.symbol.Nonterminal -import org.kotgll.cfg.grammar.symbol.Symbol -import org.kotgll.graph.GraphNode -import java.util.* - -class SymbolSPPFNode( - leftExtent: GraphNode, - rightExtent: GraphNode, - val symbol: Nonterminal, -) : ParentSPPFNode(leftExtent, rightExtent) { - override fun toString() = - "SymbolSPPFNode(leftExtent=$leftExtent, rightExtent=$rightExtent, symbol=$symbol)" - - override fun equals(other: Any?): Boolean { - if (this === other) return true - if (other !is SymbolSPPFNode) return false - if (!super.equals(other)) return false - - if (symbol != other.symbol) return false - - return true - } - - override val hashCode: Int = Objects.hash(leftExtent, rightExtent, symbol) - override fun hashCode() = hashCode - - override fun hasSymbol(symbol: Symbol) = this.symbol == symbol -} diff --git a/src/main/kotlin/org/kotgll/cfg/graphinput/withsppf/sppf/TerminalSPPFNode.kt b/src/main/kotlin/org/kotgll/cfg/graphinput/withsppf/sppf/TerminalSPPFNode.kt deleted file mode 100644 index cd1105c55..000000000 --- a/src/main/kotlin/org/kotgll/cfg/graphinput/withsppf/sppf/TerminalSPPFNode.kt +++ /dev/null @@ -1,27 +0,0 @@ -package org.kotgll.cfg.graphinput.withsppf.sppf - -import org.kotgll.cfg.grammar.symbol.Terminal -import org.kotgll.graph.GraphNode -import java.util.* - -class TerminalSPPFNode( - leftExtent: GraphNode, - rightExtent: GraphNode, - val terminal: Terminal, -) : SPPFNode(leftExtent, rightExtent) { - override fun toString() = - "TerminalSPPFNode(leftExtent=$leftExtent, rightExtent=$rightExtent, terminal=$terminal)" - - override fun equals(other: Any?): Boolean { - if (this === other) return true - if (other !is TerminalSPPFNode) return false - if (!super.equals(other)) return false - - if (terminal != other.terminal) return false - - return true - } - - override val hashCode: Int = Objects.hash(leftExtent, rightExtent, terminal) - override fun hashCode() = hashCode -} diff --git a/src/main/kotlin/org/kotgll/cfg/stringinput/withoutsppf/DescriptorsQueue.kt b/src/main/kotlin/org/kotgll/cfg/stringinput/withoutsppf/DescriptorsQueue.kt deleted file mode 100644 index 739c425a6..000000000 --- a/src/main/kotlin/org/kotgll/cfg/stringinput/withoutsppf/DescriptorsQueue.kt +++ /dev/null @@ -1,43 +0,0 @@ -package org.kotgll.cfg.stringinput.withoutsppf - -import org.kotgll.cfg.grammar.Alternative -import java.util.* -import kotlin.collections.ArrayDeque - -class DescriptorsQueue(size: Int) { - val todo: ArrayDeque = ArrayDeque() - val created: Array> = Array(size) { HashSet() } - - fun add(alternative: Alternative, dot: Int, gssNode: GSSNode, pos: Int) { - val descriptor = Descriptor(alternative, dot, gssNode, pos) - if (created[pos].add(descriptor)) todo.addLast(descriptor) - } - - fun next() = todo.removeFirst() - - fun isEmpty() = todo.isEmpty() - - class Descriptor( - val alternative: Alternative, - val dot: Int, - val gssNode: GSSNode, - val pos: Int, - ) { - override fun toString() = - "Descriptor(alternative=$alternative, dot=$dot, gssNode=$gssNode, pos=$pos)" - - override fun equals(other: Any?): Boolean { - if (this === other) return true - if (other !is Descriptor) return false - - if (alternative != other.alternative) return false - if (dot != other.dot) return false - if (gssNode != other.gssNode) return false - - return true - } - - val hashCode: Int = Objects.hash(alternative, dot, gssNode) - override fun hashCode() = hashCode - } -} diff --git a/src/main/kotlin/org/kotgll/cfg/stringinput/withoutsppf/GLL.kt b/src/main/kotlin/org/kotgll/cfg/stringinput/withoutsppf/GLL.kt deleted file mode 100644 index d7eee4f29..000000000 --- a/src/main/kotlin/org/kotgll/cfg/stringinput/withoutsppf/GLL.kt +++ /dev/null @@ -1,91 +0,0 @@ -package org.kotgll.cfg.stringinput.withoutsppf - -import org.kotgll.cfg.grammar.Alternative -import org.kotgll.cfg.grammar.symbol.Nonterminal -import org.kotgll.cfg.grammar.symbol.Symbol -import org.kotgll.cfg.grammar.symbol.Terminal - -class GLL(val startSymbol: Nonterminal, val input: String) { - val queue: DescriptorsQueue = DescriptorsQueue(input.length + 1) - val poppedGSSNodes: HashMap> = HashMap() - val createdGSSNodes: HashMap = HashMap() - var parseResult: Boolean = false - - fun getOrCreateGSSNode(nonterminal: Nonterminal, pos: Int): GSSNode { - val gssNode = GSSNode(nonterminal, pos) - if (!createdGSSNodes.contains(gssNode)) createdGSSNodes[gssNode] = gssNode - return createdGSSNodes[gssNode]!! - } - - fun parse(): Boolean { - for (alternative in startSymbol.alternatives) { - queue.add(alternative, 0, getOrCreateGSSNode(startSymbol, 0), 0) - } - - while (!queue.isEmpty()) { - val descriptor: DescriptorsQueue.Descriptor = queue.next() - if (descriptor.dot == 0 && descriptor.alternative.elements.isEmpty()) { - pop(descriptor.gssNode, descriptor.pos) - } else { - parse(descriptor.alternative, descriptor.dot, descriptor.gssNode, descriptor.pos) - } - } - - return parseResult - } - - fun parse(alternative: Alternative, dot: Int, gssNode: GSSNode, pos: Int) { - var curDot: Int = dot - var curPos: Int = pos - while (curDot < alternative.elements.size) { - val curSymbol: Symbol = alternative.elements[curDot] - - if (curSymbol is Terminal) { - if (curPos >= input.length) return - if (curSymbol.match(curPos, input)) { - curPos += curSymbol.size - curDot += 1 - continue - } - return - } - - if (curSymbol is Nonterminal) { - for (alt in curSymbol.alternatives) { - queue.add(alt, 0, createGSSNode(alternative, curDot + 1, gssNode, curPos), curPos) - } - return - } - } - pop(gssNode, curPos) - } - - fun pop(gssNode: GSSNode, pos: Int) { - if (!parseResult && - gssNode.nonterminal == startSymbol && - gssNode.pos == 0 && - pos == input.length) - parseResult = true - if (!poppedGSSNodes.containsKey(gssNode)) poppedGSSNodes[gssNode] = HashSet() - poppedGSSNodes[gssNode]!!.add(pos) - for (e in gssNode.edges) { - for (u in e.value) { - queue.add(e.key.first, e.key.second, u, pos) - } - } - } - - fun createGSSNode(alternative: Alternative, dot: Int, gssNode: GSSNode, pos: Int): GSSNode { - val v: GSSNode = getOrCreateGSSNode(alternative.elements[dot - 1] as Nonterminal, pos) - - if (v.addEdge(alternative, dot, gssNode)) { - if (poppedGSSNodes.containsKey(v)) { - for (z in poppedGSSNodes[v]!!) { - queue.add(alternative, dot, gssNode, z) - } - } - } - - return v - } -} diff --git a/src/main/kotlin/org/kotgll/cfg/stringinput/withoutsppf/GSSNode.kt b/src/main/kotlin/org/kotgll/cfg/stringinput/withoutsppf/GSSNode.kt deleted file mode 100644 index af8b65da2..000000000 --- a/src/main/kotlin/org/kotgll/cfg/stringinput/withoutsppf/GSSNode.kt +++ /dev/null @@ -1,30 +0,0 @@ -package org.kotgll.cfg.stringinput.withoutsppf - -import org.kotgll.cfg.grammar.Alternative -import org.kotgll.cfg.grammar.symbol.Nonterminal -import java.util.* - -class GSSNode(val nonterminal: Nonterminal, val pos: Int) { - val edges: HashMap, HashSet> = HashMap() - - fun addEdge(alternative: Alternative, dot: Int, gssNode: GSSNode): Boolean { - val label = Pair(alternative, dot) - if (!edges.containsKey(label)) edges[label] = HashSet() - return edges[label]!!.add(gssNode) - } - - override fun toString() = "GSSNode(nonterminal=$nonterminal, pos=$pos)" - - override fun equals(other: Any?): Boolean { - if (this === other) return true - if (other !is GSSNode) return false - - if (nonterminal != other.nonterminal) return false - if (pos != other.pos) return false - - return true - } - - val hashCode: Int = Objects.hash(nonterminal, pos) - override fun hashCode() = hashCode -} diff --git a/src/main/kotlin/org/kotgll/cfg/stringinput/withsppf/DescriptorsQueue.kt b/src/main/kotlin/org/kotgll/cfg/stringinput/withsppf/DescriptorsQueue.kt deleted file mode 100644 index 5d707074a..000000000 --- a/src/main/kotlin/org/kotgll/cfg/stringinput/withsppf/DescriptorsQueue.kt +++ /dev/null @@ -1,46 +0,0 @@ -package org.kotgll.cfg.stringinput.withsppf - -import org.kotgll.cfg.grammar.Alternative -import org.kotgll.cfg.stringinput.withsppf.sppf.SPPFNode -import java.util.* -import kotlin.collections.ArrayDeque - -class DescriptorsQueue(size: Int) { - val todo: ArrayDeque = ArrayDeque() - val created: Array> = Array(size) { HashSet() } - - fun add(alternative: Alternative, dot: Int, gssNode: GSSNode, sppfNode: SPPFNode?, pos: Int) { - val descriptor = Descriptor(alternative, dot, gssNode, sppfNode, pos) - if (created[pos].add(descriptor)) todo.addLast(descriptor) - } - - fun next() = todo.removeFirst() - - fun isEmpty() = todo.isEmpty() - - class Descriptor( - val alternative: Alternative, - val dot: Int, - val gssNode: GSSNode, - val sppfNode: SPPFNode?, - val pos: Int - ) { - override fun toString() = - "Descriptor(alternative=$alternative, dot=$dot, gssNode=$gssNode, sppfNode=$sppfNode, pos=$pos)" - - override fun equals(other: Any?): Boolean { - if (this === other) return true - if (other !is Descriptor) return false - - if (alternative != other.alternative) return false - if (dot != other.dot) return false - if (gssNode != other.gssNode) return false - if (sppfNode != other.sppfNode) return false - - return true - } - - val hashCode: Int = Objects.hash(alternative, dot, gssNode, sppfNode) - override fun hashCode() = hashCode - } -} diff --git a/src/main/kotlin/org/kotgll/cfg/stringinput/withsppf/GLL.kt b/src/main/kotlin/org/kotgll/cfg/stringinput/withsppf/GLL.kt deleted file mode 100644 index 2273fb291..000000000 --- a/src/main/kotlin/org/kotgll/cfg/stringinput/withsppf/GLL.kt +++ /dev/null @@ -1,173 +0,0 @@ -package org.kotgll.cfg.stringinput.withsppf - -import org.kotgll.cfg.grammar.Alternative -import org.kotgll.cfg.grammar.symbol.Nonterminal -import org.kotgll.cfg.grammar.symbol.Symbol -import org.kotgll.cfg.grammar.symbol.Terminal -import org.kotgll.cfg.stringinput.withsppf.sppf.* - -class GLL(val startSymbol: Nonterminal, val input: String) { - val queue: DescriptorsQueue = DescriptorsQueue(input.length + 1) - val poppedGSSNodes: HashMap> = HashMap() - val createdGSSNodes: HashMap = HashMap() - val createdSPPFNodes: HashMap = HashMap() - var parseResult: SPPFNode? = null - - fun getOrCreateGSSNode(nonterminal: Nonterminal, pos: Int): GSSNode { - val gssNode = GSSNode(nonterminal, pos) - if (!createdGSSNodes.contains(gssNode)) createdGSSNodes[gssNode] = gssNode - return createdGSSNodes[gssNode]!! - } - - fun parse(): SPPFNode? { - for (alternative in startSymbol.alternatives) { - queue.add(alternative, 0, getOrCreateGSSNode(startSymbol, 0), null, 0) - } - - while (!queue.isEmpty()) { - val descriptor: DescriptorsQueue.Descriptor = queue.next() - if (descriptor.dot == 0 && descriptor.alternative.elements.isEmpty()) { - pop( - descriptor.gssNode, - getNodeP( - descriptor.alternative, - 0, - descriptor.sppfNode, - getOrCreateItemSPPFNode(descriptor.alternative, 0, descriptor.pos, descriptor.pos)), - descriptor.pos) - } else { - parse( - descriptor.alternative, - descriptor.dot, - descriptor.gssNode, - descriptor.sppfNode, - descriptor.pos, - ) - } - } - - return parseResult - } - - fun parse(alternative: Alternative, dot: Int, gssNode: GSSNode, sppfNode: SPPFNode?, pos: Int) { - var curPos: Int = pos - var curSPPFNode: SPPFNode? = sppfNode - for (i in dot until alternative.elements.size) { - val curSymbol: Symbol = alternative.elements[i] - - if (curSymbol is Terminal) { - if (curPos >= input.length) return - if (curSymbol.match(curPos, input)) { - curSPPFNode = - getNodeP( - alternative, - i + 1, - curSPPFNode, - getOrCreateTerminalSPPFNode(curSymbol, curPos, curSymbol.size)) - curPos += curSymbol.size - continue - } - return - } - - if (curSymbol is Nonterminal) { - for (alt in curSymbol.alternatives) { - queue.add( - alt, 0, createGSSNode(alternative, i + 1, gssNode, curSPPFNode, curPos), null, curPos) - } - return - } - } - pop(gssNode, curSPPFNode, curPos) - } - - fun pop(gssNode: GSSNode, sppfNode: SPPFNode?, pos: Int) { - if (!poppedGSSNodes.containsKey(gssNode)) poppedGSSNodes[gssNode] = HashSet() - poppedGSSNodes[gssNode]!!.add(sppfNode) - for (e in gssNode.edges) { - for (u in e.value) { - queue.add( - e.key.first, - e.key.second, - u, - getNodeP(e.key.first, e.key.second, e.key.third, sppfNode!!), - pos, - ) - } - } - } - - fun createGSSNode( - alternative: Alternative, - dot: Int, - gssNode: GSSNode, - sppfNode: SPPFNode?, - pos: Int, - ): GSSNode { - val v: GSSNode = getOrCreateGSSNode(alternative.elements[dot - 1] as Nonterminal, pos) - - if (v.addEdge(alternative, dot, sppfNode, gssNode)) { - if (poppedGSSNodes.containsKey(v)) { - for (z in poppedGSSNodes[v]!!) { - queue.add( - alternative, dot, gssNode, getNodeP(alternative, dot, sppfNode, z!!), z.rightExtent) - } - } - } - - return v - } - - fun getNodeP( - alternative: Alternative, - dot: Int, - sppfNode: SPPFNode?, - nextSPPFNode: SPPFNode, - ): SPPFNode { - val leftExtent = sppfNode?.leftExtent ?: nextSPPFNode.leftExtent - val rightExtent = nextSPPFNode.rightExtent - - val newSPPFNode = - if (dot == alternative.elements.size) - getOrCreateSymbolSPPFNode(alternative.nonterminal, leftExtent, rightExtent) - else getOrCreateItemSPPFNode(alternative, dot, leftExtent, rightExtent) - - newSPPFNode.kids.add( - PackedSPPFNode(nextSPPFNode.leftExtent, alternative, dot, sppfNode, nextSPPFNode)) - - return newSPPFNode - } - - fun getOrCreateTerminalSPPFNode(terminal: Terminal, leftExtent: Int, rightExtent: Int): SPPFNode { - val newSPPFNode = TerminalSPPFNode(leftExtent, leftExtent + rightExtent, terminal) - if (!createdSPPFNodes.containsKey(newSPPFNode)) createdSPPFNodes[newSPPFNode] = newSPPFNode - return createdSPPFNodes[newSPPFNode]!! - } - - fun getOrCreateItemSPPFNode( - alternative: Alternative, - dot: Int, - leftExtent: Int, - rightExtent: Int - ): ItemSPPFNode { - val newSPPFNode = ItemSPPFNode(leftExtent, rightExtent, alternative, dot) - if (!createdSPPFNodes.containsKey(newSPPFNode)) createdSPPFNodes[newSPPFNode] = newSPPFNode - return createdSPPFNodes[newSPPFNode]!! as ItemSPPFNode - } - - fun getOrCreateSymbolSPPFNode( - nonterminal: Nonterminal, - leftExtent: Int, - rightExtent: Int - ): SymbolSPPFNode { - val newSPPFNode = SymbolSPPFNode(leftExtent, rightExtent, nonterminal) - if (!createdSPPFNodes.containsKey(newSPPFNode)) createdSPPFNodes[newSPPFNode] = newSPPFNode - val result = createdSPPFNodes[newSPPFNode]!! as SymbolSPPFNode - if (parseResult == null && - nonterminal == startSymbol && - leftExtent == 0 && - rightExtent == input.length) - parseResult = result - return result - } -} diff --git a/src/main/kotlin/org/kotgll/cfg/stringinput/withsppf/GSSNode.kt b/src/main/kotlin/org/kotgll/cfg/stringinput/withsppf/GSSNode.kt deleted file mode 100644 index de369d002..000000000 --- a/src/main/kotlin/org/kotgll/cfg/stringinput/withsppf/GSSNode.kt +++ /dev/null @@ -1,31 +0,0 @@ -package org.kotgll.cfg.stringinput.withsppf - -import org.kotgll.cfg.grammar.Alternative -import org.kotgll.cfg.grammar.symbol.Nonterminal -import org.kotgll.cfg.stringinput.withsppf.sppf.SPPFNode -import java.util.* - -class GSSNode(val nonterminal: Nonterminal, val pos: Int) { - val edges: HashMap, HashSet> = HashMap() - - fun addEdge(alternative: Alternative, dot: Int, sppfNode: SPPFNode?, gssNode: GSSNode): Boolean { - val label = Triple(alternative, dot, sppfNode) - if (!edges.containsKey(label)) edges[label] = HashSet() - return edges[label]!!.add(gssNode) - } - - override fun toString() = "GSSNode(nonterminal=$nonterminal, pos=$pos)" - - override fun equals(other: Any?): Boolean { - if (this === other) return true - if (other !is GSSNode) return false - - if (nonterminal != other.nonterminal) return false - if (pos != other.pos) return false - - return true - } - - val hashCode: Int = Objects.hash(nonterminal, pos) - override fun hashCode() = hashCode -} diff --git a/src/main/kotlin/org/kotgll/cfg/stringinput/withsppf/sppf/ItemSPPFNode.kt b/src/main/kotlin/org/kotgll/cfg/stringinput/withsppf/sppf/ItemSPPFNode.kt deleted file mode 100644 index 047c1d9c4..000000000 --- a/src/main/kotlin/org/kotgll/cfg/stringinput/withsppf/sppf/ItemSPPFNode.kt +++ /dev/null @@ -1,24 +0,0 @@ -package org.kotgll.cfg.stringinput.withsppf.sppf - -import org.kotgll.cfg.grammar.Alternative -import java.util.* - -class ItemSPPFNode(leftExtent: Int, rightExtent: Int, val alternative: Alternative, val dot: Int) : - ParentSPPFNode(leftExtent, rightExtent) { - override fun toString() = - "ItemSPPFNode(leftExtent=$leftExtent, rightExtent=$rightExtent, alternative=$alternative, dot=$dot)" - - override fun equals(other: Any?): Boolean { - if (this === other) return true - if (other !is ItemSPPFNode) return false - if (!super.equals(other)) return false - - if (alternative != other.alternative) return false - if (dot != other.dot) return false - - return true - } - - override val hashCode: Int = Objects.hash(leftExtent, rightExtent, alternative, dot) - override fun hashCode() = hashCode -} diff --git a/src/main/kotlin/org/kotgll/cfg/stringinput/withsppf/sppf/PackedSPPFNode.kt b/src/main/kotlin/org/kotgll/cfg/stringinput/withsppf/sppf/PackedSPPFNode.kt deleted file mode 100644 index a39ee5c04..000000000 --- a/src/main/kotlin/org/kotgll/cfg/stringinput/withsppf/sppf/PackedSPPFNode.kt +++ /dev/null @@ -1,31 +0,0 @@ -package org.kotgll.cfg.stringinput.withsppf.sppf - -import org.kotgll.cfg.grammar.Alternative -import java.util.* - -open class PackedSPPFNode( - val pivot: Int, - val alternative: Alternative, - val dot: Int, - val leftSPPFNode: SPPFNode? = null, - val rightSPPFNode: SPPFNode? = null -) { - override fun toString() = - "PackedSPPFNode(pivot=$pivot, alternative=$alternative, dot=$dot, leftSPPFNode=$leftSPPFNode, rightSPPFNode=$rightSPPFNode)" - - override fun equals(other: Any?): Boolean { - if (this === other) return true - if (other !is PackedSPPFNode) return false - - if (pivot != other.pivot) return false - if (alternative != other.alternative) return false - if (dot != other.dot) return false - if (leftSPPFNode != other.leftSPPFNode) return false - if (rightSPPFNode != other.rightSPPFNode) return false - - return true - } - - val hashCode: Int = Objects.hash(pivot, alternative, dot, leftSPPFNode, rightSPPFNode) - override fun hashCode() = hashCode -} diff --git a/src/main/kotlin/org/kotgll/cfg/stringinput/withsppf/sppf/ParentSPPFNode.kt b/src/main/kotlin/org/kotgll/cfg/stringinput/withsppf/sppf/ParentSPPFNode.kt deleted file mode 100644 index 86e6c9ae1..000000000 --- a/src/main/kotlin/org/kotgll/cfg/stringinput/withsppf/sppf/ParentSPPFNode.kt +++ /dev/null @@ -1,20 +0,0 @@ -package org.kotgll.cfg.stringinput.withsppf.sppf - -import java.util.* - -open class ParentSPPFNode(leftExtent: Int, rightExtent: Int) : SPPFNode(leftExtent, rightExtent) { - val kids: HashSet = HashSet() - - override fun toString() = "ParentSPPFNode(leftExtent=$leftExtent, rightExtent=$rightExtent)" - - override fun equals(other: Any?): Boolean { - if (this === other) return true - if (other !is ParentSPPFNode) return false - if (!super.equals(other)) return false - - return true - } - - override val hashCode: Int = Objects.hash(leftExtent, rightExtent) - override fun hashCode() = hashCode -} diff --git a/src/main/kotlin/org/kotgll/cfg/stringinput/withsppf/sppf/SPPFNode.kt b/src/main/kotlin/org/kotgll/cfg/stringinput/withsppf/sppf/SPPFNode.kt deleted file mode 100644 index fb4d95038..000000000 --- a/src/main/kotlin/org/kotgll/cfg/stringinput/withsppf/sppf/SPPFNode.kt +++ /dev/null @@ -1,23 +0,0 @@ -package org.kotgll.cfg.stringinput.withsppf.sppf - -import org.kotgll.cfg.grammar.symbol.Symbol -import java.util.* - -open class SPPFNode(val leftExtent: Int, val rightExtent: Int) { - override fun toString() = "SPPFNode(leftExtent=$leftExtent, rightExtent=$rightExtent)" - - override fun equals(other: Any?): Boolean { - if (this === other) return true - if (other !is SPPFNode) return false - - if (leftExtent != other.leftExtent) return false - if (rightExtent != other.rightExtent) return false - - return true - } - - open val hashCode: Int = Objects.hash(leftExtent, rightExtent) - override fun hashCode() = hashCode - - open fun hasSymbol(symbol: Symbol) = false -} diff --git a/src/main/kotlin/org/kotgll/cfg/stringinput/withsppf/sppf/SymbolSPPFNode.kt b/src/main/kotlin/org/kotgll/cfg/stringinput/withsppf/sppf/SymbolSPPFNode.kt deleted file mode 100644 index 22456638e..000000000 --- a/src/main/kotlin/org/kotgll/cfg/stringinput/withsppf/sppf/SymbolSPPFNode.kt +++ /dev/null @@ -1,29 +0,0 @@ -package org.kotgll.cfg.stringinput.withsppf.sppf - -import org.kotgll.cfg.grammar.symbol.Nonterminal -import org.kotgll.cfg.grammar.symbol.Symbol -import java.util.* - -class SymbolSPPFNode( - leftExtent: Int, - rightExtent: Int, - val symbol: Nonterminal, -) : ParentSPPFNode(leftExtent, rightExtent) { - override fun toString() = - "SymbolSPPFNode(leftExtent=$leftExtent, rightExtent=$rightExtent, symbol=$symbol)" - - override fun equals(other: Any?): Boolean { - if (this === other) return true - if (other !is SymbolSPPFNode) return false - if (!super.equals(other)) return false - - if (symbol != other.symbol) return false - - return true - } - - override val hashCode: Int = Objects.hash(leftExtent, rightExtent, symbol) - override fun hashCode() = hashCode - - override fun hasSymbol(symbol: Symbol) = this.symbol == symbol -} diff --git a/src/main/kotlin/org/kotgll/cfg/stringinput/withsppf/sppf/TerminalSPPFNode.kt b/src/main/kotlin/org/kotgll/cfg/stringinput/withsppf/sppf/TerminalSPPFNode.kt deleted file mode 100644 index 7985aee2d..000000000 --- a/src/main/kotlin/org/kotgll/cfg/stringinput/withsppf/sppf/TerminalSPPFNode.kt +++ /dev/null @@ -1,23 +0,0 @@ -package org.kotgll.cfg.stringinput.withsppf.sppf - -import org.kotgll.cfg.grammar.symbol.Terminal -import java.util.* - -class TerminalSPPFNode(leftExtent: Int, rightExtent: Int, val terminal: Terminal) : - SPPFNode(leftExtent, rightExtent) { - override fun toString() = - "TerminalSPPFNode(leftExtent=$leftExtent, rightExtent=$rightExtent, terminal=$terminal)" - - override fun equals(other: Any?): Boolean { - if (this === other) return true - if (other !is TerminalSPPFNode) return false - if (!super.equals(other)) return false - - if (terminal != other.terminal) return false - - return true - } - - override val hashCode: Int = Objects.hash(leftExtent, rightExtent, terminal) - override fun hashCode() = hashCode -} diff --git a/src/main/kotlin/org/kotgll/graph/GraphNode.kt b/src/main/kotlin/org/kotgll/graph/GraphNode.kt deleted file mode 100644 index 8727f815d..000000000 --- a/src/main/kotlin/org/kotgll/graph/GraphNode.kt +++ /dev/null @@ -1,24 +0,0 @@ -package org.kotgll.graph - -class GraphNode(val id: Int, var isStart: Boolean = false, var isFinal: Boolean = false) { - var outgoingEdges: HashMap> = HashMap() - - override fun toString() = "GraphNode(id=$id, isStart=$isStart, isFinal=$isFinal)" - - override fun equals(other: Any?): Boolean { - if (this === other) return true - if (other !is GraphNode) return false - - if (id != other.id) return false - - return true - } - - val hashCode: Int = id - override fun hashCode() = id - - fun addEdge(label: String, head: GraphNode) { - if (!outgoingEdges.containsKey(label)) outgoingEdges[label] = ArrayList() - outgoingEdges[label]!!.add(head) - } -} diff --git a/src/main/kotlin/org/kotgll/graph/GraphRead.kt b/src/main/kotlin/org/kotgll/graph/GraphRead.kt deleted file mode 100644 index 3718df71c..000000000 --- a/src/main/kotlin/org/kotgll/graph/GraphRead.kt +++ /dev/null @@ -1,54 +0,0 @@ -package org.kotgll.graph - -import java.io.File - -fun readGraphFromString(input: String): GraphNode { - val result = GraphNode(id = 0, isStart = true) - var cur = result - for (i in input.indices) { - val head = GraphNode(id = i + 1) - cur.addEdge(input[i] + "", head) - cur = head - } - cur.isFinal = true - return result -} - -fun readGraphFromCSV(pathToCSV: String): ArrayList { - val graphNodes: HashMap = HashMap() - fun makeGraphNode(id: Int, isStart: Boolean = false, isFinal: Boolean = false): GraphNode { - val y = GraphNode(id, isStart, isFinal) - if (!graphNodes.containsKey(y.id)) graphNodes[y.id] = y - return graphNodes[y.id]!! - } - - val reader = File(pathToCSV).inputStream().bufferedReader() - while (true) { - val line: String = reader.readLine() ?: break - val (tail, head, label) = line.split(' ', limit = 3) - - val tailGraphNode = makeGraphNode(id = tail.toInt(), isStart = true, isFinal = true) - val headGraphNode = makeGraphNode(id = head.toInt(), isStart = true, isFinal = true) - - tailGraphNode.addEdge(label, headGraphNode) - } - - return ArrayList(graphNodes.values) -} - -fun readStartNodesFromCSV(pathToCSV: String): ArrayList { - val graphNodes: HashMap = HashMap() - fun makeGraphNode(id: Int, isStart: Boolean = false, isFinal: Boolean = false): GraphNode { - val y = GraphNode(id, isStart, isFinal) - if (!graphNodes.containsKey(y.id)) graphNodes[y.id] = y - return graphNodes[y.id]!! - } - - val reader = File(pathToCSV).inputStream().bufferedReader() - while (true) { - val node: Int = reader.readLine()?.toInt() ?: break - makeGraphNode(node, isStart = true, isFinal = true) - } - - return ArrayList(graphNodes.values) -} diff --git a/src/main/kotlin/org/kotgll/graph/GraphWrite.kt b/src/main/kotlin/org/kotgll/graph/GraphWrite.kt deleted file mode 100644 index 258fc80d4..000000000 --- a/src/main/kotlin/org/kotgll/graph/GraphWrite.kt +++ /dev/null @@ -1,25 +0,0 @@ -package org.kotgll.graph - -import java.io.File - -fun writeGraphToCSV(graph: ArrayList, pathToCSV: String) { - val edges: ArrayList> = ArrayList() - - val visited: HashSet = HashSet() - val queue: ArrayDeque = ArrayDeque(graph) - while (!queue.isEmpty()) { - val v = queue.removeFirst() - visited.add(v) - for (edge in v.outgoingEdges) { - for (head in edge.value) { - val newEdge = Triple(v, edge.key, head) - if (!edges.contains(newEdge)) edges.add(newEdge) - if (!visited.contains(head)) queue.addFirst(head) - } - } - } - - File(pathToCSV).printWriter().use { out -> - edges.forEach { out.println("${it.first.id} ${it.third.id} ${it.second}") } - } -} diff --git a/src/main/kotlin/org/kotgll/rsm/grammar/RSMEdge.kt b/src/main/kotlin/org/kotgll/rsm/grammar/RSMEdge.kt deleted file mode 100644 index 2f0811901..000000000 --- a/src/main/kotlin/org/kotgll/rsm/grammar/RSMEdge.kt +++ /dev/null @@ -1,3 +0,0 @@ -package org.kotgll.rsm.grammar - -interface RSMEdge diff --git a/src/main/kotlin/org/kotgll/rsm/grammar/RSMNonterminalEdge.kt b/src/main/kotlin/org/kotgll/rsm/grammar/RSMNonterminalEdge.kt deleted file mode 100644 index 3c420a0d8..000000000 --- a/src/main/kotlin/org/kotgll/rsm/grammar/RSMNonterminalEdge.kt +++ /dev/null @@ -1,20 +0,0 @@ -package org.kotgll.rsm.grammar - -import org.kotgll.rsm.grammar.symbol.Nonterminal - -class RSMNonterminalEdge(val nonterminal: Nonterminal, val head: RSMState) : RSMEdge { - override fun toString() = "RSMNonterminalEdge(nonterminal=$nonterminal, head=$head)" - - override fun equals(other: Any?): Boolean { - if (this === other) return true - if (other !is RSMNonterminalEdge) return false - - if (nonterminal != other.nonterminal) return false - if (head != other.head) return false - - return true - } - - val hashCode: Int = nonterminal.hashCode - override fun hashCode() = hashCode -} diff --git a/src/main/kotlin/org/kotgll/rsm/grammar/RSMRead.kt b/src/main/kotlin/org/kotgll/rsm/grammar/RSMRead.kt deleted file mode 100644 index 843e91b6c..000000000 --- a/src/main/kotlin/org/kotgll/rsm/grammar/RSMRead.kt +++ /dev/null @@ -1,113 +0,0 @@ -package org.kotgll.rsm.grammar - -import org.kotgll.rsm.grammar.symbol.Nonterminal -import org.kotgll.rsm.grammar.symbol.Terminal -import java.io.File - -fun readRSMFromTXT(pathToTXT: String): RSMState { - var startRSMState: RSMState? = null - val rsmStates: HashMap = HashMap() - fun makeRSMState( - id: Int, - nonterminal: Nonterminal, - isStart: Boolean = false, - isFinal: Boolean = false - ): RSMState { - val y = RSMState(id, nonterminal, isStart, isFinal) - if (!rsmStates.containsKey(y.hashCode)) rsmStates[y.hashCode] = y - return rsmStates[y.hashCode]!! - } - - val nonterminals: HashMap = HashMap() - fun makeNonterminal(name: String): Nonterminal { - val y = Nonterminal(name) - if (!nonterminals.contains(y)) nonterminals[y] = y - return nonterminals[y]!! - } - - val startStateRegex = - """^StartState\( - |id=(?.*), - |nonterminal=Nonterminal\("(?.*)"\), - |isStart=(?.*), - |isFinal=(?.*) - |\)$""" - .trimMargin() - .replace("\n", "") - .toRegex() - val rsmStateRegex = - """^State\( - |id=(?.*), - |nonterminal=Nonterminal\("(?.*)"\), - |isStart=(?.*), - |isFinal=(?.*) - |\)$""" - .trimMargin() - .replace("\n", "") - .toRegex() - val rsmTerminalEdgeRegex = - """^TerminalEdge\( - |tail=(?.*), - |head=(?.*), - |terminal=Terminal\("(?.*)"\) - |\)$""" - .trimMargin() - .replace("\n", "") - .toRegex() - val rsmNonterminalEdgeRegex = - """^NonterminalEdge\( - |tail=(?.*), - |head=(?.*), - |nonterminal=Nonterminal\("(?.*)"\) - |\)$""" - .trimMargin() - .replace("\n", "") - .toRegex() - - val reader = File(pathToTXT).inputStream().bufferedReader() - while (true) { - val line = reader.readLine() ?: break - - if (startStateRegex.matches(line)) { - val (idValue, nonterminalValue, isStartValue, isFinalValue) = - startStateRegex.matchEntire(line)!!.destructured - - val tmpNonterminal = makeNonterminal(nonterminalValue) - startRSMState = - makeRSMState( - id = idValue.toInt(), - nonterminal = tmpNonterminal, - isStart = isStartValue == "true", - isFinal = isFinalValue == "true", - ) - if (startRSMState.isStart) tmpNonterminal.startState = startRSMState - } else if (rsmStateRegex.matches(line)) { - val (idValue, nonterminalValue, isStartValue, isFinalValue) = - rsmStateRegex.matchEntire(line)!!.destructured - val tmpNonterminal = makeNonterminal(nonterminalValue) - val tmpRSMState = - makeRSMState( - id = idValue.toInt(), - nonterminal = tmpNonterminal, - isStart = isStartValue == "true", - isFinal = isFinalValue == "true", - ) - if (tmpRSMState.isStart) tmpNonterminal.startState = tmpRSMState - } else if (rsmTerminalEdgeRegex.matches(line)) { - val (tailId, headId, terminalValue) = rsmTerminalEdgeRegex.matchEntire(line)!!.destructured - val tailRSMState = rsmStates[tailId.toInt()]!! - val headRSMState = rsmStates[headId.toInt()]!! - tailRSMState.addTerminalEdge( - RSMTerminalEdge(terminal = Terminal(terminalValue), head = headRSMState)) - } else if (rsmNonterminalEdgeRegex.matches(line)) { - val (tailId, headId, nonterminalValue) = - rsmNonterminalEdgeRegex.matchEntire(line)!!.destructured - val tailRSMState = rsmStates[tailId.toInt()]!! - val headRSMState = rsmStates[headId.toInt()]!! - tailRSMState.addNonterminalEdge( - RSMNonterminalEdge(nonterminal = makeNonterminal(nonterminalValue), head = headRSMState)) - } - } - - return startRSMState!! -} diff --git a/src/main/kotlin/org/kotgll/rsm/grammar/RSMState.kt b/src/main/kotlin/org/kotgll/rsm/grammar/RSMState.kt deleted file mode 100644 index af2b149b0..000000000 --- a/src/main/kotlin/org/kotgll/rsm/grammar/RSMState.kt +++ /dev/null @@ -1,36 +0,0 @@ -package org.kotgll.rsm.grammar - -import org.kotgll.rsm.grammar.symbol.Nonterminal - -class RSMState( - val id: Int, - val nonterminal: Nonterminal, - val isStart: Boolean = false, - val isFinal: Boolean = false -) { - val outgoingTerminalEdges: ArrayList = ArrayList() - val outgoingNonterminalEdges: ArrayList = ArrayList() - - override fun toString() = - "RSMState(id=$id, nonterminal=$nonterminal, isStart=$isStart, isFinal=$isFinal)" - - override fun equals(other: Any?): Boolean { - if (this === other) return true - if (other !is RSMState) return false - - if (id != other.id) return false - - return true - } - - val hashCode: Int = id - override fun hashCode() = hashCode - - fun addTerminalEdge(edge: RSMTerminalEdge) { - if (!outgoingTerminalEdges.contains(edge)) outgoingTerminalEdges.add(edge) - } - - fun addNonterminalEdge(edge: RSMNonterminalEdge) { - if (!outgoingNonterminalEdges.contains(edge)) outgoingNonterminalEdges.add(edge) - } -} diff --git a/src/main/kotlin/org/kotgll/rsm/grammar/RSMTerminalEdge.kt b/src/main/kotlin/org/kotgll/rsm/grammar/RSMTerminalEdge.kt deleted file mode 100644 index 12867c398..000000000 --- a/src/main/kotlin/org/kotgll/rsm/grammar/RSMTerminalEdge.kt +++ /dev/null @@ -1,20 +0,0 @@ -package org.kotgll.rsm.grammar - -import org.kotgll.rsm.grammar.symbol.Terminal - -class RSMTerminalEdge(val terminal: Terminal, val head: RSMState) : RSMEdge { - override fun toString() = "RSMTerminalEdge(terminal=$terminal, head=$head)" - - override fun equals(other: Any?): Boolean { - if (this === other) return true - if (other !is RSMTerminalEdge) return false - - if (terminal != other.terminal) return false - if (head != other.head) return false - - return true - } - - val hashCode: Int = terminal.hashCode - override fun hashCode() = hashCode -} diff --git a/src/main/kotlin/org/kotgll/rsm/grammar/RSMWrite.kt b/src/main/kotlin/org/kotgll/rsm/grammar/RSMWrite.kt deleted file mode 100644 index a76fbb9b0..000000000 --- a/src/main/kotlin/org/kotgll/rsm/grammar/RSMWrite.kt +++ /dev/null @@ -1,65 +0,0 @@ -package org.kotgll.rsm.grammar - -import java.io.File - -fun writeRSMToTXT(startState: RSMState, pathToTXT: String) { - val states: ArrayList = ArrayList() - - val queue: ArrayDeque = ArrayDeque(listOf(startState)) - while (!queue.isEmpty()) { - val v = queue.removeFirst() - if (!states.contains(v)) states.add(v) - for (edge in v.outgoingTerminalEdges) { - if (!states.contains(edge.head)) queue.addLast(edge.head) - } - for (edge in v.outgoingNonterminalEdges) { - if (!states.contains(edge.head)) queue.addLast(edge.head) - if (!states.contains(edge.nonterminal.startState)) queue.addLast(edge.nonterminal.startState) - } - } - - File(pathToTXT).printWriter().use { out -> - out.println( - """StartState( - |id=${startState.id}, - |nonterminal=Nonterminal("${startState.nonterminal.name}"), - |isStart=${startState.isStart}, - |isFinal=${startState.isFinal} - |)""" - .trimMargin() - .replace("\n", "")) - states.forEach { state -> - out.println( - """State( - |id=${state.id}, - |nonterminal=Nonterminal("${state.nonterminal.name}"), - |isStart=${state.isStart}, - |isFinal=${state.isFinal} - |)""" - .trimMargin() - .replace("\n", "")) - } - states.forEach { state -> - state.outgoingTerminalEdges.forEach { edge -> - out.println( - """TerminalEdge( - |tail=${state.id}, - |head=${edge.head.id}, - |terminal=Terminal("${edge.terminal.value}") - |)""" - .trimMargin() - .replace("\n", "")) - } - state.outgoingNonterminalEdges.forEach { edge -> - out.println( - """NonterminalEdge( - |tail=${state.id}, - |head=${edge.head.id}, - |nonterminal=Nonterminal("${edge.nonterminal.name}") - |)""" - .trimMargin() - .replace("\n", "")) - } - } - } -} diff --git a/src/main/kotlin/org/kotgll/rsm/grammar/symbol/Nonterminal.kt b/src/main/kotlin/org/kotgll/rsm/grammar/symbol/Nonterminal.kt deleted file mode 100644 index 3de004bb8..000000000 --- a/src/main/kotlin/org/kotgll/rsm/grammar/symbol/Nonterminal.kt +++ /dev/null @@ -1,20 +0,0 @@ -package org.kotgll.rsm.grammar.symbol - -import org.kotgll.rsm.grammar.RSMState - -class Nonterminal(val name: String) : Symbol { - lateinit var startState: RSMState - override fun toString() = "Nonterminal($name)" - - override fun equals(other: Any?): Boolean { - if (this === other) return true - if (other !is Nonterminal) return false - - if (name != other.name) return false - - return true - } - - val hashCode: Int = name.hashCode() - override fun hashCode() = hashCode -} diff --git a/src/main/kotlin/org/kotgll/rsm/grammar/symbol/Symbol.kt b/src/main/kotlin/org/kotgll/rsm/grammar/symbol/Symbol.kt deleted file mode 100644 index 1b2c427e2..000000000 --- a/src/main/kotlin/org/kotgll/rsm/grammar/symbol/Symbol.kt +++ /dev/null @@ -1,3 +0,0 @@ -package org.kotgll.rsm.grammar.symbol - -interface Symbol diff --git a/src/main/kotlin/org/kotgll/rsm/grammar/symbol/Terminal.kt b/src/main/kotlin/org/kotgll/rsm/grammar/symbol/Terminal.kt deleted file mode 100644 index 06340c9c2..000000000 --- a/src/main/kotlin/org/kotgll/rsm/grammar/symbol/Terminal.kt +++ /dev/null @@ -1,20 +0,0 @@ -package org.kotgll.rsm.grammar.symbol - -class Terminal(val value: String) : Symbol { - val size: Int = value.length - fun match(pos: Int, input: String) = input.startsWith(value, pos) - - override fun toString() = "Literal($value)" - - override fun equals(other: Any?): Boolean { - if (this === other) return true - if (other !is Terminal) return false - - if (value != other.value) return false - - return true - } - - val hashCode: Int = value.hashCode() - override fun hashCode() = hashCode -} diff --git a/src/main/kotlin/org/kotgll/rsm/graphinput/withoutsppf/DescriptorsQueue.kt b/src/main/kotlin/org/kotgll/rsm/graphinput/withoutsppf/DescriptorsQueue.kt deleted file mode 100644 index d5814351b..000000000 --- a/src/main/kotlin/org/kotgll/rsm/graphinput/withoutsppf/DescriptorsQueue.kt +++ /dev/null @@ -1,38 +0,0 @@ -package org.kotgll.rsm.graphinput.withoutsppf - -import org.kotgll.graph.GraphNode -import org.kotgll.rsm.grammar.RSMState -import java.util.* -import kotlin.collections.ArrayDeque - -class DescriptorsQueue { - val todo: ArrayDeque = ArrayDeque() - val created: HashMap> = HashMap() - - fun add(rsmState: RSMState, gssNode: GSSNode, pos: GraphNode) { - val descriptor = Descriptor(rsmState, gssNode, pos) - if (!created.containsKey(pos)) created[pos] = HashSet() - if (created[pos]!!.add(descriptor)) todo.addLast(descriptor) - } - - fun next() = todo.removeFirst() - - fun isEmpty() = todo.isEmpty() - - class Descriptor(val rsmState: RSMState, val gssNode: GSSNode, val pos: GraphNode) { - override fun toString() = "Descriptor(rsmState=$rsmState, gssNode=$gssNode, pos=$pos)" - - override fun equals(other: Any?): Boolean { - if (this === other) return true - if (other !is Descriptor) return false - - if (rsmState != other.rsmState) return false - if (gssNode != other.gssNode) return false - - return true - } - - val hashCode: Int = Objects.hash(rsmState, gssNode) - override fun hashCode() = hashCode - } -} diff --git a/src/main/kotlin/org/kotgll/rsm/graphinput/withoutsppf/GLL.kt b/src/main/kotlin/org/kotgll/rsm/graphinput/withoutsppf/GLL.kt deleted file mode 100644 index 3a22765f5..000000000 --- a/src/main/kotlin/org/kotgll/rsm/graphinput/withoutsppf/GLL.kt +++ /dev/null @@ -1,88 +0,0 @@ -package org.kotgll.rsm.graphinput.withoutsppf - -import org.kotgll.graph.GraphNode -import org.kotgll.rsm.grammar.RSMState -import org.kotgll.rsm.grammar.symbol.Nonterminal - -class GLL(val startState: RSMState, val startGraphNodes: ArrayList) { - constructor( - startState: RSMState, - startGraphNodes: List - ) : this(startState, ArrayList(startGraphNodes)) - - val queue: DescriptorsQueue = DescriptorsQueue() - val poppedGSSNodes: HashMap> = HashMap() - val createdGSSNodes: HashMap = HashMap() - val parseResult: HashMap> = HashMap() - - fun getOrCreateGSSNode(nonterminal: Nonterminal, pos: GraphNode): GSSNode { - val gssNode = GSSNode(nonterminal, pos) - if (!createdGSSNodes.containsKey(gssNode)) createdGSSNodes[gssNode] = gssNode - return createdGSSNodes[gssNode]!! - } - - fun parse(): HashMap> { - for (graphNode in startGraphNodes) { - queue.add(startState, getOrCreateGSSNode(startState.nonterminal, graphNode), graphNode) - } - - while (!queue.isEmpty()) { - val descriptor: DescriptorsQueue.Descriptor = queue.next() - parse(descriptor.rsmState, descriptor.pos, descriptor.gssNode) - } - - return parseResult - } - - fun parse(state: RSMState, pos: GraphNode, gssNode: GSSNode) { - for (rsmEdge in state.outgoingTerminalEdges) { - if (pos.outgoingEdges.containsKey(rsmEdge.terminal.value)) { - for (head in pos.outgoingEdges[rsmEdge.terminal.value]!!) { - queue.add(rsmEdge.head, gssNode, head) - } - } - } - - for (rsmEdge in state.outgoingNonterminalEdges) { - queue.add( - rsmEdge.nonterminal.startState, - createGSSNode(rsmEdge.nonterminal, rsmEdge.head, gssNode, pos), - pos) - } - - if (state.isFinal) pop(gssNode, pos) - } - - fun pop(gssNode: GSSNode, pos: GraphNode) { - if (gssNode.nonterminal == startState.nonterminal && gssNode.pos.isStart && pos.isFinal) { - if (!parseResult.containsKey(gssNode.pos.id)) parseResult[gssNode.pos.id] = HashSet() - parseResult[gssNode.pos.id]!!.add(pos.id) - } - if (!poppedGSSNodes.containsKey(gssNode)) poppedGSSNodes[gssNode] = HashSet() - poppedGSSNodes[gssNode]!!.add(pos) - for (e in gssNode.edges) { - for (u in e.value) { - queue.add(e.key, u, pos) - } - } - } - - fun createGSSNode( - nonterminal: Nonterminal, - state: RSMState, - gssNode: GSSNode, - pos: GraphNode - ): GSSNode { - val v: GSSNode = getOrCreateGSSNode(nonterminal, pos) - - if (v.addEdge(state, gssNode)) { - if (poppedGSSNodes.containsKey(v)) { - for (z in poppedGSSNodes[v]!!) { - queue.add(state, gssNode, z) - } - } - } - - return v - } -} diff --git a/src/main/kotlin/org/kotgll/rsm/graphinput/withoutsppf/GSSNode.kt b/src/main/kotlin/org/kotgll/rsm/graphinput/withoutsppf/GSSNode.kt deleted file mode 100644 index e4cabfdc4..000000000 --- a/src/main/kotlin/org/kotgll/rsm/graphinput/withoutsppf/GSSNode.kt +++ /dev/null @@ -1,30 +0,0 @@ -package org.kotgll.rsm.graphinput.withoutsppf - -import org.kotgll.graph.GraphNode -import org.kotgll.rsm.grammar.RSMState -import org.kotgll.rsm.grammar.symbol.Nonterminal -import java.util.* - -class GSSNode(val nonterminal: Nonterminal, val pos: GraphNode) { - val edges: HashMap> = HashMap() - - fun addEdge(rsmState: RSMState, gssNode: GSSNode): Boolean { - if (!edges.containsKey(rsmState)) edges[rsmState] = HashSet() - return edges[rsmState]!!.add(gssNode) - } - - override fun toString() = "GSSNode(nonterminal=$nonterminal, pos=$pos)" - - override fun equals(other: Any?): Boolean { - if (this === other) return true - if (other !is GSSNode) return false - - if (nonterminal != other.nonterminal) return false - if (pos != other.pos) return false - - return true - } - - val hashCode = Objects.hash(nonterminal, pos) - override fun hashCode() = hashCode -} diff --git a/src/main/kotlin/org/kotgll/rsm/graphinput/withsppf/DescriptorsQueue.kt b/src/main/kotlin/org/kotgll/rsm/graphinput/withsppf/DescriptorsQueue.kt deleted file mode 100644 index 404fe4aee..000000000 --- a/src/main/kotlin/org/kotgll/rsm/graphinput/withsppf/DescriptorsQueue.kt +++ /dev/null @@ -1,46 +0,0 @@ -package org.kotgll.rsm.graphinput.withsppf - -import org.kotgll.graph.GraphNode -import org.kotgll.rsm.grammar.RSMState -import org.kotgll.rsm.graphinput.withsppf.sppf.SPPFNode -import java.util.* -import kotlin.collections.ArrayDeque - -class DescriptorsQueue { - val todo: ArrayDeque = ArrayDeque() - val created: HashMap> = HashMap() - - fun add(rsmState: RSMState, gssNode: GSSNode, sppfNode: SPPFNode?, pos: GraphNode) { - val descriptor = Descriptor(rsmState, gssNode, sppfNode, pos) - if (!created.containsKey(pos)) created[pos] = HashSet() - if (created[pos]!!.add(descriptor)) todo.addLast(descriptor) - } - - fun next() = todo.removeFirst() - - fun isEmpty() = todo.isEmpty() - - class Descriptor( - val rsmState: RSMState, - val gssNode: GSSNode, - val sppfNode: SPPFNode?, - val pos: GraphNode, - ) { - override fun toString() = - "Descriptor(rsmState=$rsmState, gssNode=$gssNode, sppfNode=$sppfNode, pos=$pos)" - - override fun equals(other: Any?): Boolean { - if (this === other) return true - if (other !is Descriptor) return false - - if (rsmState != other.rsmState) return false - if (gssNode != other.gssNode) return false - if (sppfNode != other.sppfNode) return false - - return true - } - - val hashCode: Int = Objects.hash(rsmState, gssNode, sppfNode) - override fun hashCode() = hashCode - } -} diff --git a/src/main/kotlin/org/kotgll/rsm/graphinput/withsppf/GLL.kt b/src/main/kotlin/org/kotgll/rsm/graphinput/withsppf/GLL.kt deleted file mode 100644 index cb5444513..000000000 --- a/src/main/kotlin/org/kotgll/rsm/graphinput/withsppf/GLL.kt +++ /dev/null @@ -1,149 +0,0 @@ -package org.kotgll.rsm.graphinput.withsppf - -import org.kotgll.graph.GraphNode -import org.kotgll.rsm.grammar.RSMState -import org.kotgll.rsm.grammar.symbol.Nonterminal -import org.kotgll.rsm.grammar.symbol.Terminal -import org.kotgll.rsm.graphinput.withsppf.sppf.* - -class GLL(val startState: RSMState, val startGraphNodes: ArrayList) { - constructor( - startState: RSMState, - startGraphNodes: List - ) : this(startState, ArrayList(startGraphNodes)) - - val queue: DescriptorsQueue = DescriptorsQueue() - val poppedGSSNodes: HashMap> = HashMap() - val createdGSSNodes: HashMap = HashMap() - val createdSPPFNodes: HashMap = HashMap() - val parseResult: HashMap> = HashMap() - - fun getOrCreateGSSNode(nonterminal: Nonterminal, pos: GraphNode): GSSNode { - val gssNode = GSSNode(nonterminal, pos) - if (!createdGSSNodes.containsKey(gssNode)) createdGSSNodes[gssNode] = gssNode - return createdGSSNodes[gssNode]!! - } - - fun parse(): HashMap> { - for (graphNode in startGraphNodes) { - queue.add(startState, getOrCreateGSSNode(startState.nonterminal, graphNode), null, graphNode) - } - - while (!queue.isEmpty()) { - val descriptor: DescriptorsQueue.Descriptor = queue.next() - parse(descriptor.rsmState, descriptor.gssNode, descriptor.sppfNode, descriptor.pos) - } - - return parseResult - } - - fun parse(state: RSMState, gssNode: GSSNode, sppfNode: SPPFNode?, pos: GraphNode) { - var curSPPFNode: SPPFNode? = sppfNode - - if (state.isStart && state.isFinal) - curSPPFNode = getNodeP(state, curSPPFNode, getOrCreateItemSPPFNode(state, pos, pos)) - - for (rsmEdge in state.outgoingTerminalEdges) { - if (pos.outgoingEdges.containsKey(rsmEdge.terminal.value)) { - for (head in pos.outgoingEdges[rsmEdge.terminal.value]!!) { - queue.add( - rsmEdge.head, - gssNode, - getNodeP( - rsmEdge.head, - curSPPFNode, - getOrCreateTerminalSPPFNode(rsmEdge.terminal, pos, head)), - head) - } - } - } - - for (rsmEdge in state.outgoingNonterminalEdges) { - queue.add( - rsmEdge.nonterminal.startState, - createGSSNode(rsmEdge.nonterminal, rsmEdge.head, gssNode, curSPPFNode, pos), - null, - pos) - } - - if (state.isFinal) pop(gssNode, curSPPFNode, pos) - } - - fun pop(gssNode: GSSNode, sppfNode: SPPFNode?, pos: GraphNode) { - if (!poppedGSSNodes.containsKey(gssNode)) poppedGSSNodes[gssNode] = HashSet() - poppedGSSNodes[gssNode]!!.add(sppfNode) - for (e in gssNode.edges) { - for (u in e.value) { - queue.add(e.key.first, u, getNodeP(e.key.first, e.key.second, sppfNode!!), pos) - } - } - } - - fun createGSSNode( - nonterminal: Nonterminal, - state: RSMState, - gssNode: GSSNode, - sppfNode: SPPFNode?, - pos: GraphNode, - ): GSSNode { - val v: GSSNode = getOrCreateGSSNode(nonterminal, pos) - - if (v.addEdge(state, sppfNode, gssNode)) { - if (poppedGSSNodes.containsKey(v)) { - for (z in poppedGSSNodes[v]!!) { - queue.add(state, gssNode, getNodeP(state, sppfNode, z!!), z.rightExtent) - } - } - } - - return v - } - - fun getNodeP(state: RSMState, sppfNode: SPPFNode?, nextSPPFNode: SPPFNode): SPPFNode { - val leftExtent = sppfNode?.leftExtent ?: nextSPPFNode.leftExtent - val rightExtent = nextSPPFNode.rightExtent - - val y: ParentSPPFNode = - if (state.isFinal) getOrCreateSymbolSPPFNode(state.nonterminal, leftExtent, rightExtent) - else getOrCreateItemSPPFNode(state, leftExtent, rightExtent) - - y.kids.add(PackedSPPFNode(nextSPPFNode.leftExtent, state, sppfNode, nextSPPFNode)) - - return y - } - - fun getOrCreateTerminalSPPFNode( - terminal: Terminal, - leftExtent: GraphNode, - rightExtent: GraphNode - ): SPPFNode { - val y = TerminalSPPFNode(leftExtent, rightExtent, terminal) - if (!createdSPPFNodes.containsKey(y)) createdSPPFNodes[y] = y - return createdSPPFNodes[y]!! - } - - fun getOrCreateItemSPPFNode( - state: RSMState, - leftExtent: GraphNode, - rightExtent: GraphNode - ): ParentSPPFNode { - val y = ItemSPPFNode(leftExtent, rightExtent, state) - if (!createdSPPFNodes.containsKey(y)) createdSPPFNodes[y] = y - return createdSPPFNodes[y]!! as ParentSPPFNode - } - - fun getOrCreateSymbolSPPFNode( - nonterminal: Nonterminal, - leftExtent: GraphNode, - rightExtent: GraphNode - ): SymbolSPPFNode { - val y = SymbolSPPFNode(leftExtent, rightExtent, nonterminal) - if (!createdSPPFNodes.containsKey(y)) createdSPPFNodes[y] = y - val result = createdSPPFNodes[y]!! as SymbolSPPFNode - if (nonterminal == startState.nonterminal && leftExtent.isStart && rightExtent.isFinal) { - if (!parseResult.containsKey(leftExtent.id)) parseResult[leftExtent.id] = HashMap() - parseResult[leftExtent.id]!![rightExtent.id] = result - } - return result - } -} diff --git a/src/main/kotlin/org/kotgll/rsm/graphinput/withsppf/GSSNode.kt b/src/main/kotlin/org/kotgll/rsm/graphinput/withsppf/GSSNode.kt deleted file mode 100644 index 2f91fb9ca..000000000 --- a/src/main/kotlin/org/kotgll/rsm/graphinput/withsppf/GSSNode.kt +++ /dev/null @@ -1,32 +0,0 @@ -package org.kotgll.rsm.graphinput.withsppf - -import org.kotgll.graph.GraphNode -import org.kotgll.rsm.grammar.RSMState -import org.kotgll.rsm.grammar.symbol.Nonterminal -import org.kotgll.rsm.graphinput.withsppf.sppf.SPPFNode -import java.util.* - -class GSSNode(val nonterminal: Nonterminal, val pos: GraphNode) { - val edges: HashMap, HashSet> = HashMap() - - fun addEdge(rsmState: RSMState, sppfNode: SPPFNode?, gssNode: GSSNode): Boolean { - val label = Pair(rsmState, sppfNode) - if (!edges.containsKey(label)) edges[label] = HashSet() - return edges[label]!!.add(gssNode) - } - - override fun toString() = "GSSNode(nonterminal=$nonterminal, pos=$pos)" - - override fun equals(other: Any?): Boolean { - if (this === other) return true - if (other !is GSSNode) return false - - if (nonterminal != other.nonterminal) return false - if (pos != other.pos) return false - - return true - } - - val hashCode = Objects.hash(nonterminal, pos) - override fun hashCode() = hashCode -} diff --git a/src/main/kotlin/org/kotgll/rsm/graphinput/withsppf/sppf/ItemSPPFNode.kt b/src/main/kotlin/org/kotgll/rsm/graphinput/withsppf/sppf/ItemSPPFNode.kt deleted file mode 100644 index e21666397..000000000 --- a/src/main/kotlin/org/kotgll/rsm/graphinput/withsppf/sppf/ItemSPPFNode.kt +++ /dev/null @@ -1,24 +0,0 @@ -package org.kotgll.rsm.graphinput.withsppf.sppf - -import org.kotgll.graph.GraphNode -import org.kotgll.rsm.grammar.RSMState -import java.util.* - -class ItemSPPFNode(leftExtent: GraphNode, rightExtent: GraphNode, val rsmState: RSMState) : - ParentSPPFNode(leftExtent, rightExtent) { - override fun toString() = - "ItemSPPFNode(leftExtent=$leftExtent, rightExtent=$rightExtent, rsmState=$rsmState)" - - override fun equals(other: Any?): Boolean { - if (this === other) return true - if (other !is ItemSPPFNode) return false - if (!super.equals(other)) return false - - if (rsmState != other.rsmState) return false - - return true - } - - override val hashCode: Int = Objects.hash(leftExtent, rightExtent, rsmState) - override fun hashCode() = hashCode -} diff --git a/src/main/kotlin/org/kotgll/rsm/graphinput/withsppf/sppf/PackedSPPFNode.kt b/src/main/kotlin/org/kotgll/rsm/graphinput/withsppf/sppf/PackedSPPFNode.kt deleted file mode 100644 index 084304aa2..000000000 --- a/src/main/kotlin/org/kotgll/rsm/graphinput/withsppf/sppf/PackedSPPFNode.kt +++ /dev/null @@ -1,30 +0,0 @@ -package org.kotgll.rsm.graphinput.withsppf.sppf - -import org.kotgll.graph.GraphNode -import org.kotgll.rsm.grammar.RSMState -import java.util.* - -open class PackedSPPFNode( - val pivot: GraphNode, - val rsmState: RSMState, - val leftSPPFNode: SPPFNode? = null, - val rightSPPFNode: SPPFNode? = null -) { - override fun toString() = - "PackedSPPFNode(pivot=$pivot, rsmState=$rsmState, leftSPPFNode=$leftSPPFNode, rightSPPFNode=$rightSPPFNode)" - - override fun equals(other: Any?): Boolean { - if (this === other) return true - if (other !is PackedSPPFNode) return false - - if (pivot != other.pivot) return false - if (rsmState != other.rsmState) return false - if (leftSPPFNode != other.leftSPPFNode) return false - if (rightSPPFNode != other.rightSPPFNode) return false - - return true - } - - val hashCode: Int = Objects.hash(pivot, rsmState, leftSPPFNode, rightSPPFNode) - override fun hashCode() = hashCode -} diff --git a/src/main/kotlin/org/kotgll/rsm/graphinput/withsppf/sppf/ParentSPPFNode.kt b/src/main/kotlin/org/kotgll/rsm/graphinput/withsppf/sppf/ParentSPPFNode.kt deleted file mode 100644 index fc81e5d24..000000000 --- a/src/main/kotlin/org/kotgll/rsm/graphinput/withsppf/sppf/ParentSPPFNode.kt +++ /dev/null @@ -1,22 +0,0 @@ -package org.kotgll.rsm.graphinput.withsppf.sppf - -import org.kotgll.graph.GraphNode -import java.util.* - -open class ParentSPPFNode(leftExtent: GraphNode, rightExtent: GraphNode) : - SPPFNode(leftExtent, rightExtent) { - val kids: HashSet = HashSet() - - override fun toString() = "ParentSPPFNode(leftExtent=$leftExtent, rightExtent=$rightExtent)" - - override fun equals(other: Any?): Boolean { - if (this === other) return true - if (other !is ParentSPPFNode) return false - if (!super.equals(other)) return false - - return true - } - - override val hashCode: Int = Objects.hash(leftExtent, rightExtent) - override fun hashCode() = hashCode -} diff --git a/src/main/kotlin/org/kotgll/rsm/graphinput/withsppf/sppf/SPPFNode.kt b/src/main/kotlin/org/kotgll/rsm/graphinput/withsppf/sppf/SPPFNode.kt deleted file mode 100644 index fdf62a13d..000000000 --- a/src/main/kotlin/org/kotgll/rsm/graphinput/withsppf/sppf/SPPFNode.kt +++ /dev/null @@ -1,24 +0,0 @@ -package org.kotgll.rsm.graphinput.withsppf.sppf - -import org.kotgll.graph.GraphNode -import org.kotgll.rsm.grammar.symbol.Symbol -import java.util.* - -open class SPPFNode(val leftExtent: GraphNode, val rightExtent: GraphNode) { - override fun toString() = "SPPFNode(leftExtent=$leftExtent, rightExtent=$rightExtent)" - - override fun equals(other: Any?): Boolean { - if (this === other) return true - if (other !is SPPFNode) return false - - if (leftExtent != other.leftExtent) return false - if (rightExtent != other.rightExtent) return false - - return true - } - - open val hashCode: Int = Objects.hash(leftExtent, rightExtent) - override fun hashCode() = hashCode - - open fun hasSymbol(symbol: Symbol) = false -} diff --git a/src/main/kotlin/org/kotgll/rsm/graphinput/withsppf/sppf/SymbolSPPFNode.kt b/src/main/kotlin/org/kotgll/rsm/graphinput/withsppf/sppf/SymbolSPPFNode.kt deleted file mode 100644 index 701ecefec..000000000 --- a/src/main/kotlin/org/kotgll/rsm/graphinput/withsppf/sppf/SymbolSPPFNode.kt +++ /dev/null @@ -1,27 +0,0 @@ -package org.kotgll.rsm.graphinput.withsppf.sppf - -import org.kotgll.graph.GraphNode -import org.kotgll.rsm.grammar.symbol.Nonterminal -import org.kotgll.rsm.grammar.symbol.Symbol -import java.util.* - -class SymbolSPPFNode(leftExtent: GraphNode, rightExtent: GraphNode, val symbol: Nonterminal) : - ParentSPPFNode(leftExtent, rightExtent) { - override fun toString() = - "SymbolSPPFNode(leftExtent=$leftExtent, rightExtent=$rightExtent, symbol=$symbol)" - - override fun equals(other: Any?): Boolean { - if (this === other) return true - if (other !is SymbolSPPFNode) return false - if (!super.equals(other)) return false - - if (symbol != other.symbol) return false - - return true - } - - override val hashCode: Int = Objects.hash(leftExtent, rightExtent, symbol) - override fun hashCode() = hashCode - - override fun hasSymbol(symbol: Symbol) = this.symbol == symbol -} diff --git a/src/main/kotlin/org/kotgll/rsm/graphinput/withsppf/sppf/TerminalSPPFNode.kt b/src/main/kotlin/org/kotgll/rsm/graphinput/withsppf/sppf/TerminalSPPFNode.kt deleted file mode 100644 index c2e19de4d..000000000 --- a/src/main/kotlin/org/kotgll/rsm/graphinput/withsppf/sppf/TerminalSPPFNode.kt +++ /dev/null @@ -1,27 +0,0 @@ -package org.kotgll.rsm.graphinput.withsppf.sppf - -import org.kotgll.graph.GraphNode -import org.kotgll.rsm.grammar.symbol.Terminal -import java.util.* - -class TerminalSPPFNode( - leftExtent: GraphNode, - rightExtent: GraphNode, - val terminal: Terminal, -) : SPPFNode(leftExtent, rightExtent) { - override fun toString() = - "TerminalSPPFNode(leftExtent=$leftExtent, rightExtent=$rightExtent, terminal=$terminal)" - - override fun equals(other: Any?): Boolean { - if (this === other) return true - if (other !is TerminalSPPFNode) return false - if (!super.equals(other)) return false - - if (terminal != other.terminal) return false - - return true - } - - override val hashCode: Int = Objects.hash(leftExtent, rightExtent, terminal) - override fun hashCode() = hashCode -} diff --git a/src/main/kotlin/org/kotgll/rsm/stringinput/withoutsppf/DescriptorsQueue.kt b/src/main/kotlin/org/kotgll/rsm/stringinput/withoutsppf/DescriptorsQueue.kt deleted file mode 100644 index 923126451..000000000 --- a/src/main/kotlin/org/kotgll/rsm/stringinput/withoutsppf/DescriptorsQueue.kt +++ /dev/null @@ -1,36 +0,0 @@ -package org.kotgll.rsm.stringinput.withoutsppf - -import org.kotgll.rsm.grammar.RSMState -import java.util.* -import kotlin.collections.ArrayDeque - -class DescriptorsQueue(size: Int) { - val todo: ArrayDeque = ArrayDeque() - val created: Array> = Array(size) { HashSet() } - - fun add(rsmState: RSMState, gssNode: GSSNode, pos: Int) { - val descriptor = Descriptor(rsmState, gssNode, pos) - if (created[pos].add(descriptor)) todo.addLast(descriptor) - } - - fun next() = todo.removeFirst() - - fun isEmpty() = todo.isEmpty() - - class Descriptor(val rsmState: RSMState, val gssNode: GSSNode, val pos: Int) { - override fun toString() = "Descriptor(rsmState=$rsmState, gssNode=$gssNode, pos=$pos)" - - override fun equals(other: Any?): Boolean { - if (this === other) return true - if (other !is Descriptor) return false - - if (rsmState != other.rsmState) return false - if (gssNode != other.gssNode) return false - - return true - } - - val hashCode: Int = Objects.hash(rsmState, gssNode) - override fun hashCode() = hashCode - } -} diff --git a/src/main/kotlin/org/kotgll/rsm/stringinput/withoutsppf/GLL.kt b/src/main/kotlin/org/kotgll/rsm/stringinput/withoutsppf/GLL.kt deleted file mode 100644 index fc26ff678..000000000 --- a/src/main/kotlin/org/kotgll/rsm/stringinput/withoutsppf/GLL.kt +++ /dev/null @@ -1,80 +0,0 @@ -package org.kotgll.rsm.stringinput.withoutsppf - -import org.kotgll.rsm.grammar.RSMState -import org.kotgll.rsm.grammar.symbol.Nonterminal - -class GLL(val startState: RSMState, val input: String) { - val queue: DescriptorsQueue = DescriptorsQueue(input.length + 1) - val poppedGSSNodes: HashMap> = HashMap() - val createdGSSNodes: HashMap = HashMap() - var parseResult: Boolean = false - - fun getOrCreateGSSNode(nonterminal: Nonterminal, pos: Int): GSSNode { - val gssNode = GSSNode(nonterminal, pos) - if (!createdGSSNodes.containsKey(gssNode)) createdGSSNodes[gssNode] = gssNode - return createdGSSNodes[gssNode]!! - } - - fun parse(): Boolean { - queue.add(startState, getOrCreateGSSNode(startState.nonterminal, 0), 0) - - while (!queue.isEmpty()) { - val descriptor: DescriptorsQueue.Descriptor = queue.next() - parse(descriptor.rsmState, descriptor.gssNode, descriptor.pos) - } - - return parseResult - } - - fun parse(state: RSMState, gssNode: GSSNode, pos: Int) { - for (rsmEdge in state.outgoingTerminalEdges) { - if (pos >= input.length) break - if (rsmEdge.terminal.match(pos, input)) { - queue.add(rsmEdge.head, gssNode, pos + rsmEdge.terminal.size) - } - } - - for (rsmEdge in state.outgoingNonterminalEdges) { - queue.add( - rsmEdge.nonterminal.startState, - createGSSNode(rsmEdge.nonterminal, rsmEdge.head, gssNode, pos), - pos) - } - - if (state.isFinal) pop(gssNode, pos) - } - - fun pop(gssNode: GSSNode, pos: Int) { - if (!parseResult && - gssNode.nonterminal == startState.nonterminal && - gssNode.pos == 0 && - pos == input.length) - parseResult = true - if (!poppedGSSNodes.containsKey(gssNode)) poppedGSSNodes[gssNode] = HashSet() - poppedGSSNodes[gssNode]!!.add(pos) - for (e in gssNode.edges) { - for (u in e.value) { - queue.add(e.key, u, pos) - } - } - } - - fun createGSSNode( - nonterminal: Nonterminal, - state: RSMState, - gssNode: GSSNode, - pos: Int - ): GSSNode { - val v: GSSNode = getOrCreateGSSNode(nonterminal, pos) - - if (v.addEdge(state, gssNode)) { - if (poppedGSSNodes.containsKey(v)) { - for (z in poppedGSSNodes[v]!!) { - queue.add(state, gssNode, z) - } - } - } - - return v - } -} diff --git a/src/main/kotlin/org/kotgll/rsm/stringinput/withoutsppf/GSSNode.kt b/src/main/kotlin/org/kotgll/rsm/stringinput/withoutsppf/GSSNode.kt deleted file mode 100644 index 92de5e69e..000000000 --- a/src/main/kotlin/org/kotgll/rsm/stringinput/withoutsppf/GSSNode.kt +++ /dev/null @@ -1,29 +0,0 @@ -package org.kotgll.rsm.stringinput.withoutsppf - -import org.kotgll.rsm.grammar.RSMState -import org.kotgll.rsm.grammar.symbol.Nonterminal -import java.util.* - -class GSSNode(val nonterminal: Nonterminal, val pos: Int) { - val edges: HashMap> = HashMap() - - fun addEdge(rsmState: RSMState, gssNode: GSSNode): Boolean { - if (!edges.containsKey(rsmState)) edges[rsmState] = HashSet() - return edges[rsmState]!!.add(gssNode) - } - - override fun toString() = "GSSNode(nonterminal=$nonterminal, pos=$pos)" - - override fun equals(other: Any?): Boolean { - if (this === other) return true - if (other !is GSSNode) return false - - if (nonterminal != other.nonterminal) return false - if (pos != other.pos) return false - - return true - } - - val hashCode: Int = Objects.hash(nonterminal, pos) - override fun hashCode() = hashCode -} diff --git a/src/main/kotlin/org/kotgll/rsm/stringinput/withsppf/DescriptorsQueue.kt b/src/main/kotlin/org/kotgll/rsm/stringinput/withsppf/DescriptorsQueue.kt deleted file mode 100644 index b1ddd4011..000000000 --- a/src/main/kotlin/org/kotgll/rsm/stringinput/withsppf/DescriptorsQueue.kt +++ /dev/null @@ -1,44 +0,0 @@ -package org.kotgll.rsm.stringinput.withsppf - -import org.kotgll.rsm.grammar.RSMState -import org.kotgll.rsm.stringinput.withsppf.sppf.SPPFNode -import java.util.* -import kotlin.collections.ArrayDeque - -class DescriptorsQueue(size: Int) { - val todo: ArrayDeque = ArrayDeque() - val created: Array> = Array(size) { HashSet() } - - fun add(rsmState: RSMState, gssNode: GSSNode, sppfNode: SPPFNode?, pos: Int) { - val descriptor = Descriptor(rsmState, gssNode, sppfNode, pos) - if (created[pos].add(descriptor)) todo.addLast(descriptor) - } - - fun next() = todo.removeFirst() - - fun isEmpty() = todo.isEmpty() - - class Descriptor( - val rsmState: RSMState, - val gssNode: GSSNode, - val sppfNode: SPPFNode?, - val pos: Int, - ) { - override fun toString() = - "Descriptor(rsmState=$rsmState, gssNode=$gssNode, sppfNode=$sppfNode, pos=$pos)" - - override fun equals(other: Any?): Boolean { - if (this === other) return true - if (other !is Descriptor) return false - - if (rsmState != other.rsmState) return false - if (gssNode != other.gssNode) return false - if (sppfNode != other.sppfNode) return false - - return true - } - - val hashCode: Int = Objects.hash(rsmState, gssNode, sppfNode) - override fun hashCode() = hashCode - } -} diff --git a/src/main/kotlin/org/kotgll/rsm/stringinput/withsppf/GLL.kt b/src/main/kotlin/org/kotgll/rsm/stringinput/withsppf/GLL.kt deleted file mode 100644 index 39c39f1da..000000000 --- a/src/main/kotlin/org/kotgll/rsm/stringinput/withsppf/GLL.kt +++ /dev/null @@ -1,132 +0,0 @@ -package org.kotgll.rsm.stringinput.withsppf - -import org.kotgll.rsm.grammar.RSMState -import org.kotgll.rsm.grammar.symbol.Nonterminal -import org.kotgll.rsm.grammar.symbol.Terminal -import org.kotgll.rsm.stringinput.withsppf.sppf.* - -class GLL(val startState: RSMState, val input: String) { - val queue: DescriptorsQueue = DescriptorsQueue(input.length + 1) - val poppedGSSNodes: HashMap> = HashMap() - val createdGSSNodes: HashMap = HashMap() - val createdSPPFNodes: HashMap = HashMap() - var parseResult: SPPFNode? = null - - fun getOrCreateGSSNode(nonterminal: Nonterminal, pos: Int): GSSNode { - val gssNode = GSSNode(nonterminal, pos) - if (!createdGSSNodes.containsKey(gssNode)) createdGSSNodes[gssNode] = gssNode - return createdGSSNodes[gssNode]!! - } - - fun parse(): SPPFNode? { - queue.add(startState, getOrCreateGSSNode(startState.nonterminal, 0), null, 0) - - while (!queue.isEmpty()) { - val descriptor: DescriptorsQueue.Descriptor = queue.next() - parse(descriptor.rsmState, descriptor.gssNode, descriptor.sppfNode, descriptor.pos) - } - - return parseResult - } - - fun parse(state: RSMState, gssNode: GSSNode, sppfNode: SPPFNode?, pos: Int) { - var curSPPFNode: SPPFNode? = sppfNode - - if (state.isStart && state.isFinal) - curSPPFNode = getNodeP(state, curSPPFNode, getOrCreateItemSPPFNode(state, pos, pos)) - - for (rsmEdge in state.outgoingTerminalEdges) { - if (pos >= input.length) break - if (rsmEdge.terminal.match(pos, input)) { - val nextSPPFNode: SPPFNode = - getOrCreateTerminalSPPFNode(rsmEdge.terminal, pos, rsmEdge.terminal.size) - queue.add( - rsmEdge.head, - gssNode, - getNodeP(rsmEdge.head, curSPPFNode, nextSPPFNode), - pos + rsmEdge.terminal.size) - } - } - - for (rsmEdge in state.outgoingNonterminalEdges) { - queue.add( - rsmEdge.nonterminal.startState, - createGSSNode(rsmEdge.nonterminal, rsmEdge.head, gssNode, curSPPFNode, pos), - null, - pos) - } - - if (state.isFinal) pop(gssNode, curSPPFNode, pos) - } - - fun pop(gssNode: GSSNode, sppfNode: SPPFNode?, pos: Int) { - if (!poppedGSSNodes.containsKey(gssNode)) poppedGSSNodes[gssNode] = HashSet() - poppedGSSNodes[gssNode]!!.add(sppfNode) - for (e in gssNode.edges) { - for (u in e.value) { - queue.add(e.key.first, u, getNodeP(e.key.first, e.key.second, sppfNode!!), pos) - } - } - } - - fun createGSSNode( - nonterminal: Nonterminal, - state: RSMState, - gssNode: GSSNode, - sppfNode: SPPFNode?, - pos: Int - ): GSSNode { - val v: GSSNode = getOrCreateGSSNode(nonterminal, pos) - - if (v.addEdge(state, sppfNode, gssNode)) { - if (poppedGSSNodes.containsKey(v)) { - for (z in poppedGSSNodes[v]!!) { - queue.add(state, gssNode, getNodeP(state, sppfNode, z!!), z.rightExtent) - } - } - } - - return v - } - - fun getNodeP(state: RSMState, sppfNode: SPPFNode?, nextSPPFNode: SPPFNode): SPPFNode { - val leftExtent = sppfNode?.leftExtent ?: nextSPPFNode.leftExtent - val rightExtent = nextSPPFNode.rightExtent - - val y = - if (state.isFinal) getOrCreateSymbolSPPFNode(state.nonterminal, leftExtent, rightExtent) - else getOrCreateItemSPPFNode(state, leftExtent, rightExtent) - - y.kids.add(PackedSPPFNode(nextSPPFNode.leftExtent, state, sppfNode, nextSPPFNode)) - - return y - } - - fun getOrCreateTerminalSPPFNode(terminal: Terminal, leftExtent: Int, rightExtent: Int): SPPFNode { - val y = TerminalSPPFNode(leftExtent, leftExtent + rightExtent, terminal) - if (!createdSPPFNodes.containsKey(y)) createdSPPFNodes[y] = y - return createdSPPFNodes[y]!! - } - - fun getOrCreateItemSPPFNode(state: RSMState, leftExtent: Int, rightExtent: Int): ItemSPPFNode { - val y = ItemSPPFNode(leftExtent, rightExtent, state) - if (!createdSPPFNodes.containsKey(y)) createdSPPFNodes[y] = y - return createdSPPFNodes[y]!! as ItemSPPFNode - } - - fun getOrCreateSymbolSPPFNode( - nonterminal: Nonterminal, - leftExtent: Int, - rightExtent: Int - ): SymbolSPPFNode { - val y = SymbolSPPFNode(leftExtent, rightExtent, nonterminal) - if (!createdSPPFNodes.containsKey(y)) createdSPPFNodes[y] = y - val result = createdSPPFNodes[y]!! as SymbolSPPFNode - if (parseResult == null && - nonterminal == startState.nonterminal && - leftExtent == 0 && - rightExtent == input.length) - parseResult = result - return result - } -} diff --git a/src/main/kotlin/org/kotgll/rsm/stringinput/withsppf/GSSNode.kt b/src/main/kotlin/org/kotgll/rsm/stringinput/withsppf/GSSNode.kt deleted file mode 100644 index df9bc67cc..000000000 --- a/src/main/kotlin/org/kotgll/rsm/stringinput/withsppf/GSSNode.kt +++ /dev/null @@ -1,31 +0,0 @@ -package org.kotgll.rsm.stringinput.withsppf - -import org.kotgll.rsm.grammar.RSMState -import org.kotgll.rsm.grammar.symbol.Nonterminal -import org.kotgll.rsm.stringinput.withsppf.sppf.SPPFNode -import java.util.* - -class GSSNode(val nonterminal: Nonterminal, val pos: Int) { - val edges: HashMap, HashSet> = HashMap() - - fun addEdge(rsmState: RSMState, sppfNode: SPPFNode?, gssNode: GSSNode): Boolean { - val label = Pair(rsmState, sppfNode) - if (!edges.containsKey(label)) edges[label] = HashSet() - return edges[label]!!.add(gssNode) - } - - override fun toString() = "GSSNode(nonterminal=$nonterminal, pos=$pos)" - - override fun equals(other: Any?): Boolean { - if (this === other) return true - if (other !is GSSNode) return false - - if (nonterminal != other.nonterminal) return false - if (pos != other.pos) return false - - return true - } - - val hashCode: Int = Objects.hash(nonterminal, pos) - override fun hashCode() = hashCode -} diff --git a/src/main/kotlin/org/kotgll/rsm/stringinput/withsppf/sppf/ItemSPPFNode.kt b/src/main/kotlin/org/kotgll/rsm/stringinput/withsppf/sppf/ItemSPPFNode.kt deleted file mode 100644 index c3076bf2e..000000000 --- a/src/main/kotlin/org/kotgll/rsm/stringinput/withsppf/sppf/ItemSPPFNode.kt +++ /dev/null @@ -1,23 +0,0 @@ -package org.kotgll.rsm.stringinput.withsppf.sppf - -import org.kotgll.rsm.grammar.RSMState -import java.util.* - -class ItemSPPFNode(leftExtent: Int, rightExtent: Int, val rsmState: RSMState) : - ParentSPPFNode(leftExtent, rightExtent) { - override fun toString() = - "ItemSPPFNode(leftExtent=$leftExtent, rightExtent=$rightExtent, rsmState=$rsmState)" - - override fun equals(other: Any?): Boolean { - if (this === other) return true - if (other !is ItemSPPFNode) return false - if (!super.equals(other)) return false - - if (rsmState != other.rsmState) return false - - return true - } - - override val hashCode: Int = Objects.hash(leftExtent, rightExtent, rsmState) - override fun hashCode() = hashCode -} diff --git a/src/main/kotlin/org/kotgll/rsm/stringinput/withsppf/sppf/PackedSPPFNode.kt b/src/main/kotlin/org/kotgll/rsm/stringinput/withsppf/sppf/PackedSPPFNode.kt deleted file mode 100644 index 6539b25e0..000000000 --- a/src/main/kotlin/org/kotgll/rsm/stringinput/withsppf/sppf/PackedSPPFNode.kt +++ /dev/null @@ -1,29 +0,0 @@ -package org.kotgll.rsm.stringinput.withsppf.sppf - -import org.kotgll.rsm.grammar.RSMState -import java.util.* - -open class PackedSPPFNode( - val pivot: Int, - val rsmState: RSMState, - val leftSPPFNode: SPPFNode? = null, - val rightSPPFNode: SPPFNode? = null -) { - override fun toString() = - "PackedSPPFNode(pivot=$pivot, rsmState=$rsmState, leftSPPFNode=$leftSPPFNode, rightSPPFNode=$rightSPPFNode)" - - override fun equals(other: Any?): Boolean { - if (this === other) return true - if (other !is PackedSPPFNode) return false - - if (pivot != other.pivot) return false - if (rsmState != other.rsmState) return false - if (leftSPPFNode != other.leftSPPFNode) return false - if (rightSPPFNode != other.rightSPPFNode) return false - - return true - } - - val hashCode: Int = Objects.hash(pivot, rsmState, leftSPPFNode, rightSPPFNode) - override fun hashCode() = hashCode -} diff --git a/src/main/kotlin/org/kotgll/rsm/stringinput/withsppf/sppf/ParentSPPFNode.kt b/src/main/kotlin/org/kotgll/rsm/stringinput/withsppf/sppf/ParentSPPFNode.kt deleted file mode 100644 index 05f6fc692..000000000 --- a/src/main/kotlin/org/kotgll/rsm/stringinput/withsppf/sppf/ParentSPPFNode.kt +++ /dev/null @@ -1,20 +0,0 @@ -package org.kotgll.rsm.stringinput.withsppf.sppf - -import java.util.* - -open class ParentSPPFNode(leftExtent: Int, rightExtent: Int) : SPPFNode(leftExtent, rightExtent) { - val kids: HashSet = HashSet() - - override fun toString() = "ParentSPPFNode(leftExtent=$leftExtent, rightExtent=$rightExtent)" - - override fun equals(other: Any?): Boolean { - if (this === other) return true - if (other !is ParentSPPFNode) return false - if (!super.equals(other)) return false - - return true - } - - override val hashCode: Int = Objects.hash(leftExtent, rightExtent) - override fun hashCode() = hashCode -} diff --git a/src/main/kotlin/org/kotgll/rsm/stringinput/withsppf/sppf/SPPFNode.kt b/src/main/kotlin/org/kotgll/rsm/stringinput/withsppf/sppf/SPPFNode.kt deleted file mode 100644 index 9399fdc0b..000000000 --- a/src/main/kotlin/org/kotgll/rsm/stringinput/withsppf/sppf/SPPFNode.kt +++ /dev/null @@ -1,23 +0,0 @@ -package org.kotgll.rsm.stringinput.withsppf.sppf - -import org.kotgll.rsm.grammar.symbol.Symbol -import java.util.* - -open class SPPFNode(val leftExtent: Int, val rightExtent: Int) { - override fun toString() = "SPPFNode(leftExtent=$leftExtent, rightExtent=$rightExtent)" - - override fun equals(other: Any?): Boolean { - if (this === other) return true - if (other !is SPPFNode) return false - - if (leftExtent != other.leftExtent) return false - if (rightExtent != other.rightExtent) return false - - return true - } - - open val hashCode: Int = Objects.hash(leftExtent, rightExtent) - override fun hashCode() = hashCode - - open fun hasSymbol(symbol: Symbol) = false -} diff --git a/src/main/kotlin/org/kotgll/rsm/stringinput/withsppf/sppf/SymbolSPPFNode.kt b/src/main/kotlin/org/kotgll/rsm/stringinput/withsppf/sppf/SymbolSPPFNode.kt deleted file mode 100644 index 8ac6e8cb9..000000000 --- a/src/main/kotlin/org/kotgll/rsm/stringinput/withsppf/sppf/SymbolSPPFNode.kt +++ /dev/null @@ -1,26 +0,0 @@ -package org.kotgll.rsm.stringinput.withsppf.sppf - -import org.kotgll.rsm.grammar.symbol.Nonterminal -import org.kotgll.rsm.grammar.symbol.Symbol -import java.util.* - -class SymbolSPPFNode(leftExtent: Int, rightExtent: Int, val symbol: Nonterminal) : - ParentSPPFNode(leftExtent, rightExtent) { - override fun toString() = - "SymbolSPPFNode(leftExtent=$leftExtent, rightExtent=$rightExtent, symbol=$symbol)" - - override fun equals(other: Any?): Boolean { - if (this === other) return true - if (other !is SymbolSPPFNode) return false - if (!super.equals(other)) return false - - if (symbol != other.symbol) return false - - return true - } - - override val hashCode: Int = Objects.hash(leftExtent, rightExtent, symbol) - override fun hashCode() = hashCode - - override fun hasSymbol(symbol: Symbol) = this.symbol == symbol -} diff --git a/src/main/kotlin/org/kotgll/rsm/stringinput/withsppf/sppf/TerminalSPPFNode.kt b/src/main/kotlin/org/kotgll/rsm/stringinput/withsppf/sppf/TerminalSPPFNode.kt deleted file mode 100644 index 424733d01..000000000 --- a/src/main/kotlin/org/kotgll/rsm/stringinput/withsppf/sppf/TerminalSPPFNode.kt +++ /dev/null @@ -1,23 +0,0 @@ -package org.kotgll.rsm.stringinput.withsppf.sppf - -import org.kotgll.rsm.grammar.symbol.Terminal -import java.util.* - -class TerminalSPPFNode(leftExtent: Int, rightExtent: Int, val terminal: Terminal) : - SPPFNode(leftExtent, rightExtent) { - override fun toString() = - "TerminalSPPFNode(leftExtent=$leftExtent, rightExtent=$rightExtent, terminal=$terminal)" - - override fun equals(other: Any?): Boolean { - if (this === other) return true - if (other !is TerminalSPPFNode) return false - if (!super.equals(other)) return false - - if (terminal != other.terminal) return false - - return true - } - - override val hashCode: Int = Objects.hash(leftExtent, rightExtent, terminal) - override fun hashCode() = hashCode -} diff --git a/src/test/kotlin/cfg/graphinput/withoutsppf/TestCFGGraphInputWithoutSPPFFail.kt b/src/test/kotlin/cfg/graphinput/withoutsppf/TestCFGGraphInputWithoutSPPFFail.kt deleted file mode 100644 index ad3b2b9cc..000000000 --- a/src/test/kotlin/cfg/graphinput/withoutsppf/TestCFGGraphInputWithoutSPPFFail.kt +++ /dev/null @@ -1,360 +0,0 @@ -package cfg.graphinput.withoutsppf - -import org.junit.jupiter.api.Test -import org.junit.jupiter.params.ParameterizedTest -import org.junit.jupiter.params.provider.ValueSource -import org.kotgll.cfg.grammar.Alternative -import org.kotgll.cfg.grammar.symbol.* -import org.kotgll.cfg.graphinput.withoutsppf.GLL -import org.kotgll.graph.GraphNode -import org.kotgll.graph.readGraphFromString -import kotlin.test.assertEquals - -class TestCFGGraphInputWithoutSPPFFail { - @Test - fun `test 'empty' hand-crafted grammar`() { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative(Alternative(listOf())) - - val graph = GraphNode(id = 0) - - assertEquals( - expected = hashMapOf(), - actual = GLL(nonterminalS, listOf(graph)).parse(), - ) - } - - @ParameterizedTest(name = "Should be Empty for {0}") - @ValueSource(strings = ["", "b", "bb", "ab", "aa"]) - fun `test 'a' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative(Alternative(listOf(Terminal("a")))) - - assertEquals( - expected = hashMapOf(), - actual = GLL(nonterminalS, listOf(readGraphFromString(input))).parse(), - ) - } - - @ParameterizedTest(name = "Should be Empty for {0}") - @ValueSource(strings = ["", "a", "b", "aba", "ababa", "aa", "b", "bb", "c", "cc"]) - fun `test 'ab' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative(Alternative(listOf(Terminal("a"), Terminal("b")))) - - assertEquals( - expected = hashMapOf(), - actual = GLL(nonterminalS, listOf(readGraphFromString(input))).parse(), - ) - } - - @ParameterizedTest(name = "Should be Empty for {0}") - @ValueSource(strings = ["b", "bb", "c", "cc", "ab", "ac"]) - fun `test 'a-star' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative(Alternative(listOf(Star(Terminal("a"))))) - - assertEquals( - expected = hashMapOf(), - actual = GLL(nonterminalS, listOf(readGraphFromString(input))).parse(), - ) - } - - @ParameterizedTest(name = "Should be Empty for {0}") - @ValueSource(strings = ["", "b", "bb", "c", "cc", "ab", "ac"]) - fun `test 'a-plus' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative(Alternative(listOf(Plus(Terminal("a"))))) - - assertEquals( - expected = hashMapOf(), - actual = GLL(nonterminalS, listOf(readGraphFromString(input))).parse(), - ) - } - - @ParameterizedTest(name = "Should be Empty for {0}") - @ValueSource( - strings = - [ - "abaa", - "abba", - "abca", - "ababaa", - "ababba", - "ababca", - "abbb", - "abcb", - "ababbb", - "ababcb", - "abac", - "abbc", - "abcc", - "ababac", - "ababbc", - "ababcc", - ]) - fun `test '(ab)-star' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative(Alternative(listOf(Star(Terminal("ab"))))) - - val graph = GraphNode(id = 0, isStart = true) - var cur = graph - var i = 0 - while (i < input.length) { - val head = GraphNode(id = i + 1) - cur.addEdge("" + input[i] + input[i + 1], head) - cur = head - i += 2 - } - cur.isFinal = true - - assertEquals( - expected = hashMapOf(), - actual = GLL(nonterminalS, listOf(graph)).parse(), - ) - } - - @ParameterizedTest(name = "Should be Empty for {0}") - @ValueSource( - strings = - [ - "(", - ")", - "((", - "))", - "()(", - "()()(", - "()()()(", - "())", - "()())", - "()()())", - "(())(", - "(())()(", - "(())()()(", - "(()))", - "(())())", - "(())()())", - "(())(())(", - "(())(())()(", - "(())(())()()(", - "(())(()))", - "(())(())())", - "(())(())()())", - "(()())(()())(", - "(()())(()()))", - ]) - fun `test 'dyck' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative(Alternative(listOf())) - nonterminalS.addAlternative( - Alternative(listOf(Terminal("("), nonterminalS, Terminal(")"), nonterminalS))) - - assertEquals( - expected = hashMapOf(), - actual = GLL(nonterminalS, listOf(readGraphFromString(input))).parse(), - ) - } - - @ParameterizedTest(name = "Should be Empty for {0}") - @ValueSource( - strings = - [ - "", - "a", - "b", - "c", - "d", - "aa", - "ac", - "ad", - "ba", - "bb", - "bc", - "bd", - "ca", - "cb", - "cc", - "da", - "db", - "dc", - "dd", - ]) - fun `test 'ab or cd' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative(Alternative(listOf(Terminal("ab")))) - nonterminalS.addAlternative(Alternative(listOf(Terminal("cd")))) - - val graph = GraphNode(id = 0, isStart = true) - graph.addEdge(input, GraphNode(id = 1, isFinal = true)) - - assertEquals( - expected = hashMapOf(), - actual = GLL(nonterminalS, listOf(graph)).parse(), - ) - } - - @ParameterizedTest(name = "Should be Empty for {0}") - @ValueSource(strings = ["b", "bb", "ab"]) - fun `test 'a-optional' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative(Alternative(listOf(Optional(Terminal("a"))))) - - assertEquals( - expected = hashMapOf(), - actual = GLL(nonterminalS, listOf(readGraphFromString(input))).parse(), - ) - } - - @ParameterizedTest(name = "Should be Empty for {0}") - @ValueSource(strings = ["", "a", "b", "c", "ab", "ac", "abb", "bc", "abcd"]) - fun `test 'abc' ambiguous hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - val nonterminalA = Nonterminal("A") - val nonterminalB = Nonterminal("B") - - nonterminalS.addAlternative(Alternative(listOf(nonterminalA, Terminal("c")))) - nonterminalS.addAlternative(Alternative(listOf(Terminal("a"), nonterminalB, Terminal("c")))) - nonterminalA.addAlternative(Alternative(listOf(Terminal("a"), Terminal("b")))) - nonterminalB.addAlternative(Alternative(listOf(Terminal("b")))) - - assertEquals( - expected = hashMapOf(), - actual = GLL(nonterminalS, listOf(readGraphFromString(input))).parse(), - ) - } - - @ParameterizedTest(name = "Should be Empty for {0}") - @ValueSource( - strings = - [ - "", - "a", - "b", - "c", - "d", - "aa", - "ac", - "ad", - "ba", - "bb", - "bc", - "bd", - "ca", - "cb", - "cc", - "da", - "db", - "dc", - "dd", - ]) - fun `test 'ab or cd' ambiguous hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - val nonterminalA = Nonterminal("A") - val nonterminalB = Nonterminal("B") - nonterminalS.addAlternative(Alternative(listOf(nonterminalA))) - nonterminalS.addAlternative(Alternative(listOf(nonterminalB))) - - nonterminalA.addAlternative(Alternative(listOf(Terminal("ab")))) - nonterminalA.addAlternative(Alternative(listOf(Terminal("cd")))) - - nonterminalB.addAlternative(Alternative(listOf(Terminal("ab")))) - nonterminalB.addAlternative(Alternative(listOf(Terminal("cd")))) - - val graph = GraphNode(id = 0, isStart = true) - graph.addEdge(input, GraphNode(id = 1, isFinal = true)) - - assertEquals( - expected = hashMapOf(), - actual = GLL(nonterminalS, listOf(graph)).parse(), - ) - } - - @Test - fun `test 'dyck' hand-crafted grammar two cycle graph`() { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative(Alternative(listOf())) - nonterminalS.addAlternative( - Alternative(listOf(Terminal("("), nonterminalS, Terminal(")"), nonterminalS))) - - val graphNode0 = GraphNode(id = 0, isStart = true, isFinal = true) - val graphNode1 = GraphNode(id = 1, isStart = true, isFinal = true) - val graphNode2 = GraphNode(id = 2, isStart = true, isFinal = true) - val graphNode3 = GraphNode(id = 3, isStart = true) - - graphNode0.addEdge("(", graphNode1) - graphNode1.addEdge("(", graphNode2) - graphNode2.addEdge("(", graphNode0) - - graphNode2.addEdge(")", graphNode3) - graphNode3.addEdge(")", graphNode2) - - assertEquals( - expected = hashMapOf(), - actual = GLL(nonterminalS, listOf(graphNode3)).parse(), - ) - } - - @Test - fun `test 'a-plus' hand-crafted grammar one cycle graph`() { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative(Alternative(listOf(Terminal("a")))) - nonterminalS.addAlternative(Alternative(listOf(Terminal("a"), nonterminalS))) - - val graphNode0 = GraphNode(id = 0, isStart = true, isFinal = true) - val graphNode1 = GraphNode(id = 1, isStart = true) - - graphNode0.addEdge("a", graphNode1) - graphNode1.addEdge("a", graphNode1) - - assertEquals( - expected = hashMapOf(), - actual = GLL(nonterminalS, listOf(graphNode0)).parse(), - ) - } - - @Test - fun `test 'a-star' hand-crafted grammar one cycle graph`() { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative(Alternative(listOf(Terminal("a"), nonterminalS))) - nonterminalS.addAlternative(Alternative(listOf())) - - val graphNode0 = GraphNode(id = 0, isStart = true) - val graphNode1 = GraphNode(id = 1, isStart = true) - - graphNode0.addEdge("a", graphNode1) - graphNode1.addEdge("a", graphNode1) - - assertEquals( - expected = hashMapOf(), - actual = GLL(nonterminalS, listOf(graphNode0, graphNode1)).parse(), - ) - } - - @Test - fun `test 'g1' hand-crafted grammar two cycle graph`() { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative( - Alternative(listOf(Terminal("subClassOf_r"), nonterminalS, Terminal("subClassOf")))) - nonterminalS.addAlternative( - Alternative(listOf(Terminal("subClassOf_r"), Terminal("subClassOf")))) - nonterminalS.addAlternative( - Alternative(listOf(Terminal("type_r"), nonterminalS, Terminal("type")))) - nonterminalS.addAlternative(Alternative(listOf(Terminal("type_r"), Terminal("type")))) - - val graphNode0 = GraphNode(id = 0, isStart = true, isFinal = true) - val graphNode1 = GraphNode(id = 1, isStart = true, isFinal = true) - val graphNode2 = GraphNode(id = 2) - val graphNode3 = GraphNode(id = 3) - - graphNode0.addEdge("subClassOf_r", graphNode1) - graphNode1.addEdge("subClassOf_r", graphNode2) - graphNode2.addEdge("subClassOf_r", graphNode0) - - graphNode2.addEdge("subClassOf", graphNode3) - graphNode3.addEdge("subClassOf", graphNode2) - - assertEquals( - expected = hashMapOf(), - actual = GLL(nonterminalS, listOf(graphNode0, graphNode1, graphNode2, graphNode3)).parse()) - } -} diff --git a/src/test/kotlin/cfg/graphinput/withoutsppf/TestCFGGraphInputWithoutSPPFSuccess.kt b/src/test/kotlin/cfg/graphinput/withoutsppf/TestCFGGraphInputWithoutSPPFSuccess.kt deleted file mode 100644 index 37cc76bef..000000000 --- a/src/test/kotlin/cfg/graphinput/withoutsppf/TestCFGGraphInputWithoutSPPFSuccess.kt +++ /dev/null @@ -1,302 +0,0 @@ -package cfg.graphinput.withoutsppf - -import org.junit.jupiter.api.Test -import org.junit.jupiter.params.ParameterizedTest -import org.junit.jupiter.params.provider.ValueSource -import org.kotgll.cfg.grammar.Alternative -import org.kotgll.cfg.grammar.symbol.* -import org.kotgll.cfg.graphinput.withoutsppf.GLL -import org.kotgll.graph.GraphNode -import org.kotgll.graph.readGraphFromString -import kotlin.test.assertEquals - -class TestCFGGraphInputWithoutSPPFSuccess { - @Test - fun `test 'empty' hand-crafted grammar`() { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative(Alternative(listOf())) - - val graph = GraphNode(id = 0, isStart = true, isFinal = true) - - assertEquals( - expected = hashMapOf(0 to hashSetOf(0)), - actual = GLL(nonterminalS, listOf(graph)).parse(), - ) - } - - @Test - fun `test 'a' hand-crafted grammar`() { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative(Alternative(listOf(Terminal("a")))) - - assertEquals( - expected = hashMapOf(0 to hashSetOf(1)), - actual = GLL(nonterminalS, listOf(readGraphFromString("a"))).parse(), - ) - } - - @Test - fun `test 'ab' hand-crafted grammar`() { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative(Alternative(listOf(Terminal("a"), Terminal("b")))) - - assertEquals( - expected = hashMapOf(0 to hashSetOf(2)), - actual = GLL(nonterminalS, listOf(readGraphFromString("ab"))).parse(), - ) - } - - @ParameterizedTest(name = "Should be NotEmpty for {0}") - @ValueSource(strings = ["", "a", "aa", "aaa", "aaaa"]) - fun `test 'a-star' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative(Alternative(listOf(Star(Terminal("a"))))) - - assertEquals( - expected = hashMapOf(0 to hashSetOf(input.length)), - actual = GLL(nonterminalS, listOf(readGraphFromString(input))).parse(), - ) - } - - @ParameterizedTest(name = "Should be NotEmpty for {0}") - @ValueSource(strings = ["a", "aa", "aaa"]) - fun `test 'a-plus' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative(Alternative(listOf(Plus(Terminal("a"))))) - - assertEquals( - expected = hashMapOf(0 to hashSetOf(input.length)), - actual = GLL(nonterminalS, listOf(readGraphFromString(input))).parse(), - ) - } - - @ParameterizedTest(name = "Should be NotEmpty for {0}") - @ValueSource(strings = ["", "ab", "abab", "ababab"]) - fun `test '(ab)-star' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative(Alternative(listOf(Star(Terminal("ab"))))) - - val graph = GraphNode(id = 0, isStart = true) - var cur = graph - var i = 0 - while (i < input.length) { - val head = GraphNode(id = i + 1) - cur.addEdge("" + input[i] + input[i + 1], head) - cur = head - i += 2 - } - cur.isFinal = true - - assertEquals( - expected = hashMapOf(0 to hashSetOf(cur.id)), - actual = GLL(nonterminalS, listOf(graph)).parse(), - ) - } - - @ParameterizedTest(name = "Should be NotEmpty for {0}") - @ValueSource( - strings = - [ - "", - "()", - "()()", - "()()()", - "(())", - "(())()", - "(())()()", - "(())(())", - "(())(())()", - "(())(())()()", - "(()())(()())", - "((()))", - "(((())))", - "((((()))))", - ]) - fun `test 'dyck' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative(Alternative(listOf())) - nonterminalS.addAlternative( - Alternative(listOf(Terminal("("), nonterminalS, Terminal(")"), nonterminalS))) - - assertEquals( - expected = hashMapOf(0 to hashSetOf(input.length)), - actual = GLL(nonterminalS, listOf(readGraphFromString(input))).parse(), - ) - } - - @ParameterizedTest(name = "Should be NotEmpty for {0}") - @ValueSource(strings = ["ab", "cd"]) - fun `test 'ab or cd' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative(Alternative(listOf(Terminal("ab")))) - nonterminalS.addAlternative(Alternative(listOf(Terminal("cd")))) - - val graph = GraphNode(id = 0, isStart = true) - graph.addEdge(input, GraphNode(id = 1, isFinal = true)) - - assertEquals( - expected = hashMapOf(0 to hashSetOf(1)), - actual = GLL(nonterminalS, listOf(graph)).parse(), - ) - } - - @ParameterizedTest(name = "Should be NotEmpty for {0}") - @ValueSource(strings = ["", "a"]) - fun `test 'a-optional' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative(Alternative(listOf(Optional(Terminal("a"))))) - - assertEquals( - expected = hashMapOf(0 to hashSetOf(input.length)), - actual = GLL(nonterminalS, listOf(readGraphFromString(input))).parse(), - ) - } - - @ParameterizedTest(name = "Should be NotEmpty for {0}") - @ValueSource(strings = ["abc"]) - fun `test 'abc' ambiguous hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - val nonterminalA = Nonterminal("A") - val nonterminalB = Nonterminal("B") - - nonterminalS.addAlternative(Alternative(listOf(nonterminalA, Terminal("c")))) - nonterminalS.addAlternative(Alternative(listOf(Terminal("a"), nonterminalB, Terminal("c")))) - nonterminalA.addAlternative(Alternative(listOf(Terminal("a"), Terminal("b")))) - nonterminalB.addAlternative(Alternative(listOf(Terminal("b")))) - - assertEquals( - expected = hashMapOf(0 to hashSetOf(input.length)), - actual = GLL(nonterminalS, listOf(readGraphFromString(input))).parse(), - ) - } - - @ParameterizedTest(name = "Should be NotEmpty for {0}") - @ValueSource(strings = ["ab", "cd"]) - fun `test 'ab or cd' ambiguous hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - val nonterminalA = Nonterminal("A") - val nonterminalB = Nonterminal("B") - nonterminalS.addAlternative(Alternative(listOf(nonterminalA))) - nonterminalS.addAlternative(Alternative(listOf(nonterminalB))) - - nonterminalA.addAlternative(Alternative(listOf(Terminal("ab")))) - nonterminalA.addAlternative(Alternative(listOf(Terminal("cd")))) - - nonterminalB.addAlternative(Alternative(listOf(Terminal("ab")))) - nonterminalB.addAlternative(Alternative(listOf(Terminal("cd")))) - - val graph = GraphNode(id = 0, isStart = true) - graph.addEdge(input, GraphNode(id = 1, isFinal = true)) - - assertEquals( - expected = hashMapOf(0 to hashSetOf(1)), - actual = GLL(nonterminalS, listOf(graph)).parse(), - ) - } - - @Test - fun `test 'dyck' hand-crafted grammar two cycle graph`() { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative(Alternative(listOf(Terminal("("), nonterminalS, Terminal(")")))) - nonterminalS.addAlternative(Alternative(listOf())) - - val graphNode0 = GraphNode(id = 0, isStart = true, isFinal = true) - val graphNode1 = GraphNode(id = 1, isStart = true, isFinal = true) - val graphNode2 = GraphNode(id = 2, isStart = true, isFinal = true) - val graphNode3 = GraphNode(id = 3, isStart = true, isFinal = true) - - graphNode0.addEdge("(", graphNode1) - graphNode1.addEdge("(", graphNode2) - graphNode2.addEdge("(", graphNode0) - - graphNode2.addEdge(")", graphNode3) - graphNode3.addEdge(")", graphNode2) - - assertEquals( - expected = - hashMapOf( - 0 to hashSetOf(0, 2, 3), - 1 to hashSetOf(1, 2, 3), - 2 to hashSetOf(2, 3), - 3 to hashSetOf(3)), - actual = GLL(nonterminalS, listOf(graphNode0, graphNode1, graphNode2, graphNode3)).parse()) - } - - @Test - fun `test 'a-plus' hand-crafted grammar one cycle graph`() { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative(Alternative(listOf(Terminal("a")))) - nonterminalS.addAlternative(Alternative(listOf(Terminal("a"), nonterminalS))) - - val graphNode0 = GraphNode(id = 0, isStart = true, isFinal = true) - val graphNode1 = GraphNode(id = 1, isStart = true, isFinal = true) - - graphNode0.addEdge("a", graphNode1) - graphNode1.addEdge("a", graphNode1) - - assertEquals( - expected = - hashMapOf( - 0 to hashSetOf(1), - 1 to hashSetOf(1), - ), - actual = GLL(nonterminalS, listOf(graphNode0, graphNode1)).parse(), - ) - } - - @Test - fun `test 'a-star' hand-crafted grammar one cycle graph`() { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative(Alternative(listOf(Terminal("a"), nonterminalS))) - nonterminalS.addAlternative(Alternative(listOf())) - - val graphNode0 = GraphNode(id = 0, isStart = true, isFinal = true) - val graphNode1 = GraphNode(id = 1, isStart = true, isFinal = true) - - graphNode0.addEdge("a", graphNode1) - graphNode1.addEdge("a", graphNode1) - - assertEquals( - expected = - hashMapOf( - 0 to hashSetOf(0, 1), - 1 to hashSetOf(1), - ), - actual = GLL(nonterminalS, listOf(graphNode0, graphNode1)).parse(), - ) - } - - @Test - fun `test 'g1' hand-crafted grammar two cycle graph`() { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative( - Alternative(listOf(Terminal("subClassOf_r"), nonterminalS, Terminal("subClassOf")))) - nonterminalS.addAlternative( - Alternative(listOf(Terminal("subClassOf_r"), Terminal("subClassOf")))) - nonterminalS.addAlternative( - Alternative(listOf(Terminal("type_r"), nonterminalS, Terminal("type")))) - nonterminalS.addAlternative(Alternative(listOf(Terminal("type_r"), Terminal("type")))) - - val graphNode0 = GraphNode(id = 0, isStart = true, isFinal = true) - val graphNode1 = GraphNode(id = 1, isStart = true, isFinal = true) - val graphNode2 = GraphNode(id = 2, isStart = true, isFinal = true) - val graphNode3 = GraphNode(id = 3, isStart = true, isFinal = true) - - graphNode0.addEdge("subClassOf_r", graphNode1) - graphNode1.addEdge("subClassOf_r", graphNode2) - graphNode2.addEdge("subClassOf_r", graphNode0) - - graphNode2.addEdge("subClassOf", graphNode3) - graphNode3.addEdge("subClassOf", graphNode2) - - assertEquals( - expected = - hashMapOf( - 0 to hashSetOf(2, 3), - 1 to hashSetOf(2, 3), - 2 to hashSetOf(2, 3), - ), - actual = GLL(nonterminalS, listOf(graphNode0, graphNode1, graphNode2, graphNode3)).parse(), - ) - } -} diff --git a/src/test/kotlin/cfg/graphinput/withsppf/TestCFGGraphInputWithSPPFFail.kt b/src/test/kotlin/cfg/graphinput/withsppf/TestCFGGraphInputWithSPPFFail.kt deleted file mode 100644 index eb59ab6f9..000000000 --- a/src/test/kotlin/cfg/graphinput/withsppf/TestCFGGraphInputWithSPPFFail.kt +++ /dev/null @@ -1,341 +0,0 @@ -package cfg.graphinput.withsppf - -import org.junit.jupiter.api.Test -import org.junit.jupiter.params.ParameterizedTest -import org.junit.jupiter.params.provider.ValueSource -import org.kotgll.cfg.grammar.Alternative -import org.kotgll.cfg.grammar.symbol.* -import org.kotgll.cfg.graphinput.withsppf.GLL -import org.kotgll.graph.GraphNode -import org.kotgll.graph.readGraphFromString -import kotlin.test.assertEquals - -class TestCFGGraphInputWithSPPFFail { - @Test - fun `test 'empty' hand-crafted grammar`() { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative(Alternative(listOf())) - - val graph = GraphNode(id = 0) - - assertEquals(expected = hashMapOf(), actual = GLL(nonterminalS, listOf(graph)).parse()) - } - - @ParameterizedTest(name = "Should be Empty for {0}") - @ValueSource(strings = ["", "b", "bb", "ab", "aa"]) - fun `test 'a' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative(Alternative(listOf(Terminal("a")))) - - assertEquals( - expected = hashMapOf(), - actual = GLL(nonterminalS, listOf(readGraphFromString(input))).parse()) - } - - @ParameterizedTest(name = "Should be Empty for {0}") - @ValueSource(strings = ["", "a", "b", "aba", "ababa", "aa", "b", "bb", "c", "cc"]) - fun `test 'ab' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative(Alternative(listOf(Terminal("a"), Terminal("b")))) - - assertEquals( - expected = hashMapOf(), - actual = GLL(nonterminalS, listOf(readGraphFromString(input))).parse()) - } - - @ParameterizedTest(name = "Should be Empty for {0}") - @ValueSource(strings = ["b", "bb", "c", "cc", "ab", "ac"]) - fun `test 'a-star' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative(Alternative(listOf(Star(Terminal("a"))))) - - assertEquals( - expected = hashMapOf(), - actual = GLL(nonterminalS, listOf(readGraphFromString(input))).parse()) - } - - @ParameterizedTest(name = "Should be Empty for {0}") - @ValueSource(strings = ["", "b", "bb", "c", "cc", "ab", "ac"]) - fun `test 'a-plus' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative(Alternative(listOf(Plus(Terminal("a"))))) - - assertEquals( - expected = hashMapOf(), - actual = GLL(nonterminalS, listOf(readGraphFromString(input))).parse()) - } - - @ParameterizedTest(name = "Should be Empty for {0}") - @ValueSource( - strings = - [ - "abaa", - "abba", - "abca", - "ababaa", - "ababba", - "ababca", - "abbb", - "abcb", - "ababbb", - "ababcb", - "abac", - "abbc", - "abcc", - "ababac", - "ababbc", - "ababcc", - ]) - fun `test '(ab)-star' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative(Alternative(listOf(Star(Terminal("ab"))))) - - val graph = GraphNode(id = 0, isStart = true) - var cur = graph - var i = 0 - while (i < input.length) { - val head = GraphNode(id = i + 1) - cur.addEdge("" + input[i] + input[i + 1], head) - cur = head - i += 2 - } - cur.isFinal = true - - assertEquals(expected = hashMapOf(), actual = GLL(nonterminalS, listOf(graph)).parse()) - } - - @ParameterizedTest(name = "Should be Empty for {0}") - @ValueSource( - strings = - [ - "(", - ")", - "((", - "))", - "()(", - "()()(", - "()()()(", - "())", - "()())", - "()()())", - "(())(", - "(())()(", - "(())()()(", - "(()))", - "(())())", - "(())()())", - "(())(())(", - "(())(())()(", - "(())(())()()(", - "(())(()))", - "(())(())())", - "(())(())()())", - "(()())(()())(", - "(()())(()()))", - ]) - fun `test 'dyck' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative(Alternative(listOf())) - nonterminalS.addAlternative( - Alternative(listOf(Terminal("("), nonterminalS, Terminal(")"), nonterminalS))) - - assertEquals( - expected = hashMapOf(), - actual = GLL(nonterminalS, listOf(readGraphFromString(input))).parse()) - } - - @ParameterizedTest(name = "Should be Empty for {0}") - @ValueSource(strings = ["", "a", "b", "c", "ab", "ac", "abb", "bc", "abcd"]) - fun `test 'abc' ambiguous hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - val nonterminalA = Nonterminal("A") - val nonterminalB = Nonterminal("B") - - nonterminalS.addAlternative(Alternative(listOf(nonterminalA, Terminal("c")))) - nonterminalS.addAlternative(Alternative(listOf(Terminal("a"), nonterminalB, Terminal("c")))) - nonterminalA.addAlternative(Alternative(listOf(Terminal("a"), Terminal("b")))) - nonterminalB.addAlternative(Alternative(listOf(Terminal("b")))) - - assertEquals( - expected = hashMapOf(), - actual = GLL(nonterminalS, listOf(readGraphFromString(input))).parse()) - } - - @ParameterizedTest(name = "Should be Empty for {0}") - @ValueSource( - strings = - [ - "", - "a", - "b", - "c", - "d", - "aa", - "ac", - "ad", - "ba", - "bb", - "bc", - "bd", - "ca", - "cb", - "cc", - "da", - "db", - "dc", - "dd", - ]) - fun `test 'ab or cd' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative(Alternative(listOf(Terminal("ab")))) - nonterminalS.addAlternative(Alternative(listOf(Terminal("cd")))) - - val graph = GraphNode(id = 0, isStart = true) - graph.addEdge(input, GraphNode(id = 1, isFinal = true)) - - assertEquals(expected = hashMapOf(), actual = GLL(nonterminalS, listOf(graph)).parse()) - } - - @ParameterizedTest(name = "Should be Empty for {0}") - @ValueSource(strings = ["b", "bb", "ab"]) - fun `test 'a-optional' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative(Alternative(listOf(Optional(Terminal("a"))))) - - assertEquals( - expected = hashMapOf(), - actual = GLL(nonterminalS, listOf(readGraphFromString(input))).parse()) - } - - @ParameterizedTest(name = "Should be Empty for {0}") - @ValueSource( - strings = - [ - "", - "a", - "b", - "c", - "d", - "aa", - "ac", - "ad", - "ba", - "bb", - "bc", - "bd", - "ca", - "cb", - "cc", - "da", - "db", - "dc", - "dd", - ]) - fun `test 'ab or cd' ambiguous hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - val nonterminalA = Nonterminal("A") - val nonterminalB = Nonterminal("B") - nonterminalS.addAlternative(Alternative(listOf(nonterminalA))) - nonterminalS.addAlternative(Alternative(listOf(nonterminalB))) - - nonterminalA.addAlternative(Alternative(listOf(Terminal("ab")))) - nonterminalA.addAlternative(Alternative(listOf(Terminal("cd")))) - - nonterminalB.addAlternative(Alternative(listOf(Terminal("ab")))) - nonterminalB.addAlternative(Alternative(listOf(Terminal("cd")))) - - val graph = GraphNode(id = 0, isStart = true) - graph.addEdge(input, GraphNode(id = 1, isFinal = true)) - - assertEquals(expected = hashMapOf(), actual = GLL(nonterminalS, listOf(graph)).parse()) - } - - @Test - fun `test 'dyck' hand-crafted grammar two cycle graph`() { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative(Alternative(listOf())) - nonterminalS.addAlternative( - Alternative(listOf(Terminal("("), nonterminalS, Terminal(")"), nonterminalS))) - - val graphNode0 = GraphNode(id = 0, isStart = true, isFinal = true) - val graphNode1 = GraphNode(id = 1, isStart = true, isFinal = true) - val graphNode2 = GraphNode(id = 2, isStart = true, isFinal = true) - val graphNode3 = GraphNode(id = 3, isStart = true) - - graphNode0.addEdge("(", graphNode1) - graphNode1.addEdge("(", graphNode2) - graphNode2.addEdge("(", graphNode0) - - graphNode2.addEdge(")", graphNode3) - graphNode3.addEdge(")", graphNode2) - - assertEquals(expected = hashMapOf(), actual = GLL(nonterminalS, listOf(graphNode3)).parse()) - } - - @Test - fun `test 'a-plus' hand-crafted grammar one cycle graph`() { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative(Alternative(listOf(Terminal("a")))) - nonterminalS.addAlternative(Alternative(listOf(Terminal("a"), nonterminalS))) - - val graphNode0 = GraphNode(id = 0, isStart = true, isFinal = true) - val graphNode1 = GraphNode(id = 1, isStart = true) - - graphNode0.addEdge("a", graphNode1) - graphNode1.addEdge("a", graphNode1) - - assertEquals(expected = hashMapOf(), actual = GLL(nonterminalS, listOf(graphNode0)).parse()) - assertEquals(expected = hashMapOf(), actual = GLL(nonterminalS, listOf(graphNode1)).parse()) - } - - @Test - fun `test 'a-star' hand-crafted grammar one cycle graph`() { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative(Alternative(listOf(Terminal("a"), nonterminalS))) - nonterminalS.addAlternative(Alternative(listOf())) - - val graphNode0 = GraphNode(id = 0, isStart = true) - val graphNode1 = GraphNode(id = 1, isStart = true) - - graphNode0.addEdge("a", graphNode1) - graphNode1.addEdge("a", graphNode1) - - assertEquals( - expected = hashMapOf(), - actual = GLL(nonterminalS, listOf(graphNode0, graphNode1)).parse(), - ) - } - - @Test - fun `test 'g1' hand-crafted grammar two cycle graph`() { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative( - Alternative(listOf(Terminal("subClassOf_r"), nonterminalS, Terminal("subClassOf")))) - nonterminalS.addAlternative( - Alternative(listOf(Terminal("subClassOf_r"), Terminal("subClassOf")))) - nonterminalS.addAlternative( - Alternative(listOf(Terminal("type_r"), nonterminalS, Terminal("type")))) - nonterminalS.addAlternative(Alternative(listOf(Terminal("type_r"), Terminal("type")))) - - val graphNode0 = GraphNode(id = 0, isStart = true, isFinal = true) - val graphNode1 = GraphNode(id = 1, isStart = true, isFinal = true) - val graphNode2 = GraphNode(id = 2) - val graphNode3 = GraphNode(id = 3) - - graphNode0.addEdge("subClassOf_r", graphNode1) - graphNode1.addEdge("subClassOf_r", graphNode2) - graphNode2.addEdge("subClassOf_r", graphNode0) - - graphNode2.addEdge("subClassOf", graphNode3) - graphNode3.addEdge("subClassOf", graphNode2) - - val result = GLL(nonterminalS, listOf(graphNode0, graphNode1, graphNode2, graphNode3)).parse() - val pairs: HashMap> = HashMap() - result.keys.forEach { tail -> - if (!pairs.containsKey(tail)) pairs[tail] = HashSet() - result[tail]!!.keys.forEach { head -> pairs[tail]!!.add(head) } - } - - assertEquals(expected = hashMapOf(), actual = pairs) - } -} diff --git a/src/test/kotlin/cfg/graphinput/withsppf/TestCFGGraphInputWithSPPFSuccess.kt b/src/test/kotlin/cfg/graphinput/withsppf/TestCFGGraphInputWithSPPFSuccess.kt deleted file mode 100644 index 4a86bd0bd..000000000 --- a/src/test/kotlin/cfg/graphinput/withsppf/TestCFGGraphInputWithSPPFSuccess.kt +++ /dev/null @@ -1,365 +0,0 @@ -package cfg.graphinput.withsppf - -import org.junit.jupiter.api.Test -import org.junit.jupiter.params.ParameterizedTest -import org.junit.jupiter.params.provider.ValueSource -import org.kotgll.cfg.grammar.Alternative -import org.kotgll.cfg.grammar.symbol.* -import org.kotgll.cfg.graphinput.withsppf.GLL -import org.kotgll.graph.GraphNode -import org.kotgll.graph.readGraphFromString -import kotlin.test.assertEquals - -class TestCFGGraphInputWithSPPFSuccess { - @Test - fun `test 'empty' hand-crafted grammar`() { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative(Alternative(listOf())) - - val graph = GraphNode(id = 0, isStart = true, isFinal = true) - - val result = GLL(nonterminalS, listOf(graph)).parse() - val pairs: HashMap> = HashMap() - result.keys.forEach { tail -> - if (!pairs.containsKey(tail)) pairs[tail] = HashSet() - result[tail]!!.keys.forEach { head -> pairs[tail]!!.add(head) } - } - - assertEquals(expected = hashMapOf(0 to hashSetOf(0)), actual = pairs) - } - - @Test - fun `test 'a' hand-crafted grammar`() { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative(Alternative(listOf(Terminal("a")))) - - val result = GLL(nonterminalS, listOf(readGraphFromString("a"))).parse() - val pairs: HashMap> = HashMap() - result.keys.forEach { tail -> - if (!pairs.containsKey(tail)) pairs[tail] = HashSet() - result[tail]!!.keys.forEach { head -> pairs[tail]!!.add(head) } - } - - assertEquals(expected = hashMapOf(0 to hashSetOf(1)), actual = pairs) - } - - @Test - fun `test 'ab' hand-crafted grammar`() { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative(Alternative(listOf(Terminal("a"), Terminal("b")))) - - val result = GLL(nonterminalS, listOf(readGraphFromString("ab"))).parse() - val pairs: HashMap> = HashMap() - result.keys.forEach { tail -> - if (!pairs.containsKey(tail)) pairs[tail] = HashSet() - result[tail]!!.keys.forEach { head -> pairs[tail]!!.add(head) } - } - - assertEquals(expected = hashMapOf(0 to hashSetOf(2)), actual = pairs) - } - - @ParameterizedTest(name = "Should be NotEmpty for {0}") - @ValueSource(strings = ["", "a", "aa", "aaa", "aaaa"]) - fun `test 'a-star' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative(Alternative(listOf(Star(Terminal("a"))))) - - val result = GLL(nonterminalS, listOf(readGraphFromString(input))).parse() - val pairs: HashMap> = HashMap() - result.keys.forEach { tail -> - if (!pairs.containsKey(tail)) pairs[tail] = HashSet() - result[tail]!!.keys.forEach { head -> pairs[tail]!!.add(head) } - } - - assertEquals(expected = hashMapOf(0 to hashSetOf(input.length)), actual = pairs) - } - - @ParameterizedTest(name = "Should be NotEmpty for {0}") - @ValueSource(strings = ["a", "aa", "aaa"]) - fun `test 'a-plus' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative(Alternative(listOf(Plus(Terminal("a"))))) - - val result = GLL(nonterminalS, listOf(readGraphFromString(input))).parse() - val pairs: HashMap> = HashMap() - result.keys.forEach { tail -> - if (!pairs.containsKey(tail)) pairs[tail] = HashSet() - result[tail]!!.keys.forEach { head -> pairs[tail]!!.add(head) } - } - - assertEquals(expected = hashMapOf(0 to hashSetOf(input.length)), actual = pairs) - } - - @ParameterizedTest(name = "Should be NotEmpty for {0}") - @ValueSource(strings = ["", "ab", "abab", "ababab"]) - fun `test '(ab)-star' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative(Alternative(listOf(Star(Terminal("ab"))))) - - val graph = GraphNode(id = 0, isStart = true) - var cur = graph - var i = 0 - while (i < input.length) { - val head = GraphNode(id = i + 1) - cur.addEdge("" + input[i] + input[i + 1], head) - cur = head - i += 2 - } - cur.isFinal = true - - val result = GLL(nonterminalS, listOf(graph)).parse() - val pairs: HashMap> = HashMap() - result.keys.forEach { tail -> - if (!pairs.containsKey(tail)) pairs[tail] = HashSet() - result[tail]!!.keys.forEach { head -> pairs[tail]!!.add(head) } - } - - assertEquals(expected = hashMapOf(0 to hashSetOf(cur.id)), actual = pairs) - } - - @ParameterizedTest(name = "Should be NotEmpty for {0}") - @ValueSource( - strings = - [ - "", - "()", - "()()", - "()()()", - "(())", - "(())()", - "(())()()", - "(())(())", - "(())(())()", - "(())(())()()", - "(()())(()())", - "((()))", - "(((())))", - "((((()))))", - ]) - fun `test 'dyck' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative(Alternative(listOf())) - nonterminalS.addAlternative( - Alternative(listOf(Terminal("("), nonterminalS, Terminal(")"), nonterminalS))) - - val result = GLL(nonterminalS, listOf(readGraphFromString(input))).parse() - val pairs: HashMap> = HashMap() - result.keys.forEach { tail -> - if (!pairs.containsKey(tail)) pairs[tail] = HashSet() - result[tail]!!.keys.forEach { head -> pairs[tail]!!.add(head) } - } - - assertEquals(expected = hashMapOf(0 to hashSetOf(input.length)), actual = pairs) - } - - @ParameterizedTest(name = "Should be NotEmpty for {0}") - @ValueSource(strings = ["ab", "cd"]) - fun `test 'ab or cd' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative(Alternative(listOf(Terminal("ab")))) - nonterminalS.addAlternative(Alternative(listOf(Terminal("cd")))) - - val graph = GraphNode(id = 0, isStart = true) - graph.addEdge(input, GraphNode(id = 1, isFinal = true)) - - val result = GLL(nonterminalS, listOf(graph)).parse() - val pairs: HashMap> = HashMap() - result.keys.forEach { tail -> - if (!pairs.containsKey(tail)) pairs[tail] = HashSet() - result[tail]!!.keys.forEach { head -> pairs[tail]!!.add(head) } - } - - assertEquals(expected = hashMapOf(0 to hashSetOf(1)), actual = pairs) - } - - @ParameterizedTest(name = "Should be NotEmpty for {0}") - @ValueSource(strings = ["", "a"]) - fun `test 'a-optional' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative(Alternative(listOf(Optional(Terminal("a"))))) - - val result = GLL(nonterminalS, listOf(readGraphFromString(input))).parse() - val pairs: HashMap> = HashMap() - result.keys.forEach { tail -> - if (!pairs.containsKey(tail)) pairs[tail] = HashSet() - result[tail]!!.keys.forEach { head -> pairs[tail]!!.add(head) } - } - - assertEquals(expected = hashMapOf(0 to hashSetOf(input.length)), actual = pairs) - } - - @ParameterizedTest(name = "Should be NotEmpty for {0}") - @ValueSource(strings = ["abc"]) - fun `test 'abc' ambiguous hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - val nonterminalA = Nonterminal("A") - val nonterminalB = Nonterminal("B") - - nonterminalS.addAlternative(Alternative(listOf(nonterminalA, Terminal("c")))) - nonterminalS.addAlternative(Alternative(listOf(Terminal("a"), nonterminalB, Terminal("c")))) - nonterminalA.addAlternative(Alternative(listOf(Terminal("a"), Terminal("b")))) - nonterminalB.addAlternative(Alternative(listOf(Terminal("b")))) - - val result = GLL(nonterminalS, listOf(readGraphFromString(input))).parse() - val pairs: HashMap> = HashMap() - result.keys.forEach { tail -> - if (!pairs.containsKey(tail)) pairs[tail] = HashSet() - result[tail]!!.keys.forEach { head -> pairs[tail]!!.add(head) } - } - - assertEquals(expected = hashMapOf(0 to hashSetOf(input.length)), actual = pairs) - } - - @ParameterizedTest(name = "Should be NotEmpty for {0}") - @ValueSource(strings = ["ab", "cd"]) - fun `test 'ab or cd' ambiguous hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - val nonterminalA = Nonterminal("A") - val nonterminalB = Nonterminal("B") - nonterminalS.addAlternative(Alternative(listOf(nonterminalA))) - nonterminalS.addAlternative(Alternative(listOf(nonterminalB))) - - nonterminalA.addAlternative(Alternative(listOf(Terminal("ab")))) - nonterminalA.addAlternative(Alternative(listOf(Terminal("cd")))) - - nonterminalB.addAlternative(Alternative(listOf(Terminal("ab")))) - nonterminalB.addAlternative(Alternative(listOf(Terminal("cd")))) - - val graph = GraphNode(id = 0, isStart = true) - graph.addEdge(input, GraphNode(id = 1, isFinal = true)) - - val result = GLL(nonterminalS, listOf(graph)).parse() - val pairs: HashMap> = HashMap() - result.keys.forEach { tail -> - if (!pairs.containsKey(tail)) pairs[tail] = HashSet() - result[tail]!!.keys.forEach { head -> pairs[tail]!!.add(head) } - } - - assertEquals(expected = hashMapOf(0 to hashSetOf(1)), actual = pairs) - } - - @Test - fun `test 'dyck' hand-crafted grammar two cycle graph`() { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative(Alternative(listOf())) - nonterminalS.addAlternative( - Alternative(listOf(Terminal("("), nonterminalS, Terminal(")"), nonterminalS))) - - val graphNode0 = GraphNode(id = 0, isStart = true, isFinal = true) - val graphNode1 = GraphNode(id = 1, isStart = true, isFinal = true) - val graphNode2 = GraphNode(id = 2, isStart = true, isFinal = true) - val graphNode3 = GraphNode(id = 3, isStart = true, isFinal = true) - - graphNode0.addEdge("(", graphNode1) - graphNode1.addEdge("(", graphNode2) - graphNode2.addEdge("(", graphNode0) - - graphNode2.addEdge(")", graphNode3) - graphNode3.addEdge(")", graphNode2) - - val result = GLL(nonterminalS, listOf(graphNode0, graphNode1, graphNode2, graphNode3)).parse() - val pairs: HashMap> = HashMap() - result.keys.forEach { tail -> - if (!pairs.containsKey(tail)) pairs[tail] = HashSet() - result[tail]!!.keys.forEach { head -> pairs[tail]!!.add(head) } - } - - assertEquals( - expected = - hashMapOf( - 0 to hashSetOf(0, 2, 3), - 1 to hashSetOf(1, 2, 3), - 2 to hashSetOf(2, 3), - 3 to hashSetOf(3), - ), - actual = pairs) - } - - @Test - fun `test 'a-plus' hand-crafted grammar one cycle graph`() { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative(Alternative(listOf(Terminal("a")))) - nonterminalS.addAlternative(Alternative(listOf(Terminal("a"), nonterminalS))) - - val graphNode0 = GraphNode(id = 0, isStart = true, isFinal = true) - val graphNode1 = GraphNode(id = 1, isStart = true, isFinal = true) - - graphNode0.addEdge("a", graphNode1) - graphNode1.addEdge("a", graphNode1) - - val result = GLL(nonterminalS, listOf(graphNode0, graphNode1)).parse() - val pairs: HashMap> = HashMap() - result.keys.forEach { tail -> - if (!pairs.containsKey(tail)) pairs[tail] = HashSet() - result[tail]!!.keys.forEach { head -> pairs[tail]!!.add(head) } - } - - assertEquals(expected = hashMapOf(0 to hashSetOf(1), 1 to hashSetOf(1)), actual = pairs) - } - - @Test - fun `test 'a-star' hand-crafted grammar one cycle graph`() { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative(Alternative(listOf(Terminal("a"), nonterminalS))) - nonterminalS.addAlternative(Alternative(listOf())) - - val graphNode0 = GraphNode(id = 0, isStart = true, isFinal = true) - val graphNode1 = GraphNode(id = 1, isStart = true, isFinal = true) - - graphNode0.addEdge("a", graphNode1) - graphNode1.addEdge("a", graphNode1) - - val result = GLL(nonterminalS, listOf(graphNode0, graphNode1)).parse() - val pairs: HashMap> = HashMap() - result.keys.forEach { tail -> - if (!pairs.containsKey(tail)) pairs[tail] = HashSet() - result[tail]!!.keys.forEach { head -> pairs[tail]!!.add(head) } - } - - assertEquals( - expected = hashMapOf(0 to hashSetOf(0, 1), 1 to hashSetOf(1)), - actual = pairs, - ) - } - - @Test - fun `test 'g1' hand-crafted grammar two cycle graph`() { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative( - Alternative(listOf(Terminal("subClassOf_r"), nonterminalS, Terminal("subClassOf")))) - nonterminalS.addAlternative( - Alternative(listOf(Terminal("subClassOf_r"), Terminal("subClassOf")))) - nonterminalS.addAlternative( - Alternative(listOf(Terminal("type_r"), nonterminalS, Terminal("type")))) - nonterminalS.addAlternative(Alternative(listOf(Terminal("type_r"), Terminal("type")))) - - val graphNode0 = GraphNode(id = 0, isStart = true, isFinal = true) - val graphNode1 = GraphNode(id = 1, isStart = true, isFinal = true) - val graphNode2 = GraphNode(id = 2, isStart = true, isFinal = true) - val graphNode3 = GraphNode(id = 3, isStart = true, isFinal = true) - - graphNode0.addEdge("subClassOf_r", graphNode1) - graphNode1.addEdge("subClassOf_r", graphNode2) - graphNode2.addEdge("subClassOf_r", graphNode0) - - graphNode2.addEdge("subClassOf", graphNode3) - graphNode3.addEdge("subClassOf", graphNode2) - - val result = GLL(nonterminalS, listOf(graphNode0, graphNode1, graphNode2, graphNode3)).parse() - val pairs: HashMap> = HashMap() - result.keys.forEach { tail -> - if (!pairs.containsKey(tail)) pairs[tail] = HashSet() - result[tail]!!.keys.forEach { head -> pairs[tail]!!.add(head) } - } - - assertEquals( - expected = - hashMapOf( - 0 to hashSetOf(2, 3), - 1 to hashSetOf(2, 3), - 2 to hashSetOf(2, 3), - ), - actual = pairs, - ) - } -} diff --git a/src/test/kotlin/cfg/stringinput/withoutsppf/TestCFGStringInputWithoutSPPFFail.kt b/src/test/kotlin/cfg/stringinput/withoutsppf/TestCFGStringInputWithoutSPPFFail.kt deleted file mode 100644 index 5fb13f70d..000000000 --- a/src/test/kotlin/cfg/stringinput/withoutsppf/TestCFGStringInputWithoutSPPFFail.kt +++ /dev/null @@ -1,223 +0,0 @@ -package cfg.stringinput.withoutsppf - -import org.junit.jupiter.api.Test -import org.junit.jupiter.params.ParameterizedTest -import org.junit.jupiter.params.provider.ValueSource -import org.kotgll.cfg.grammar.Alternative -import org.kotgll.cfg.grammar.symbol.* -import org.kotgll.cfg.stringinput.withoutsppf.GLL -import kotlin.test.assertFalse - -class TestCFGStringInputWithoutSPPFFail { - @Test - fun `test 'empty' hand-crafted grammar`() { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative(Alternative(listOf())) - - assertFalse(GLL(nonterminalS, "a").parse()) - } - - @ParameterizedTest(name = "Should be False for {0}") - @ValueSource(strings = ["", "b", "bb", "ab", "aa"]) - fun `test 'a' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative(Alternative(listOf(Terminal("a")))) - - assertFalse(GLL(nonterminalS, input).parse()) - } - - @ParameterizedTest(name = "Should be False for {0}") - @ValueSource(strings = ["", "a", "b", "aba", "ababa", "aa", "b", "bb", "c", "cc"]) - fun `test 'ab' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative(Alternative(listOf(Terminal("a"), Terminal("b")))) - - assertFalse(GLL(nonterminalS, input).parse()) - } - - @ParameterizedTest(name = "Should be Null for {0}") - @ValueSource(strings = ["b", "bb", "c", "cc", "ab", "ac"]) - fun `test 'a-star' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative(Alternative(listOf(Star(Terminal("a"))))) - - assertFalse(GLL(nonterminalS, input).parse()) - } - - @ParameterizedTest(name = "Should be Null for {0}") - @ValueSource(strings = ["", "b", "bb", "c", "cc", "ab", "ac"]) - fun `test 'a-plus' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative(Alternative(listOf(Plus(Terminal("a"))))) - - assertFalse(GLL(nonterminalS, input).parse()) - } - - @ParameterizedTest(name = "Should be Null for {0}") - @ValueSource( - strings = - [ - "abaa", - "abba", - "abca", - "ababaa", - "ababba", - "ababca", - "abbb", - "abcb", - "ababbb", - "ababcb", - "abac", - "abbc", - "abcc", - "ababac", - "ababbc", - "ababcc", - ]) - fun `test '(ab)-star' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative(Alternative(listOf(Star(Terminal("ab"))))) - - assertFalse(GLL(nonterminalS, input).parse()) - } - - @ParameterizedTest(name = "Should be Null for {0}") - @ValueSource( - strings = - [ - "(", - ")", - "((", - "))", - "()(", - "()()(", - "()()()(", - "())", - "()())", - "()()())", - "(())(", - "(())()(", - "(())()()(", - "(()))", - "(())())", - "(())()())", - "(())(())(", - "(())(())()(", - "(())(())()()(", - "(())(()))", - "(())(())())", - "(())(())()())", - "(()())(()())(", - "(()())(()()))", - ]) - fun `test 'dyck' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative(Alternative(listOf())) - nonterminalS.addAlternative( - Alternative( - listOf( - Terminal("("), - nonterminalS, - Terminal(")"), - nonterminalS, - ))) - - assertFalse(GLL(nonterminalS, input).parse()) - } - - @ParameterizedTest(name = "Should be Null for {0}") - @ValueSource( - strings = - [ - "", - "a", - "b", - "c", - "d", - "aa", - "ac", - "ad", - "ba", - "bb", - "bc", - "bd", - "ca", - "cb", - "cc", - "da", - "db", - "dc", - "dd", - ]) - fun `test 'ab or cd' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative(Alternative(listOf(Terminal("ab")))) - nonterminalS.addAlternative(Alternative(listOf(Terminal("cd")))) - - assertFalse(GLL(nonterminalS, input).parse()) - } - - @ParameterizedTest(name = "Should be Null for {0}") - @ValueSource(strings = ["b", "bb", "ab"]) - fun `test 'a-optional' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative(Alternative(listOf(Optional(Terminal("a"))))) - - assertFalse(GLL(nonterminalS, input).parse()) - } - - @ParameterizedTest(name = "Should be Null for {0}") - @ValueSource(strings = ["", "a", "b", "c", "ab", "ac", "abb", "bc", "abcd"]) - fun `test 'abc' ambiguous hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - val nonterminalA = Nonterminal("A") - val nonterminalB = Nonterminal("B") - - nonterminalS.addAlternative(Alternative(listOf(nonterminalA, Terminal("c")))) - nonterminalS.addAlternative(Alternative(listOf(Terminal("a"), nonterminalB, Terminal("c")))) - nonterminalA.addAlternative(Alternative(listOf(Terminal("a"), Terminal("b")))) - nonterminalB.addAlternative(Alternative(listOf(Terminal("b")))) - - assertFalse(GLL(nonterminalS, input).parse()) - } - - @ParameterizedTest(name = "Should be Null for {0}") - @ValueSource( - strings = - [ - "", - "a", - "b", - "c", - "d", - "aa", - "ac", - "ad", - "ba", - "bb", - "bc", - "bd", - "ca", - "cb", - "cc", - "da", - "db", - "dc", - "dd", - ]) - fun `test 'ab or cd' ambiguous hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - val nonterminalA = Nonterminal("A") - val nonterminalB = Nonterminal("B") - nonterminalS.addAlternative(Alternative(listOf(nonterminalA))) - nonterminalS.addAlternative(Alternative(listOf(nonterminalB))) - - nonterminalA.addAlternative(Alternative(listOf(Terminal("ab")))) - nonterminalA.addAlternative(Alternative(listOf(Terminal("cd")))) - - nonterminalB.addAlternative(Alternative(listOf(Terminal("ab")))) - nonterminalB.addAlternative(Alternative(listOf(Terminal("cd")))) - - assertFalse(GLL(nonterminalS, input).parse()) - } -} diff --git a/src/test/kotlin/cfg/stringinput/withoutsppf/TestCFGStringInputWithoutSPPFSuccess.kt b/src/test/kotlin/cfg/stringinput/withoutsppf/TestCFGStringInputWithoutSPPFSuccess.kt deleted file mode 100644 index d56f5f8ca..000000000 --- a/src/test/kotlin/cfg/stringinput/withoutsppf/TestCFGStringInputWithoutSPPFSuccess.kt +++ /dev/null @@ -1,148 +0,0 @@ -package cfg.stringinput.withoutsppf - -import org.junit.jupiter.api.Test -import org.junit.jupiter.params.ParameterizedTest -import org.junit.jupiter.params.provider.ValueSource -import org.kotgll.cfg.grammar.Alternative -import org.kotgll.cfg.grammar.symbol.* -import org.kotgll.cfg.stringinput.withoutsppf.GLL -import kotlin.test.assertTrue - -class TestCFGStringInputWithoutSPPFSuccess { - @Test - fun `test 'empty' hand-crafted grammar`() { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative(Alternative(listOf())) - - assertTrue(GLL(nonterminalS, "").parse()) - } - - @Test - fun `test 'a' hand-crafted grammar`() { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative(Alternative(listOf(Terminal("a")))) - - assertTrue(GLL(nonterminalS, "a").parse()) - } - - @Test - fun `test 'ab' hand-crafted grammar`() { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative(Alternative(listOf(Terminal("a"), Terminal("b")))) - - assertTrue(GLL(nonterminalS, "ab").parse()) - } - - @ParameterizedTest(name = "Should be True for {0}") - @ValueSource(strings = ["", "a", "aa", "aaa", "aaaa"]) - fun `test 'a-star' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative(Alternative(listOf(Star(Terminal("a"))))) - - assertTrue(GLL(nonterminalS, input).parse()) - } - - @ParameterizedTest(name = "Should be True for {0}") - @ValueSource(strings = ["a", "aa", "aaa"]) - fun `test 'a-plus' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative(Alternative(listOf(Plus(Terminal("a"))))) - - assertTrue(GLL(nonterminalS, input).parse()) - } - - @ParameterizedTest(name = "Should be True for {0}") - @ValueSource(strings = ["", "ab", "abab", "ababab"]) - fun `test '(ab)-star' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative(Alternative(listOf(Star(Terminal("ab"))))) - - assertTrue(GLL(nonterminalS, input).parse()) - } - - @ParameterizedTest(name = "Should be True for {0}") - @ValueSource( - strings = - [ - "", - "()", - "()()", - "()()()", - "(())", - "(())()", - "(())()()", - "(())(())", - "(())(())()", - "(())(())()()", - "(()())(()())", - "((()))", - "(((())))", - "((((()))))", - ]) - fun `test 'dyck' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative(Alternative(listOf())) - nonterminalS.addAlternative( - Alternative( - listOf( - Terminal("("), - nonterminalS, - Terminal(")"), - nonterminalS, - ))) - - assertTrue(GLL(nonterminalS, input).parse()) - } - - @ParameterizedTest(name = "Should be True for {0}") - @ValueSource(strings = ["ab", "cd"]) - fun `test 'ab or cd' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative(Alternative(listOf(Terminal("ab")))) - nonterminalS.addAlternative(Alternative(listOf(Terminal("cd")))) - - assertTrue(GLL(nonterminalS, input).parse()) - } - - @ParameterizedTest(name = "Should be True for {0}") - @ValueSource(strings = ["", "a"]) - fun `test 'a-optional' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative(Alternative(listOf(Optional(Terminal("a"))))) - - assertTrue(GLL(nonterminalS, input).parse()) - } - - @ParameterizedTest(name = "Should be True for {0}") - @ValueSource(strings = ["abc"]) - fun `test 'abc' ambiguous hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - val nonterminalA = Nonterminal("A") - val nonterminalB = Nonterminal("B") - - nonterminalS.addAlternative(Alternative(listOf(nonterminalA, Terminal("c")))) - nonterminalS.addAlternative(Alternative(listOf(Terminal("a"), nonterminalB, Terminal("c")))) - nonterminalA.addAlternative(Alternative(listOf(Terminal("a"), Terminal("b")))) - nonterminalB.addAlternative(Alternative(listOf(Terminal("b")))) - - assertTrue(GLL(nonterminalS, input).parse()) - } - - @ParameterizedTest(name = "Should be True for {0}") - @ValueSource(strings = ["ab", "cd"]) - fun `test 'ab or cd' ambiguous hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - val nonterminalA = Nonterminal("A") - val nonterminalB = Nonterminal("B") - nonterminalS.addAlternative(Alternative(listOf(nonterminalA))) - nonterminalS.addAlternative(Alternative(listOf(nonterminalB))) - - nonterminalA.addAlternative(Alternative(listOf(Terminal("ab")))) - nonterminalA.addAlternative(Alternative(listOf(Terminal("cd")))) - - nonterminalB.addAlternative(Alternative(listOf(Terminal("ab")))) - nonterminalB.addAlternative(Alternative(listOf(Terminal("cd")))) - - assertTrue(GLL(nonterminalS, input).parse()) - } -} diff --git a/src/test/kotlin/cfg/stringinput/withsppf/TestCFGStringInputWithSPPFFail.kt b/src/test/kotlin/cfg/stringinput/withsppf/TestCFGStringInputWithSPPFFail.kt deleted file mode 100644 index 04d131d0e..000000000 --- a/src/test/kotlin/cfg/stringinput/withsppf/TestCFGStringInputWithSPPFFail.kt +++ /dev/null @@ -1,223 +0,0 @@ -package cfg.stringinput.withsppf - -import org.junit.jupiter.api.Test -import org.junit.jupiter.params.ParameterizedTest -import org.junit.jupiter.params.provider.ValueSource -import org.kotgll.cfg.grammar.Alternative -import org.kotgll.cfg.grammar.symbol.* -import org.kotgll.cfg.stringinput.withsppf.GLL -import kotlin.test.assertNull - -class TestCFGStringInputWithSPPFFail { - @Test - fun `test 'empty' hand-crafted grammar`() { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative(Alternative(listOf())) - - assertNull(GLL(nonterminalS, "a").parse()) - } - - @ParameterizedTest(name = "Should be Null for {0}") - @ValueSource(strings = ["", "b", "bb", "ab", "aa"]) - fun `test 'a' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative(Alternative(listOf(Terminal("a")))) - - assertNull(GLL(nonterminalS, input).parse()) - } - - @ParameterizedTest(name = "Should be Null for {0}") - @ValueSource(strings = ["", "a", "b", "aba", "ababa", "aa", "b", "bb", "c", "cc"]) - fun `test 'ab' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative(Alternative(listOf(Terminal("a"), Terminal("b")))) - - assertNull(GLL(nonterminalS, input).parse()) - } - - @ParameterizedTest(name = "Should be Null for {0}") - @ValueSource(strings = ["b", "bb", "c", "cc", "ab", "ac"]) - fun `test 'a-star' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative(Alternative(listOf(Star(Terminal("a"))))) - - assertNull(GLL(nonterminalS, input).parse()) - } - - @ParameterizedTest(name = "Should be Null for {0}") - @ValueSource(strings = ["", "b", "bb", "c", "cc", "ab", "ac"]) - fun `test 'a-plus' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative(Alternative(listOf(Plus(Terminal("a"))))) - - assertNull(GLL(nonterminalS, input).parse()) - } - - @ParameterizedTest(name = "Should be Null for {0}") - @ValueSource( - strings = - [ - "abaa", - "abba", - "abca", - "ababaa", - "ababba", - "ababca", - "abbb", - "abcb", - "ababbb", - "ababcb", - "abac", - "abbc", - "abcc", - "ababac", - "ababbc", - "ababcc", - ]) - fun `test '(ab)-star' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative(Alternative(listOf(Star(Terminal("ab"))))) - - assertNull(GLL(nonterminalS, input).parse()) - } - - @ParameterizedTest(name = "Should be Null for {0}") - @ValueSource( - strings = - [ - "(", - ")", - "((", - "))", - "()(", - "()()(", - "()()()(", - "())", - "()())", - "()()())", - "(())(", - "(())()(", - "(())()()(", - "(()))", - "(())())", - "(())()())", - "(())(())(", - "(())(())()(", - "(())(())()()(", - "(())(()))", - "(())(())())", - "(())(())()())", - "(()())(()())(", - "(()())(()()))", - ]) - fun `test 'dyck' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative(Alternative(listOf())) - nonterminalS.addAlternative( - Alternative( - listOf( - Terminal("("), - nonterminalS, - Terminal(")"), - nonterminalS, - ))) - - assertNull(GLL(nonterminalS, input).parse()) - } - - @ParameterizedTest(name = "Should be Null for {0}") - @ValueSource( - strings = - [ - "", - "a", - "b", - "c", - "d", - "aa", - "ac", - "ad", - "ba", - "bb", - "bc", - "bd", - "ca", - "cb", - "cc", - "da", - "db", - "dc", - "dd", - ]) - fun `test 'ab or cd' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative(Alternative(listOf(Terminal("ab")))) - nonterminalS.addAlternative(Alternative(listOf(Terminal("cd")))) - - assertNull(GLL(nonterminalS, input).parse()) - } - - @ParameterizedTest(name = "Should be Null for {0}") - @ValueSource(strings = ["b", "bb", "ab"]) - fun `test 'a-optional' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative(Alternative(listOf(Optional(Terminal("a"))))) - - assertNull(GLL(nonterminalS, input).parse()) - } - - @ParameterizedTest(name = "Should be Null for {0}") - @ValueSource(strings = ["", "a", "b", "c", "ab", "ac", "abb", "bc", "abcd"]) - fun `test 'abc' ambiguous hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - val nonterminalA = Nonterminal("A") - val nonterminalB = Nonterminal("B") - - nonterminalS.addAlternative(Alternative(listOf(nonterminalA, Terminal("c")))) - nonterminalS.addAlternative(Alternative(listOf(Terminal("a"), nonterminalB, Terminal("c")))) - nonterminalA.addAlternative(Alternative(listOf(Terminal("a"), Terminal("b")))) - nonterminalB.addAlternative(Alternative(listOf(Terminal("b")))) - - assertNull(GLL(nonterminalS, input).parse()) - } - - @ParameterizedTest(name = "Should be Null for {0}") - @ValueSource( - strings = - [ - "", - "a", - "b", - "c", - "d", - "aa", - "ac", - "ad", - "ba", - "bb", - "bc", - "bd", - "ca", - "cb", - "cc", - "da", - "db", - "dc", - "dd", - ]) - fun `test 'ab or cd' ambiguous hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - val nonterminalA = Nonterminal("A") - val nonterminalB = Nonterminal("B") - nonterminalS.addAlternative(Alternative(listOf(nonterminalA))) - nonterminalS.addAlternative(Alternative(listOf(nonterminalB))) - - nonterminalA.addAlternative(Alternative(listOf(Terminal("ab")))) - nonterminalA.addAlternative(Alternative(listOf(Terminal("cd")))) - - nonterminalB.addAlternative(Alternative(listOf(Terminal("ab")))) - nonterminalB.addAlternative(Alternative(listOf(Terminal("cd")))) - - assertNull(GLL(nonterminalS, input).parse()) - } -} diff --git a/src/test/kotlin/cfg/stringinput/withsppf/TestCFGStringInputWithSPPFSuccess.kt b/src/test/kotlin/cfg/stringinput/withsppf/TestCFGStringInputWithSPPFSuccess.kt deleted file mode 100644 index 7ee55ab5a..000000000 --- a/src/test/kotlin/cfg/stringinput/withsppf/TestCFGStringInputWithSPPFSuccess.kt +++ /dev/null @@ -1,153 +0,0 @@ -package cfg.stringinput.withsppf - -import org.junit.jupiter.api.Test -import org.junit.jupiter.params.ParameterizedTest -import org.junit.jupiter.params.provider.ValueSource -import org.kotgll.cfg.grammar.Alternative -import org.kotgll.cfg.grammar.symbol.* -import org.kotgll.cfg.stringinput.withsppf.GLL -import kotlin.test.assertNotNull - -class TestCFGStringInputWithSPPFSuccess { - @Test - fun `test 'empty' hand-crafted grammar`() { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative(Alternative(listOf())) - - assertNotNull(GLL(nonterminalS, "").parse()) - } - - @Test - fun `test 'a' hand-crafted grammar`() { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative(Alternative(listOf(Terminal("a")))) - - assertNotNull(GLL(nonterminalS, "a").parse()) - } - - @Test - fun `test 'ab' hand-crafted grammar`() { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative( - Alternative( - listOf( - Terminal("a"), - Terminal("b"), - ))) - - assertNotNull(GLL(nonterminalS, "ab").parse()) - } - - @ParameterizedTest(name = "Should be NotNull for {0}") - @ValueSource(strings = ["", "a", "aa", "aaa", "aaaa"]) - fun `test 'a-star' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative(Alternative(listOf(Star(Terminal("a"))))) - - assertNotNull(GLL(nonterminalS, input).parse()) - } - - @ParameterizedTest(name = "Should be NotNull for {0}") - @ValueSource(strings = ["a", "aa", "aaa"]) - fun `test 'a-plus' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative(Alternative(listOf(Plus(Terminal("a"))))) - - assertNotNull(GLL(nonterminalS, input).parse()) - } - - @ParameterizedTest(name = "Should be NotNull for {0}") - @ValueSource(strings = ["", "ab", "abab", "ababab"]) - fun `test '(ab)-star' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative(Alternative(listOf(Star(Terminal("ab"))))) - - assertNotNull(GLL(nonterminalS, input).parse()) - } - - @ParameterizedTest(name = "Should be NotNull for {0}") - @ValueSource( - strings = - [ - "", - "()", - "()()", - "()()()", - "(())", - "(())()", - "(())()()", - "(())(())", - "(())(())()", - "(())(())()()", - "(()())(()())", - "((()))", - "(((())))", - "((((()))))", - ]) - fun `test 'dyck' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative(Alternative(listOf())) - nonterminalS.addAlternative( - Alternative( - listOf( - Terminal("("), - nonterminalS, - Terminal(")"), - nonterminalS, - ))) - - assertNotNull(GLL(nonterminalS, input).parse()) - } - - @ParameterizedTest(name = "Should be NotNull for {0}") - @ValueSource(strings = ["ab", "cd"]) - fun `test 'ab or cd' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative(Alternative(listOf(Terminal("ab")))) - nonterminalS.addAlternative(Alternative(listOf(Terminal("cd")))) - - assertNotNull(GLL(nonterminalS, input).parse()) - } - - @ParameterizedTest(name = "Should be NotNull for {0}") - @ValueSource(strings = ["", "a"]) - fun `test 'a-optional' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative(Alternative(listOf(Optional(Terminal("a"))))) - - assertNotNull(GLL(nonterminalS, input).parse()) - } - - @ParameterizedTest(name = "Should be NotNull for {0}") - @ValueSource(strings = ["abc"]) - fun `test 'abc' ambiguous hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - val nonterminalA = Nonterminal("A") - val nonterminalB = Nonterminal("B") - - nonterminalS.addAlternative(Alternative(listOf(nonterminalA, Terminal("c")))) - nonterminalS.addAlternative(Alternative(listOf(Terminal("a"), nonterminalB, Terminal("c")))) - nonterminalA.addAlternative(Alternative(listOf(Terminal("a"), Terminal("b")))) - nonterminalB.addAlternative(Alternative(listOf(Terminal("b")))) - - assertNotNull(GLL(nonterminalS, input).parse()) - } - - @ParameterizedTest(name = "Should be NotNull for {0}") - @ValueSource(strings = ["ab", "cd"]) - fun `test 'ab or cd' ambiguous hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - val nonterminalA = Nonterminal("A") - val nonterminalB = Nonterminal("B") - nonterminalS.addAlternative(Alternative(listOf(nonterminalA))) - nonterminalS.addAlternative(Alternative(listOf(nonterminalB))) - - nonterminalA.addAlternative(Alternative(listOf(Terminal("ab")))) - nonterminalA.addAlternative(Alternative(listOf(Terminal("cd")))) - - nonterminalB.addAlternative(Alternative(listOf(Terminal("ab")))) - nonterminalB.addAlternative(Alternative(listOf(Terminal("cd")))) - - assertNotNull(GLL(nonterminalS, input).parse()) - } -} diff --git a/src/test/kotlin/cli/TestCFGReadWriteTXT.kt b/src/test/kotlin/cli/TestCFGReadWriteTXT.kt deleted file mode 100644 index 113b429e0..000000000 --- a/src/test/kotlin/cli/TestCFGReadWriteTXT.kt +++ /dev/null @@ -1,281 +0,0 @@ -package cli - -import org.junit.jupiter.api.Test -import org.kotgll.cfg.grammar.Alternative -import org.kotgll.cfg.grammar.readCFGFromTXT -import org.kotgll.cfg.grammar.symbol.Nonterminal -import org.kotgll.cfg.grammar.symbol.Terminal -import org.kotgll.cfg.grammar.writeCFGToTXT -import kotlin.test.assertEquals - -class TestCFGReadWriteTXT { - @Test - fun `'a' cfg`() { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative(Alternative(listOf(Terminal("a")))) - - val pathToTXT = "src/test/resources/cli/TestCFGReadWriteTXT/a.txt" - writeCFGToTXT(nonterminalS, pathToTXT) - val actualNonterminal = readCFGFromTXT(pathToTXT) - - assertEquals(expected = nonterminalS, actual = actualNonterminal) - assertEquals(expected = nonterminalS.alternatives, actual = actualNonterminal.alternatives) - } - - @Test - fun `'a-star' cfg`() { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative(Alternative(listOf(Terminal("a")))) - nonterminalS.addAlternative(Alternative(listOf(Terminal("a"), nonterminalS))) - - val pathToTXT = "src/test/resources/cli/TestCFGReadWriteTXT/a_star.txt" - writeCFGToTXT(nonterminalS, pathToTXT) - val actualNonterminal = readCFGFromTXT(pathToTXT) - - assertEquals(expected = nonterminalS, actual = actualNonterminal) - assertEquals(expected = nonterminalS.alternatives, actual = actualNonterminal.alternatives) - } - - @Test - fun `'dyck' cfg`() { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative( - Alternative(listOf(Terminal("("), nonterminalS, Terminal(")"), nonterminalS))) - nonterminalS.addAlternative(Alternative(listOf())) - - val pathToTXT = "src/test/resources/cli/TestCFGReadWriteTXT/dyck.txt" - writeCFGToTXT(nonterminalS, pathToTXT) - val actualNonterminal = readCFGFromTXT(pathToTXT) - - assertEquals(expected = nonterminalS, actual = actualNonterminal) - assertEquals(expected = nonterminalS.alternatives, actual = actualNonterminal.alternatives) - } - - @Test - fun `'g1' cfg`() { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative( - Alternative(listOf(Terminal("subClassOf_r"), nonterminalS, Terminal("subClassOf")))) - nonterminalS.addAlternative( - Alternative(listOf(Terminal("subClassOf_r"), Terminal("subClassOf")))) - nonterminalS.addAlternative( - Alternative(listOf(Terminal("type_r"), nonterminalS, Terminal("type")))) - nonterminalS.addAlternative(Alternative(listOf(Terminal("type_r"), Terminal("type")))) - - val pathToTXT = "src/test/resources/cli/TestCFGReadWriteTXT/g1.txt" - writeCFGToTXT(nonterminalS, pathToTXT) - val actualNonterminal = readCFGFromTXT(pathToTXT) - - assertEquals(expected = nonterminalS, actual = actualNonterminal) - assertEquals(expected = nonterminalS.alternatives, actual = actualNonterminal.alternatives) - } - - @Test - fun `'g2' cfg`() { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative( - Alternative(listOf(Terminal("subClassOf_r"), nonterminalS, Terminal("subClassOf")))) - nonterminalS.addAlternative(Alternative(listOf(Terminal("subClassOf")))) - - val pathToTXT = "src/test/resources/cli/TestCFGReadWriteTXT/g2.txt" - writeCFGToTXT(nonterminalS, pathToTXT) - val actualNonterminal = readCFGFromTXT(pathToTXT) - - assertEquals(expected = nonterminalS, actual = actualNonterminal) - assertEquals(expected = nonterminalS.alternatives, actual = actualNonterminal.alternatives) - } - - @Test - fun `'geo' cfg`() { - val nonterminalS = Nonterminal("S") - nonterminalS.addAlternative( - Alternative( - listOf( - Terminal("broaderTransitive"), - nonterminalS, - Terminal("broaderTransitive_r"), - ))) - nonterminalS.addAlternative( - Alternative( - listOf( - Terminal("broaderTransitive"), - Terminal("broaderTransitive_r"), - ))) - - val pathToTXT = "src/test/resources/cli/TestCFGReadWriteTXT/geo.txt" - writeCFGToTXT(nonterminalS, pathToTXT) - val actualNonterminal = readCFGFromTXT(pathToTXT) - - assertEquals(expected = nonterminalS, actual = actualNonterminal) - assertEquals(expected = nonterminalS.alternatives, actual = actualNonterminal.alternatives) - } - - @Test - fun `'c_analysis' rsm`() { - val nonterminalS = Nonterminal("S") - val nonterminalV = Nonterminal("V") - val nonterminalV1 = Nonterminal("V1") - val nonterminalV2 = Nonterminal("V2") - val nonterminalV3 = Nonterminal("V3") - - nonterminalS.addAlternative(Alternative(listOf(Terminal("d_r"), nonterminalV, Terminal("d")))) - nonterminalV.addAlternative(Alternative(listOf(nonterminalV1, nonterminalV2, nonterminalV3))) - nonterminalV1.addAlternative(Alternative(listOf())) - nonterminalV1.addAlternative(Alternative(listOf(nonterminalV2, Terminal("a_r"), nonterminalV1))) - nonterminalV2.addAlternative(Alternative(listOf())) - nonterminalV2.addAlternative(Alternative(listOf(nonterminalS))) - nonterminalV3.addAlternative(Alternative(listOf())) - nonterminalV3.addAlternative(Alternative(listOf(Terminal("a"), nonterminalV2, nonterminalV3))) - - val pathToTXT = "src/test/resources/cli/TestCFGReadWriteTXT/c_analysis.txt" - writeCFGToTXT(nonterminalS, pathToTXT) - val actualNonterminal = readCFGFromTXT(pathToTXT) - - assertEquals(expected = nonterminalS, actual = actualNonterminal) - assertEquals(expected = nonterminalS.alternatives, actual = actualNonterminal.alternatives) - } - - @Test - fun `'rdf_reg1' cfg`() { - val nonterminalS = Nonterminal("S") - - nonterminalS.addAlternative(Alternative(listOf())) - nonterminalS.addAlternative(Alternative(listOf(Terminal("type"), nonterminalS))) - - val pathToTXT = "src/test/resources/cli/TestCFGReadWriteTXT/rdf_reg1.txt" - writeCFGToTXT(nonterminalS, pathToTXT) - val actualNonterminal = readCFGFromTXT(pathToTXT) - - assertEquals(expected = nonterminalS, actual = actualNonterminal) - assertEquals(expected = nonterminalS.alternatives, actual = actualNonterminal.alternatives) - } - - @Test - fun `'rdf_reg2' cfg`() { - val nonterminalS = Nonterminal("S") - val nonterminalA = Nonterminal("A") - - nonterminalS.addAlternative(Alternative(listOf())) - nonterminalS.addAlternative(Alternative(listOf(Terminal("type"), nonterminalA))) - - nonterminalA.addAlternative(Alternative(listOf())) - nonterminalA.addAlternative(Alternative(listOf(Terminal("subClassOf"), nonterminalA))) - - val pathToTXT = "src/test/resources/cli/TestCFGReadWriteTXT/rdf_reg2.txt" - writeCFGToTXT(nonterminalS, pathToTXT) - val actualNonterminal = readCFGFromTXT(pathToTXT) - - assertEquals(expected = nonterminalS, actual = actualNonterminal) - assertEquals(expected = nonterminalS.alternatives, actual = actualNonterminal.alternatives) - } - - @Test - fun `'rdf_reg3' cfg`() { - val nonterminalS = Nonterminal("S") - - nonterminalS.addAlternative(Alternative(listOf())) - nonterminalS.addAlternative(Alternative(listOf(Terminal("type"), nonterminalS))) - nonterminalS.addAlternative(Alternative(listOf(Terminal("subClassOf"), nonterminalS))) - - val pathToTXT = "src/test/resources/cli/TestCFGReadWriteTXT/rdf_reg3.txt" - writeCFGToTXT(nonterminalS, pathToTXT) - val actualNonterminal = readCFGFromTXT(pathToTXT) - - assertEquals(expected = nonterminalS, actual = actualNonterminal) - assertEquals(expected = nonterminalS.alternatives, actual = actualNonterminal.alternatives) - } - - @Test - fun `'rdf_reg4' cfg`() { - val nonterminalS = Nonterminal("S") - val nonterminalA = Nonterminal("A") - val nonterminalB = Nonterminal("B") - - nonterminalS.addAlternative(Alternative(listOf(nonterminalA, nonterminalB))) - - nonterminalA.addAlternative(Alternative(listOf())) - nonterminalA.addAlternative(Alternative(listOf(Terminal("type"), nonterminalA))) - - nonterminalB.addAlternative(Alternative(listOf())) - nonterminalB.addAlternative(Alternative(listOf(Terminal("subClassOf"), nonterminalB))) - - val pathToTXT = "src/test/resources/cli/TestCFGReadWriteTXT/rdf_reg4.txt" - writeCFGToTXT(nonterminalS, pathToTXT) - val actualNonterminal = readCFGFromTXT(pathToTXT) - - assertEquals(expected = nonterminalS, actual = actualNonterminal) - assertEquals(expected = nonterminalS.alternatives, actual = actualNonterminal.alternatives) - } - - @Test - fun `'c_analysis_reg1' cfg`() { - val nonterminalS = Nonterminal("S") - - nonterminalS.addAlternative(Alternative(listOf())) - nonterminalS.addAlternative(Alternative(listOf(Terminal("a"), nonterminalS))) - - val pathToTXT = "src/test/resources/cli/TestCFGReadWriteTXT/c_analysis_reg1.txt" - writeCFGToTXT(nonterminalS, pathToTXT) - val actualNonterminal = readCFGFromTXT(pathToTXT) - - assertEquals(expected = nonterminalS, actual = actualNonterminal) - assertEquals(expected = nonterminalS.alternatives, actual = actualNonterminal.alternatives) - } - - @Test - fun `'c_analysis_reg2' cfg`() { - val nonterminalS = Nonterminal("S") - val nonterminalA = Nonterminal("A") - - nonterminalS.addAlternative(Alternative(listOf())) - nonterminalS.addAlternative(Alternative(listOf(Terminal("a"), nonterminalA))) - - nonterminalA.addAlternative(Alternative(listOf())) - nonterminalA.addAlternative(Alternative(listOf(Terminal("d"), nonterminalA))) - - val pathToTXT = "src/test/resources/cli/TestCFGReadWriteTXT/c_analysis_reg2.txt" - writeCFGToTXT(nonterminalS, pathToTXT) - val actualNonterminal = readCFGFromTXT(pathToTXT) - - assertEquals(expected = nonterminalS, actual = actualNonterminal) - assertEquals(expected = nonterminalS.alternatives, actual = actualNonterminal.alternatives) - } - - @Test - fun `'c_analysis_reg3' cfg`() { - val nonterminalS = Nonterminal("S") - - nonterminalS.addAlternative(Alternative(listOf())) - nonterminalS.addAlternative(Alternative(listOf(Terminal("a"), nonterminalS))) - nonterminalS.addAlternative(Alternative(listOf(Terminal("d"), nonterminalS))) - - val pathToTXT = "src/test/resources/cli/TestCFGReadWriteTXT/c_analysis_reg3.txt" - writeCFGToTXT(nonterminalS, pathToTXT) - val actualNonterminal = readCFGFromTXT(pathToTXT) - - assertEquals(expected = nonterminalS, actual = actualNonterminal) - assertEquals(expected = nonterminalS.alternatives, actual = actualNonterminal.alternatives) - } - - @Test - fun `'c_analysis_reg4' cfg`() { - val nonterminalS = Nonterminal("S") - val nonterminalA = Nonterminal("A") - val nonterminalB = Nonterminal("B") - - nonterminalS.addAlternative(Alternative(listOf(nonterminalA, nonterminalB))) - - nonterminalA.addAlternative(Alternative(listOf())) - nonterminalA.addAlternative(Alternative(listOf(Terminal("a"), nonterminalA))) - - nonterminalB.addAlternative(Alternative(listOf())) - nonterminalB.addAlternative(Alternative(listOf(Terminal("d"), nonterminalB))) - - val pathToTXT = "src/test/resources/cli/TestCFGReadWriteTXT/c_analysis_reg4.txt" - writeCFGToTXT(nonterminalS, pathToTXT) - val actualNonterminal = readCFGFromTXT(pathToTXT) - - assertEquals(expected = nonterminalS, actual = actualNonterminal) - assertEquals(expected = nonterminalS.alternatives, actual = actualNonterminal.alternatives) - } -} diff --git a/src/test/kotlin/cli/TestGraphReadWriteCSV.kt b/src/test/kotlin/cli/TestGraphReadWriteCSV.kt deleted file mode 100644 index ee9b35966..000000000 --- a/src/test/kotlin/cli/TestGraphReadWriteCSV.kt +++ /dev/null @@ -1,78 +0,0 @@ -package cli - -import org.junit.jupiter.api.Test -import org.kotgll.graph.GraphNode -import org.kotgll.graph.readGraphFromCSV -import org.kotgll.graph.writeGraphToCSV -import kotlin.test.assertEquals - -class TestGraphReadWriteCSV { - @Test - fun `OneEdgeGraph CSV`() { - val graphNode0 = GraphNode(id = 0, isStart = true, isFinal = true) - val graphNode1 = GraphNode(id = 1, isStart = true, isFinal = true) - graphNode0.addEdge("a", graphNode1) - val expectedGraphNodes = listOf(graphNode0, graphNode1) - - val pathToCSV = "src/test/resources/cli/TestGraphReadWriteCSV/OneEdgeGraph.csv" - writeGraphToCSV(ArrayList(expectedGraphNodes), pathToCSV) - val actualGraphNodes = readGraphFromCSV(pathToCSV) - - assertEquals(expected = expectedGraphNodes, actual = actualGraphNodes) - } - - @Test - fun `TwoEdgesGraph CSV`() { - val graphNode0 = GraphNode(id = 0, isStart = true, isFinal = true) - val graphNode1 = GraphNode(id = 1, isStart = true, isFinal = true) - val graphNode2 = GraphNode(id = 2, isStart = true, isFinal = true) - graphNode0.addEdge("a", graphNode1) - graphNode0.addEdge("b", graphNode2) - val expectedGraphNodes = listOf(graphNode0, graphNode1, graphNode2) - - val pathToCSV = "src/test/resources/cli/TestGraphReadWriteCSV/TwoEdgesGraph.csv" - writeGraphToCSV(ArrayList(expectedGraphNodes), pathToCSV) - val actualGraphNodes = readGraphFromCSV(pathToCSV) - - assertEquals(expected = expectedGraphNodes, actual = actualGraphNodes) - } - - @Test - fun `OneCycleGraph CSV`() { - val graphNode0 = GraphNode(id = 0, isStart = true, isFinal = true) - val graphNode1 = GraphNode(id = 1, isStart = true, isFinal = true) - val graphNode2 = GraphNode(id = 2, isStart = true, isFinal = true) - graphNode0.addEdge("a", graphNode1) - graphNode1.addEdge("a", graphNode2) - graphNode2.addEdge("a", graphNode0) - val expectedGraphNodes = listOf(graphNode0, graphNode1, graphNode2) - - val pathToCSV = "src/test/resources/cli/TestGraphReadWriteCSV/OneCycleGraph.csv" - writeGraphToCSV(ArrayList(expectedGraphNodes), pathToCSV) - val actualGraphNodes = readGraphFromCSV(pathToCSV) - - assertEquals(expected = expectedGraphNodes, actual = actualGraphNodes) - } - - @Test - fun `'dyck' two cycles graph CSV`() { - val graphNode0 = GraphNode(id = 0, isStart = true, isFinal = true) - val graphNode1 = GraphNode(id = 1, isStart = true, isFinal = true) - val graphNode2 = GraphNode(id = 2, isStart = true, isFinal = true) - val graphNode3 = GraphNode(id = 3, isStart = true, isFinal = true) - val expectedGraphNodes = listOf(graphNode0, graphNode1, graphNode2, graphNode3) - - graphNode0.addEdge("(", graphNode1) - graphNode1.addEdge("(", graphNode2) - graphNode2.addEdge("(", graphNode0) - - graphNode2.addEdge(")", graphNode3) - graphNode3.addEdge(")", graphNode2) - - val pathToCSV = "src/test/resources/cli/TestGraphReadWriteCSV/dyck.csv" - writeGraphToCSV(ArrayList(expectedGraphNodes), pathToCSV) - val actualGraphNodes = readGraphFromCSV(pathToCSV) - - assertEquals(expected = expectedGraphNodes, actual = actualGraphNodes) - } -} diff --git a/src/test/kotlin/cli/TestRSMReadWriteTXT.kt b/src/test/kotlin/cli/TestRSMReadWriteTXT.kt deleted file mode 100644 index 066c4c645..000000000 --- a/src/test/kotlin/cli/TestRSMReadWriteTXT.kt +++ /dev/null @@ -1,580 +0,0 @@ -package cli - -import org.junit.jupiter.api.Test -import org.kotgll.rsm.grammar.* -import org.kotgll.rsm.grammar.symbol.Nonterminal -import org.kotgll.rsm.grammar.symbol.Terminal -import kotlin.test.assertEquals - -class TestRSMReadWriteTXT { - @Test - fun `'a' rsm`() { - val nonterminalS = Nonterminal("S") - val rsmState0 = RSMState(id = 0, nonterminal = nonterminalS, isStart = true) - val rsmState1 = RSMState(id = 1, nonterminal = nonterminalS, isFinal = true) - - nonterminalS.startState = rsmState0 - - rsmState0.addTerminalEdge(RSMTerminalEdge(terminal = Terminal("a"), head = rsmState1)) - - val pathToTXT = "src/test/resources/cli/TestRSMReadWriteTXT/a.txt" - writeRSMToTXT(rsmState0, pathToTXT) - val actualRSMState = readRSMFromTXT(pathToTXT) - - assertEquals(expected = rsmState0, actual = actualRSMState) - assertEquals( - expected = rsmState0.outgoingTerminalEdges, actual = actualRSMState.outgoingTerminalEdges) - assertEquals( - expected = rsmState0.outgoingNonterminalEdges, - actual = actualRSMState.outgoingNonterminalEdges) - } - - @Test - fun `'a-star' rsm`() { - val nonterminalS = Nonterminal("S") - val rsmState0 = RSMState(id = 0, nonterminal = nonterminalS, isStart = true) - val rsmState1 = RSMState(id = 1, nonterminal = nonterminalS, isFinal = true) - - nonterminalS.startState = rsmState0 - - rsmState0.addTerminalEdge(RSMTerminalEdge(terminal = Terminal("a"), head = rsmState1)) - rsmState1.addTerminalEdge(RSMTerminalEdge(terminal = Terminal("a"), head = rsmState1)) - - val pathToTXT = "src/test/resources/cli/TestRSMReadWriteTXT/a_star.txt" - writeRSMToTXT(rsmState0, pathToTXT) - val actualRSMState = readRSMFromTXT(pathToTXT) - - assertEquals(expected = rsmState0, actual = actualRSMState) - assertEquals( - expected = rsmState0.outgoingTerminalEdges, actual = actualRSMState.outgoingTerminalEdges) - assertEquals( - expected = rsmState0.outgoingNonterminalEdges, - actual = actualRSMState.outgoingNonterminalEdges) - } - - @Test - fun `'dyck' rsm`() { - val nonterminalS = Nonterminal("S") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - isFinal = true, - ) - nonterminalS.startState = rsmState0 - val rsmState1 = - RSMState( - id = 1, - nonterminal = nonterminalS, - ) - val rsmState2 = - RSMState( - id = 2, - nonterminal = nonterminalS, - ) - val rsmState3 = - RSMState( - id = 3, - nonterminal = nonterminalS, - ) - val rsmState4 = - RSMState( - id = 4, - nonterminal = nonterminalS, - isFinal = true, - ) - - rsmState0.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("("), - head = rsmState1, - )) - rsmState1.addNonterminalEdge( - RSMNonterminalEdge( - nonterminal = nonterminalS, - head = rsmState2, - )) - rsmState2.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal(")"), - head = rsmState3, - )) - rsmState3.addNonterminalEdge( - RSMNonterminalEdge( - nonterminal = nonterminalS, - head = rsmState4, - )) - - val pathToTXT = "src/test/resources/cli/TestRSMReadWriteTXT/dyck.txt" - writeRSMToTXT(rsmState0, pathToTXT) - val actualRSMState = readRSMFromTXT(pathToTXT) - - assertEquals(expected = rsmState0, actual = actualRSMState) - assertEquals( - expected = rsmState0.outgoingTerminalEdges, actual = actualRSMState.outgoingTerminalEdges) - assertEquals( - expected = rsmState0.outgoingNonterminalEdges, - actual = actualRSMState.outgoingNonterminalEdges) - } - - @Test - fun `'abc' rsm`() { - val nonterminalS = Nonterminal("S") - val nonterminalA = Nonterminal("A") - val nonterminalB = Nonterminal("B") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - ) - nonterminalS.startState = rsmState0 - val rsmState1 = - RSMState( - id = 1, - nonterminal = nonterminalS, - ) - val rsmState2 = - RSMState( - id = 2, - nonterminal = nonterminalS, - ) - val rsmState3 = - RSMState( - id = 3, - nonterminal = nonterminalS, - isFinal = true, - ) - val rsmState4 = - RSMState( - id = 4, - nonterminal = nonterminalS, - ) - val rsmState5 = - RSMState( - id = 5, - nonterminal = nonterminalS, - isFinal = true, - ) - val rsmState6 = - RSMState( - id = 6, - nonterminal = nonterminalA, - isStart = true, - ) - nonterminalA.startState = rsmState6 - val rsmState7 = - RSMState( - id = 7, - nonterminal = nonterminalA, - ) - val rsmState8 = - RSMState( - id = 8, - nonterminal = nonterminalA, - isFinal = true, - ) - val rsmState9 = - RSMState( - id = 9, - nonterminal = nonterminalB, - isStart = true, - ) - nonterminalB.startState = rsmState9 - val rsmState10 = - RSMState( - id = 10, - nonterminal = nonterminalB, - isFinal = true, - ) - - rsmState0.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("a"), - head = rsmState1, - )) - rsmState1.addNonterminalEdge( - RSMNonterminalEdge( - nonterminal = nonterminalB, - head = rsmState2, - )) - rsmState2.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("c"), - head = rsmState3, - )) - rsmState0.addNonterminalEdge( - RSMNonterminalEdge( - nonterminal = nonterminalA, - head = rsmState4, - )) - rsmState4.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("c"), - head = rsmState5, - )) - - rsmState6.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("a"), - head = rsmState7, - )) - rsmState7.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("b"), - head = rsmState8, - )) - - rsmState9.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("b"), - head = rsmState10, - )) - - val pathToTXT = "src/test/resources/cli/TestRSMReadWriteTXT/abc.txt" - writeRSMToTXT(rsmState0, pathToTXT) - val actualRSMState = readRSMFromTXT(pathToTXT) - - assertEquals(expected = rsmState0, actual = actualRSMState) - assertEquals( - expected = rsmState0.outgoingTerminalEdges, actual = actualRSMState.outgoingTerminalEdges) - assertEquals( - expected = rsmState0.outgoingNonterminalEdges, - actual = actualRSMState.outgoingNonterminalEdges) - } - - @Test - fun `'g1' rsm`() { - val nonterminalS = Nonterminal("S") - val rsmState0 = RSMState(id = 0, nonterminal = nonterminalS, isStart = true) - val rsmState1 = RSMState(id = 1, nonterminal = nonterminalS) - val rsmState2 = RSMState(id = 2, nonterminal = nonterminalS) - val rsmState3 = RSMState(id = 3, nonterminal = nonterminalS, isFinal = true) - val rsmState4 = RSMState(id = 4, nonterminal = nonterminalS) - val rsmState5 = RSMState(id = 5, nonterminal = nonterminalS) - - nonterminalS.startState = rsmState0 - - rsmState0.addTerminalEdge( - RSMTerminalEdge(terminal = Terminal("subClassOf_r"), head = rsmState1)) - rsmState1.addNonterminalEdge(RSMNonterminalEdge(nonterminal = nonterminalS, head = rsmState2)) - rsmState2.addTerminalEdge(RSMTerminalEdge(terminal = Terminal("subClassOf"), head = rsmState3)) - - rsmState1.addTerminalEdge(RSMTerminalEdge(terminal = Terminal("subClassOf"), head = rsmState3)) - - rsmState0.addTerminalEdge(RSMTerminalEdge(terminal = Terminal("type_r"), head = rsmState4)) - rsmState4.addNonterminalEdge(RSMNonterminalEdge(nonterminal = nonterminalS, head = rsmState5)) - rsmState5.addTerminalEdge(RSMTerminalEdge(terminal = Terminal("type"), head = rsmState3)) - - rsmState4.addTerminalEdge(RSMTerminalEdge(terminal = Terminal("type"), head = rsmState3)) - - val pathToTXT = "src/test/resources/cli/TestRSMReadWriteTXT/g1.txt" - writeRSMToTXT(rsmState0, pathToTXT) - val actualRSMState = readRSMFromTXT(pathToTXT) - - assertEquals(expected = rsmState0, actual = actualRSMState) - assertEquals( - expected = rsmState0.outgoingTerminalEdges, actual = actualRSMState.outgoingTerminalEdges) - assertEquals( - expected = rsmState0.outgoingNonterminalEdges, - actual = actualRSMState.outgoingNonterminalEdges) - } - - @Test - fun `'g2' rsm`() { - val nonterminalS = Nonterminal("S") - val rsmState0 = RSMState(id = 0, nonterminal = nonterminalS, isStart = true) - val rsmState1 = RSMState(id = 1, nonterminal = nonterminalS) - val rsmState2 = RSMState(id = 2, nonterminal = nonterminalS) - val rsmState3 = RSMState(id = 3, nonterminal = nonterminalS, isFinal = true) - - nonterminalS.startState = rsmState0 - - rsmState0.addTerminalEdge( - RSMTerminalEdge(terminal = Terminal("subClassOf_r"), head = rsmState1)) - rsmState1.addNonterminalEdge(RSMNonterminalEdge(nonterminal = nonterminalS, head = rsmState2)) - rsmState2.addTerminalEdge(RSMTerminalEdge(terminal = Terminal("subClassOf"), head = rsmState3)) - - rsmState0.addTerminalEdge(RSMTerminalEdge(terminal = Terminal("subClassOf"), head = rsmState3)) - - val pathToTXT = "src/test/resources/cli/TestRSMReadWriteTXT/g2.txt" - writeRSMToTXT(rsmState0, pathToTXT) - val actualRSMState = readRSMFromTXT(pathToTXT) - - assertEquals(expected = rsmState0, actual = actualRSMState) - assertEquals( - expected = rsmState0.outgoingTerminalEdges, actual = actualRSMState.outgoingTerminalEdges) - assertEquals( - expected = rsmState0.outgoingNonterminalEdges, - actual = actualRSMState.outgoingNonterminalEdges) - } - - @Test - fun `'geo' rsm`() { - val nonterminalS = Nonterminal("S") - val rsmState0 = RSMState(id = 0, nonterminal = nonterminalS, isStart = true) - val rsmState1 = RSMState(id = 1, nonterminal = nonterminalS) - val rsmState2 = RSMState(id = 2, nonterminal = nonterminalS) - val rsmState3 = RSMState(id = 3, nonterminal = nonterminalS, isFinal = true) - - nonterminalS.startState = rsmState0 - - rsmState0.addTerminalEdge( - RSMTerminalEdge(terminal = Terminal("broaderTransitive"), head = rsmState1)) - rsmState1.addNonterminalEdge(RSMNonterminalEdge(nonterminal = nonterminalS, head = rsmState2)) - rsmState2.addTerminalEdge( - RSMTerminalEdge(terminal = Terminal("broaderTransitive_r"), head = rsmState3)) - - rsmState1.addTerminalEdge( - RSMTerminalEdge(terminal = Terminal("broaderTransitive_r"), head = rsmState3)) - - val pathToTXT = "src/test/resources/cli/TestRSMReadWriteTXT/geo.txt" - writeRSMToTXT(rsmState0, pathToTXT) - val actualRSMState = readRSMFromTXT(pathToTXT) - - assertEquals(expected = rsmState0, actual = actualRSMState) - assertEquals( - expected = rsmState0.outgoingTerminalEdges, actual = actualRSMState.outgoingTerminalEdges) - assertEquals( - expected = rsmState0.outgoingNonterminalEdges, - actual = actualRSMState.outgoingNonterminalEdges) - } - - @Test - fun `'c_analysis' rsm`() { - val nonterminalS = Nonterminal("S") - val nonterminalV = Nonterminal("V") - val rsmState0 = RSMState(id = 0, nonterminal = nonterminalS, isStart = true) - val rsmState1 = RSMState(id = 1, nonterminal = nonterminalS) - val rsmState2 = RSMState(id = 2, nonterminal = nonterminalS) - val rsmState3 = RSMState(id = 3, nonterminal = nonterminalS, isFinal = true) - - nonterminalS.startState = rsmState0 - - val rsmState4 = RSMState(id = 4, nonterminal = nonterminalV, isStart = true, isFinal = true) - val rsmState5 = RSMState(id = 5, nonterminal = nonterminalV) - val rsmState6 = RSMState(id = 6, nonterminal = nonterminalV, isFinal = true) - val rsmState7 = RSMState(id = 7, nonterminal = nonterminalV, isFinal = true) - val rsmState8 = RSMState(id = 8, nonterminal = nonterminalV, isFinal = true) - val rsmState9 = RSMState(id = 9, nonterminal = nonterminalV, isFinal = true) - - nonterminalV.startState = rsmState4 - - rsmState0.addTerminalEdge(RSMTerminalEdge(terminal = Terminal("d_r"), head = rsmState1)) - rsmState1.addNonterminalEdge(RSMNonterminalEdge(nonterminal = nonterminalV, head = rsmState2)) - rsmState2.addTerminalEdge(RSMTerminalEdge(terminal = Terminal("d"), head = rsmState3)) - - rsmState4.addTerminalEdge(RSMTerminalEdge(terminal = Terminal("a_r"), head = rsmState6)) - rsmState4.addTerminalEdge(RSMTerminalEdge(terminal = Terminal("a"), head = rsmState8)) - rsmState4.addNonterminalEdge(RSMNonterminalEdge(nonterminal = nonterminalS, head = rsmState5)) - rsmState4.addNonterminalEdge(RSMNonterminalEdge(nonterminal = nonterminalS, head = rsmState7)) - - rsmState5.addTerminalEdge(RSMTerminalEdge(terminal = Terminal("a_r"), head = rsmState6)) - - rsmState6.addTerminalEdge(RSMTerminalEdge(terminal = Terminal("a"), head = rsmState8)) - rsmState6.addTerminalEdge(RSMTerminalEdge(terminal = Terminal("a_r"), head = rsmState6)) - rsmState6.addNonterminalEdge(RSMNonterminalEdge(nonterminal = nonterminalS, head = rsmState5)) - rsmState6.addNonterminalEdge(RSMNonterminalEdge(nonterminal = nonterminalS, head = rsmState7)) - - rsmState7.addTerminalEdge(RSMTerminalEdge(terminal = Terminal("a"), head = rsmState8)) - - rsmState8.addTerminalEdge(RSMTerminalEdge(terminal = Terminal("a"), head = rsmState8)) - rsmState8.addNonterminalEdge(RSMNonterminalEdge(nonterminal = nonterminalS, head = rsmState9)) - - rsmState9.addTerminalEdge(RSMTerminalEdge(terminal = Terminal("a"), head = rsmState8)) - - val pathToTXT = "src/test/resources/cli/TestRSMReadWriteTXT/c_analysis.txt" - writeRSMToTXT(rsmState0, pathToTXT) - val actualRSMState = readRSMFromTXT(pathToTXT) - - assertEquals(expected = rsmState0, actual = actualRSMState) - assertEquals( - expected = rsmState0.outgoingTerminalEdges, actual = actualRSMState.outgoingTerminalEdges) - assertEquals( - expected = rsmState0.outgoingNonterminalEdges, - actual = actualRSMState.outgoingNonterminalEdges) - } - - @Test - fun `'rdf_reg1' rsm`() { - val nonterminalS = Nonterminal("S") - val rsmState0 = RSMState(id = 0, nonterminal = nonterminalS, isStart = true, isFinal = true) - - nonterminalS.startState = rsmState0 - - rsmState0.addTerminalEdge(RSMTerminalEdge(terminal = Terminal("type"), head = rsmState0)) - - val pathToTXT = "src/test/resources/cli/TestRSMReadWriteTXT/rdf_reg1.txt" - writeRSMToTXT(rsmState0, pathToTXT) - val actualRSMState = readRSMFromTXT(pathToTXT) - - assertEquals(expected = rsmState0, actual = actualRSMState) - assertEquals( - expected = rsmState0.outgoingTerminalEdges, actual = actualRSMState.outgoingTerminalEdges) - assertEquals( - expected = rsmState0.outgoingNonterminalEdges, - actual = actualRSMState.outgoingNonterminalEdges) - } - - @Test - fun `'rdf_reg2' rsm`() { - val nonterminalS = Nonterminal("S") - val rsmState0 = RSMState(id = 0, nonterminal = nonterminalS, isStart = true) - val rsmState1 = RSMState(id = 1, nonterminal = nonterminalS, isFinal = true) - - nonterminalS.startState = rsmState0 - - rsmState0.addTerminalEdge(RSMTerminalEdge(terminal = Terminal("type"), head = rsmState1)) - rsmState1.addTerminalEdge(RSMTerminalEdge(terminal = Terminal("subClassOf"), head = rsmState1)) - - val pathToTXT = "src/test/resources/cli/TestRSMReadWriteTXT/rdf_reg2.txt" - writeRSMToTXT(rsmState0, pathToTXT) - val actualRSMState = readRSMFromTXT(pathToTXT) - - assertEquals(expected = rsmState0, actual = actualRSMState) - assertEquals( - expected = rsmState0.outgoingTerminalEdges, actual = actualRSMState.outgoingTerminalEdges) - assertEquals( - expected = rsmState0.outgoingNonterminalEdges, - actual = actualRSMState.outgoingNonterminalEdges) - } - - @Test - fun `'rdf_reg3' rsm`() { - val nonterminalS = Nonterminal("S") - val rsmState0 = RSMState(id = 0, nonterminal = nonterminalS, isStart = true, isFinal = true) - - nonterminalS.startState = rsmState0 - - rsmState0.addTerminalEdge(RSMTerminalEdge(terminal = Terminal("type"), head = rsmState0)) - rsmState0.addTerminalEdge(RSMTerminalEdge(terminal = Terminal("subClassOf"), head = rsmState0)) - - val pathToTXT = "src/test/resources/cli/TestRSMReadWriteTXT/rdf_reg3.txt" - writeRSMToTXT(rsmState0, pathToTXT) - val actualRSMState = readRSMFromTXT(pathToTXT) - - assertEquals(expected = rsmState0, actual = actualRSMState) - assertEquals( - expected = rsmState0.outgoingTerminalEdges, actual = actualRSMState.outgoingTerminalEdges) - assertEquals( - expected = rsmState0.outgoingNonterminalEdges, - actual = actualRSMState.outgoingNonterminalEdges) - } - - @Test - fun `'rdf_reg4' rsm`() { - val nonterminalS = Nonterminal("S") - val rsmState0 = RSMState(id = 0, nonterminal = nonterminalS, isStart = true, isFinal = true) - val rsmState1 = RSMState(id = 1, nonterminal = nonterminalS, isFinal = true) - - nonterminalS.startState = rsmState0 - - rsmState0.addTerminalEdge(RSMTerminalEdge(terminal = Terminal("type"), head = rsmState0)) - rsmState0.addTerminalEdge(RSMTerminalEdge(terminal = Terminal("subClassOf"), head = rsmState1)) - - rsmState1.addTerminalEdge(RSMTerminalEdge(terminal = Terminal("subClassOf"), head = rsmState1)) - - val pathToTXT = "src/test/resources/cli/TestRSMReadWriteTXT/rdf_reg4.txt" - writeRSMToTXT(rsmState0, pathToTXT) - val actualRSMState = readRSMFromTXT(pathToTXT) - - assertEquals(expected = rsmState0, actual = actualRSMState) - assertEquals( - expected = rsmState0.outgoingTerminalEdges, actual = actualRSMState.outgoingTerminalEdges) - assertEquals( - expected = rsmState0.outgoingNonterminalEdges, - actual = actualRSMState.outgoingNonterminalEdges) - } - - @Test - fun `'c_analysis_reg1' rsm`() { - val nonterminalS = Nonterminal("S") - val rsmState0 = RSMState(id = 0, nonterminal = nonterminalS, isStart = true, isFinal = true) - - nonterminalS.startState = rsmState0 - - rsmState0.addTerminalEdge(RSMTerminalEdge(terminal = Terminal("a"), head = rsmState0)) - - val pathToTXT = "src/test/resources/cli/TestRSMReadWriteTXT/c_analysis_reg1.txt" - writeRSMToTXT(rsmState0, pathToTXT) - val actualRSMState = readRSMFromTXT(pathToTXT) - - assertEquals(expected = rsmState0, actual = actualRSMState) - assertEquals( - expected = rsmState0.outgoingTerminalEdges, actual = actualRSMState.outgoingTerminalEdges) - assertEquals( - expected = rsmState0.outgoingNonterminalEdges, - actual = actualRSMState.outgoingNonterminalEdges) - } - - @Test - fun `'c_analysis_reg2' rsm`() { - val nonterminalS = Nonterminal("S") - val rsmState0 = RSMState(id = 0, nonterminal = nonterminalS, isStart = true) - val rsmState1 = RSMState(id = 1, nonterminal = nonterminalS, isFinal = true) - - nonterminalS.startState = rsmState0 - - rsmState0.addTerminalEdge(RSMTerminalEdge(terminal = Terminal("a"), head = rsmState1)) - rsmState1.addTerminalEdge(RSMTerminalEdge(terminal = Terminal("d"), head = rsmState1)) - - val pathToTXT = "src/test/resources/cli/TestRSMReadWriteTXT/c_analysis_reg2.txt" - writeRSMToTXT(rsmState0, pathToTXT) - val actualRSMState = readRSMFromTXT(pathToTXT) - - assertEquals(expected = rsmState0, actual = actualRSMState) - assertEquals( - expected = rsmState0.outgoingTerminalEdges, actual = actualRSMState.outgoingTerminalEdges) - assertEquals( - expected = rsmState0.outgoingNonterminalEdges, - actual = actualRSMState.outgoingNonterminalEdges) - } - - @Test - fun `'c_analysis_reg3' rsm`() { - val nonterminalS = Nonterminal("S") - val rsmState0 = RSMState(id = 0, nonterminal = nonterminalS, isStart = true, isFinal = true) - - nonterminalS.startState = rsmState0 - - rsmState0.addTerminalEdge(RSMTerminalEdge(terminal = Terminal("a"), head = rsmState0)) - rsmState0.addTerminalEdge(RSMTerminalEdge(terminal = Terminal("d"), head = rsmState0)) - - val pathToTXT = "src/test/resources/cli/TestRSMReadWriteTXT/c_analysis_reg3.txt" - writeRSMToTXT(rsmState0, pathToTXT) - val actualRSMState = readRSMFromTXT(pathToTXT) - - assertEquals(expected = rsmState0, actual = actualRSMState) - assertEquals( - expected = rsmState0.outgoingTerminalEdges, actual = actualRSMState.outgoingTerminalEdges) - assertEquals( - expected = rsmState0.outgoingNonterminalEdges, - actual = actualRSMState.outgoingNonterminalEdges) - } - - @Test - fun `'c_analysis_reg4' rsm`() { - val nonterminalS = Nonterminal("S") - val rsmState0 = RSMState(id = 0, nonterminal = nonterminalS, isStart = true, isFinal = true) - val rsmState1 = RSMState(id = 1, nonterminal = nonterminalS, isFinal = true) - - nonterminalS.startState = rsmState0 - - rsmState0.addTerminalEdge(RSMTerminalEdge(terminal = Terminal("a"), head = rsmState0)) - rsmState0.addTerminalEdge(RSMTerminalEdge(terminal = Terminal("d"), head = rsmState1)) - - rsmState1.addTerminalEdge(RSMTerminalEdge(terminal = Terminal("d"), head = rsmState1)) - - val pathToTXT = "src/test/resources/cli/TestRSMReadWriteTXT/c_analysis_reg4.txt" - writeRSMToTXT(rsmState0, pathToTXT) - val actualRSMState = readRSMFromTXT(pathToTXT) - - assertEquals(expected = rsmState0, actual = actualRSMState) - assertEquals( - expected = rsmState0.outgoingTerminalEdges, actual = actualRSMState.outgoingTerminalEdges) - assertEquals( - expected = rsmState0.outgoingNonterminalEdges, - actual = actualRSMState.outgoingNonterminalEdges) - } -} diff --git a/src/test/kotlin/rsm/graphinput/withoutsppf/TestRSMGraphInputWithoutSPPFFail.kt b/src/test/kotlin/rsm/graphinput/withoutsppf/TestRSMGraphInputWithoutSPPFFail.kt deleted file mode 100644 index a2752c8f2..000000000 --- a/src/test/kotlin/rsm/graphinput/withoutsppf/TestRSMGraphInputWithoutSPPFFail.kt +++ /dev/null @@ -1,846 +0,0 @@ -package rsm.graphinput.withoutsppf - -import org.junit.jupiter.api.Test -import org.junit.jupiter.params.ParameterizedTest -import org.junit.jupiter.params.provider.ValueSource -import org.kotgll.graph.GraphNode -import org.kotgll.graph.readGraphFromString -import org.kotgll.rsm.grammar.RSMNonterminalEdge -import org.kotgll.rsm.grammar.RSMState -import org.kotgll.rsm.grammar.RSMTerminalEdge -import org.kotgll.rsm.grammar.symbol.Nonterminal -import org.kotgll.rsm.grammar.symbol.Terminal -import org.kotgll.rsm.graphinput.withoutsppf.GLL -import kotlin.test.assertEquals - -class TestRSMGraphInputWithoutSPPFFail { - @Test - fun `test 'empty' hand-crafted grammar`() { - val nonterminalS = Nonterminal("S") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - isFinal = true, - ) - nonterminalS.startState = rsmState0 - - val graph = GraphNode(id = 0, isStart = true) - - assertEquals( - expected = hashMapOf(), - actual = GLL(rsmState0, listOf(graph)).parse(), - ) - } - - @ParameterizedTest(name = "Should be Empty for {0}") - @ValueSource(strings = ["", "b", "bb", "ab", "aa"]) - fun `test 'a' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - ) - nonterminalS.startState = rsmState0 - rsmState0.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("a"), - head = - RSMState( - id = 1, - nonterminal = nonterminalS, - isFinal = true, - ))) - - assertEquals( - expected = hashMapOf(), - actual = GLL(rsmState0, listOf(readGraphFromString(input))).parse(), - ) - } - - @ParameterizedTest(name = "Should be Empty for {0}") - @ValueSource(strings = ["", "a", "b", "aba", "ababa", "aa", "b", "bb", "c", "cc"]) - fun `test 'ab' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - ) - nonterminalS.startState = rsmState0 - val rsmState1 = - RSMState( - id = 1, - nonterminal = nonterminalS, - ) - rsmState0.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("a"), - head = rsmState1, - )) - rsmState1.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("b"), - head = - RSMState( - id = 2, - nonterminal = nonterminalS, - isFinal = true, - ))) - - assertEquals( - expected = hashMapOf(), - actual = GLL(rsmState0, listOf(readGraphFromString(input))).parse(), - ) - } - - @ParameterizedTest(name = "Should be Empty for {0}") - @ValueSource(strings = ["b", "bb", "c", "cc", "ab", "ac"]) - fun `test 'a-star' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - isFinal = true, - ) - nonterminalS.startState = rsmState0 - val rsmState1 = - RSMState( - id = 1, - nonterminal = nonterminalS, - isFinal = true, - ) - rsmState0.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("a"), - head = rsmState1, - )) - rsmState1.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("a"), - head = rsmState1, - )) - - assertEquals( - expected = hashMapOf(), - actual = GLL(rsmState0, listOf(readGraphFromString(input))).parse(), - ) - } - - @ParameterizedTest(name = "Should be Empty for {0}") - @ValueSource(strings = ["", "b", "bb", "c", "cc", "ab", "ac"]) - fun `test 'a-plus' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - ) - nonterminalS.startState = rsmState0 - val rsmState1 = - RSMState( - id = 1, - nonterminal = nonterminalS, - isFinal = true, - ) - rsmState0.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("a"), - head = rsmState1, - )) - rsmState1.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("a"), - head = rsmState1, - )) - - assertEquals( - expected = hashMapOf(), - actual = GLL(rsmState0, listOf(readGraphFromString(input))).parse(), - ) - } - - @ParameterizedTest(name = "Should be Empty for {0}") - @ValueSource( - strings = - [ - "abaa", - "abba", - "abca", - "ababaa", - "ababba", - "ababca", - "abbb", - "abcb", - "ababbb", - "ababcb", - "abac", - "abbc", - "abcc", - "ababac", - "ababbc", - "ababcc", - ]) - fun `test '(ab)-star' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - isFinal = true, - ) - nonterminalS.startState = rsmState0 - val rsmState1 = - RSMState( - id = 1, - nonterminal = nonterminalS, - isFinal = true, - ) - rsmState0.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("ab"), - head = rsmState1, - )) - rsmState1.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("ab"), - head = rsmState1, - )) - - val graph = GraphNode(id = 0, isStart = true) - var cur = graph - var i = 0 - while (i < input.length) { - val head = GraphNode(id = i + 1) - cur.addEdge("" + input[i] + input[i + 1], head) - cur = head - i += 2 - } - cur.isFinal = true - - assertEquals( - expected = hashMapOf(), - actual = GLL(rsmState0, listOf(graph)).parse(), - ) - } - - @ParameterizedTest(name = "Should be Empty for {0}") - @ValueSource( - strings = - [ - "(", - ")", - "((", - "))", - "()(", - "()()(", - "()()()(", - "())", - "()())", - "()()())", - "(())(", - "(())()(", - "(())()()(", - "(()))", - "(())())", - "(())()())", - "(())(())(", - "(())(())()(", - "(())(())()()(", - "(())(()))", - "(())(())())", - "(())(())()())", - "(()())(()())(", - "(()())(()()))", - ]) - fun `test 'dyck' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - isFinal = true, - ) - nonterminalS.startState = rsmState0 - val rsmState1 = - RSMState( - id = 1, - nonterminal = nonterminalS, - ) - val rsmState2 = - RSMState( - id = 2, - nonterminal = nonterminalS, - ) - val rsmState3 = - RSMState( - id = 3, - nonterminal = nonterminalS, - ) - val rsmState4 = - RSMState( - id = 4, - nonterminal = nonterminalS, - isFinal = true, - ) - - rsmState0.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("("), - head = rsmState1, - )) - rsmState1.addNonterminalEdge( - RSMNonterminalEdge( - nonterminal = nonterminalS, - head = rsmState2, - )) - rsmState2.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal(")"), - head = rsmState3, - )) - rsmState3.addNonterminalEdge( - RSMNonterminalEdge( - nonterminal = nonterminalS, - head = rsmState4, - )) - - assertEquals( - expected = hashMapOf(), - actual = GLL(rsmState0, listOf(readGraphFromString(input))).parse(), - ) - } - - @ParameterizedTest(name = "Should be Empty for {0}") - @ValueSource( - strings = - [ - "", - "a", - "b", - "c", - "d", - "aa", - "ac", - "ad", - "ba", - "bb", - "bc", - "bd", - "ca", - "cb", - "cc", - "da", - "db", - "dc", - "dd", - ]) - fun `test 'ab or cd' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - ) - nonterminalS.startState = rsmState0 - val rsmState1 = - RSMState( - id = 1, - nonterminal = nonterminalS, - isFinal = true, - ) - val rsmState2 = - RSMState( - id = 2, - nonterminal = nonterminalS, - isFinal = true, - ) - - rsmState0.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("ab"), - head = rsmState1, - )) - rsmState0.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("cd"), - head = rsmState2, - )) - - val graph = GraphNode(id = 0, isStart = true) - graph.addEdge(input, GraphNode(id = 1, isFinal = true)) - - assertEquals(expected = hashMapOf(), actual = GLL(rsmState0, listOf(graph)).parse()) - } - - @ParameterizedTest(name = "Should be Empty for {0}") - @ValueSource(strings = ["b", "bb", "ab"]) - fun `test 'a-optional' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - isFinal = true, - ) - nonterminalS.startState = rsmState0 - val rsmState1 = - RSMState( - id = 1, - nonterminal = nonterminalS, - isFinal = true, - ) - - rsmState0.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("a"), - head = rsmState1, - )) - - assertEquals( - expected = hashMapOf(), actual = GLL(rsmState0, listOf(readGraphFromString(input))).parse()) - } - - @ParameterizedTest(name = "Should be Empty for {0}") - @ValueSource(strings = ["", "a", "b", "c", "ab", "ac", "abb", "bc", "abcd"]) - fun `test 'abc' ambiguous hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - val nonterminalA = Nonterminal("A") - val nonterminalB = Nonterminal("B") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - ) - nonterminalS.startState = rsmState0 - val rsmState1 = - RSMState( - id = 1, - nonterminal = nonterminalS, - ) - val rsmState2 = - RSMState( - id = 2, - nonterminal = nonterminalS, - ) - val rsmState3 = - RSMState( - id = 3, - nonterminal = nonterminalS, - isFinal = true, - ) - val rsmState4 = - RSMState( - id = 4, - nonterminal = nonterminalS, - ) - val rsmState5 = - RSMState( - id = 5, - nonterminal = nonterminalS, - isFinal = true, - ) - val rsmState6 = - RSMState( - id = 6, - nonterminal = nonterminalA, - isStart = true, - ) - nonterminalA.startState = rsmState6 - val rsmState7 = - RSMState( - id = 7, - nonterminal = nonterminalA, - ) - val rsmState8 = - RSMState( - id = 8, - nonterminal = nonterminalA, - isFinal = true, - ) - val rsmState9 = - RSMState( - id = 9, - nonterminal = nonterminalB, - isStart = true, - ) - nonterminalB.startState = rsmState9 - val rsmState10 = - RSMState( - id = 10, - nonterminal = nonterminalB, - isFinal = true, - ) - - rsmState0.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("a"), - head = rsmState1, - )) - rsmState1.addNonterminalEdge( - RSMNonterminalEdge( - nonterminal = nonterminalB, - head = rsmState2, - )) - rsmState2.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("c"), - head = rsmState3, - )) - rsmState0.addNonterminalEdge( - RSMNonterminalEdge( - nonterminal = nonterminalA, - head = rsmState4, - )) - rsmState4.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("c"), - head = rsmState5, - )) - - rsmState6.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("a"), - head = rsmState7, - )) - rsmState7.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("b"), - head = rsmState8, - )) - - rsmState9.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("b"), - head = rsmState10, - )) - - assertEquals( - expected = hashMapOf(), actual = GLL(rsmState0, listOf(readGraphFromString(input))).parse()) - } - - @ParameterizedTest(name = "Should be Empty for {0}") - @ValueSource( - strings = - [ - "", - "a", - "b", - "c", - "d", - "aa", - "ac", - "ad", - "ba", - "bb", - "bc", - "bd", - "ca", - "cb", - "cc", - "da", - "db", - "dc", - "dd", - ]) - fun `test 'ab or cd' ambiguous hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - val nonterminalA = Nonterminal("A") - val nonterminalB = Nonterminal("B") - - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - ) - nonterminalS.startState = rsmState0 - val rsmState1 = - RSMState( - id = 1, - nonterminal = nonterminalS, - isFinal = true, - ) - val rsmState2 = - RSMState( - id = 2, - nonterminal = nonterminalS, - isFinal = true, - ) - val rsmState3 = - RSMState( - id = 3, - nonterminal = nonterminalA, - isStart = true, - ) - nonterminalA.startState = rsmState3 - val rsmState4 = - RSMState( - id = 4, - nonterminal = nonterminalA, - isFinal = true, - ) - val rsmState5 = - RSMState( - id = 5, - nonterminal = nonterminalA, - isFinal = true, - ) - val rsmState6 = - RSMState( - id = 6, - nonterminal = nonterminalB, - isStart = true, - ) - nonterminalB.startState = rsmState6 - val rsmState7 = RSMState(id = 7, nonterminal = nonterminalB, isFinal = true) - val rsmState8 = - RSMState( - id = 8, - nonterminal = nonterminalB, - isFinal = true, - ) - - rsmState0.addNonterminalEdge( - RSMNonterminalEdge( - nonterminal = nonterminalA, - head = rsmState1, - )) - rsmState0.addNonterminalEdge( - RSMNonterminalEdge( - nonterminal = nonterminalB, - head = rsmState2, - )) - rsmState3.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("ab"), - head = rsmState4, - )) - rsmState3.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("cd"), - head = rsmState5, - )) - rsmState6.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("ab"), - head = rsmState7, - )) - rsmState6.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("cd"), - head = rsmState8, - )) - - val graphNode0 = - GraphNode( - id = 0, - isStart = true, - ) - val graphNode1 = - GraphNode( - id = 1, - isFinal = true, - ) - - graphNode0.addEdge(input, graphNode1) - - assertEquals(expected = hashMapOf(), actual = GLL(rsmState0, listOf(graphNode0)).parse()) - } - - @Test - fun `test 'dyck' hand-crafted grammar two cycle graph`() { - val nonterminalS = Nonterminal("S") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - isFinal = true, - ) - nonterminalS.startState = rsmState0 - val rsmState1 = - RSMState( - id = 1, - nonterminal = nonterminalS, - ) - val rsmState2 = - RSMState( - id = 2, - nonterminal = nonterminalS, - ) - val rsmState3 = - RSMState( - id = 3, - nonterminal = nonterminalS, - ) - val rsmState4 = - RSMState( - id = 4, - nonterminal = nonterminalS, - isFinal = true, - ) - - rsmState0.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("("), - head = rsmState1, - )) - rsmState1.addNonterminalEdge( - RSMNonterminalEdge( - nonterminal = nonterminalS, - head = rsmState2, - )) - rsmState2.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal(")"), - head = rsmState3, - )) - rsmState3.addNonterminalEdge( - RSMNonterminalEdge( - nonterminal = nonterminalS, - head = rsmState4, - )) - - val graphNode0 = GraphNode(id = 0, isStart = true, isFinal = true) - val graphNode1 = GraphNode(id = 1, isStart = true, isFinal = true) - val graphNode2 = GraphNode(id = 2, isStart = true, isFinal = true) - val graphNode3 = GraphNode(id = 3, isStart = true) - - graphNode0.addEdge("(", graphNode1) - graphNode1.addEdge("(", graphNode2) - graphNode2.addEdge("(", graphNode0) - - graphNode2.addEdge(")", graphNode3) - graphNode3.addEdge(")", graphNode2) - - assertEquals(expected = hashMapOf(), actual = GLL(rsmState0, listOf(graphNode3)).parse()) - } - - @Test - fun `test 'a-plus' hand-crafted grammar one cycle graph`() { - val nonterminalS = Nonterminal("S") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - ) - nonterminalS.startState = rsmState0 - val rsmState1 = - RSMState( - id = 1, - nonterminal = nonterminalS, - isFinal = true, - ) - val rsmState2 = - RSMState( - id = 2, - nonterminal = nonterminalS, - isFinal = true, - ) - - rsmState0.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("a"), - head = rsmState1, - )) - rsmState1.addNonterminalEdge( - RSMNonterminalEdge( - nonterminal = nonterminalS, - head = rsmState2, - )) - - val graphNode0 = GraphNode(id = 0, isStart = true, isFinal = true) - val graphNode1 = GraphNode(id = 1, isStart = true) - - graphNode0.addEdge("a", graphNode1) - graphNode1.addEdge("a", graphNode1) - - assertEquals(expected = hashMapOf(), actual = GLL(rsmState0, listOf(graphNode0)).parse()) - assertEquals(expected = hashMapOf(), actual = GLL(rsmState0, listOf(graphNode1)).parse()) - } - - @Test - fun `test 'a-star' hand-crafted grammar one cycle graph`() { - val nonterminalS = Nonterminal("S") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - isFinal = true, - ) - nonterminalS.startState = rsmState0 - - rsmState0.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("a"), - head = rsmState0, - )) - - val graphNode0 = GraphNode(id = 0, isStart = true) - val graphNode1 = GraphNode(id = 1, isStart = true) - - graphNode0.addEdge("a", graphNode1) - graphNode1.addEdge("a", graphNode1) - - assertEquals(expected = hashMapOf(), actual = GLL(rsmState0, listOf(graphNode0)).parse()) - assertEquals(expected = hashMapOf(), actual = GLL(rsmState0, listOf(graphNode1)).parse()) - } - - @Test - fun `test 'g1' hand-crafted grammar two cycle graph`() { - val nonterminalS = Nonterminal("S") - val rsmState0 = RSMState(id = 0, nonterminal = nonterminalS, isStart = true) - val rsmState1 = RSMState(id = 1, nonterminal = nonterminalS) - val rsmState2 = RSMState(id = 2, nonterminal = nonterminalS) - val rsmState3 = RSMState(id = 3, nonterminal = nonterminalS, isFinal = true) - val rsmState4 = RSMState(id = 4, nonterminal = nonterminalS) - val rsmState5 = RSMState(id = 5, nonterminal = nonterminalS) - val rsmState6 = RSMState(id = 6, nonterminal = nonterminalS, isFinal = true) - - nonterminalS.startState = rsmState0 - - rsmState0.addTerminalEdge( - RSMTerminalEdge(terminal = Terminal("subClassOf_r"), head = rsmState1)) - rsmState1.addNonterminalEdge(RSMNonterminalEdge(nonterminal = nonterminalS, head = rsmState2)) - rsmState2.addTerminalEdge(RSMTerminalEdge(terminal = Terminal("subClassOf"), head = rsmState3)) - - rsmState1.addTerminalEdge(RSMTerminalEdge(terminal = Terminal("subClassOf"), head = rsmState3)) - - rsmState0.addTerminalEdge(RSMTerminalEdge(terminal = Terminal("type_r"), head = rsmState4)) - rsmState4.addNonterminalEdge(RSMNonterminalEdge(nonterminal = nonterminalS, head = rsmState5)) - rsmState5.addTerminalEdge(RSMTerminalEdge(terminal = Terminal("type"), head = rsmState6)) - - rsmState4.addTerminalEdge(RSMTerminalEdge(terminal = Terminal("subClassOf"), head = rsmState6)) - - val graphNode0 = GraphNode(id = 0, isStart = true, isFinal = true) - val graphNode1 = GraphNode(id = 1, isStart = true, isFinal = true) - val graphNode2 = GraphNode(id = 2, isStart = true) - val graphNode3 = GraphNode(id = 3, isStart = true) - - graphNode0.addEdge("subClassOf_r", graphNode1) - graphNode1.addEdge("subClassOf_r", graphNode2) - graphNode2.addEdge("subClassOf_r", graphNode0) - - graphNode2.addEdge("subClassOf", graphNode3) - graphNode3.addEdge("subClassOf", graphNode2) - - assertEquals( - expected = hashMapOf(), - actual = GLL(rsmState0, listOf(graphNode0, graphNode1, graphNode2, graphNode3)).parse()) - } -} diff --git a/src/test/kotlin/rsm/graphinput/withoutsppf/TestRSMGraphInputWithoutSPPFSuccess.kt b/src/test/kotlin/rsm/graphinput/withoutsppf/TestRSMGraphInputWithoutSPPFSuccess.kt deleted file mode 100644 index 3610404b5..000000000 --- a/src/test/kotlin/rsm/graphinput/withoutsppf/TestRSMGraphInputWithoutSPPFSuccess.kt +++ /dev/null @@ -1,785 +0,0 @@ -package rsm.graphinput.withoutsppf - -import org.junit.jupiter.api.Test -import org.junit.jupiter.params.ParameterizedTest -import org.junit.jupiter.params.provider.ValueSource -import org.kotgll.graph.GraphNode -import org.kotgll.graph.readGraphFromString -import org.kotgll.rsm.grammar.RSMNonterminalEdge -import org.kotgll.rsm.grammar.RSMState -import org.kotgll.rsm.grammar.RSMTerminalEdge -import org.kotgll.rsm.grammar.symbol.Nonterminal -import org.kotgll.rsm.grammar.symbol.Terminal -import org.kotgll.rsm.graphinput.withoutsppf.GLL -import kotlin.test.assertEquals - -class TestRSMGraphInputWithoutSPPFSuccess { - @Test - fun `test 'empty' hand-crafted grammar`() { - val nonterminalS = Nonterminal("S") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - isFinal = true, - ) - nonterminalS.startState = rsmState0 - - val graph = GraphNode(id = 0, isStart = true, isFinal = true) - - assertEquals( - expected = hashMapOf(0 to hashSetOf(0)), - actual = GLL(rsmState0, listOf(graph)).parse(), - ) - } - - @Test - fun `test 'a' hand-crafted grammar`() { - val nonterminalS = Nonterminal("S") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - ) - nonterminalS.startState = rsmState0 - rsmState0.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("a"), - head = - RSMState( - id = 1, - nonterminal = nonterminalS, - isFinal = true, - ))) - - assertEquals( - expected = hashMapOf(0 to hashSetOf(1)), - actual = GLL(rsmState0, listOf(readGraphFromString("a"))).parse(), - ) - } - - @Test - fun `test 'ab' hand-crafted grammar`() { - val nonterminalS = Nonterminal("S") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - ) - nonterminalS.startState = rsmState0 - val rsmState1 = - RSMState( - id = 1, - nonterminal = nonterminalS, - ) - rsmState0.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("a"), - head = rsmState1, - )) - rsmState1.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("b"), - head = - RSMState( - id = 2, - nonterminal = nonterminalS, - isFinal = true, - ))) - - assertEquals( - expected = hashMapOf(0 to hashSetOf(2)), - actual = GLL(rsmState0, listOf(readGraphFromString("ab"))).parse(), - ) - } - - @ParameterizedTest(name = "Should be NotNull for {0}") - @ValueSource(strings = ["", "a", "aa", "aaa", "aaaa"]) - fun `test 'a-star' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - isFinal = true, - ) - nonterminalS.startState = rsmState0 - val rsmState1 = - RSMState( - id = 1, - nonterminal = nonterminalS, - isFinal = true, - ) - rsmState0.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("a"), - head = rsmState1, - )) - rsmState1.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("a"), - head = rsmState1, - )) - - assertEquals( - expected = hashMapOf(0 to hashSetOf(input.length)), - actual = GLL(rsmState0, listOf(readGraphFromString(input))).parse(), - ) - } - - @ParameterizedTest(name = "Should be NotNull for {0}") - @ValueSource(strings = ["a", "aa", "aaa"]) - fun `test 'a-plus' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - ) - nonterminalS.startState = rsmState0 - val rsmState1 = - RSMState( - id = 1, - nonterminal = nonterminalS, - isFinal = true, - ) - rsmState0.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("a"), - head = rsmState1, - )) - rsmState1.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("a"), - head = rsmState1, - )) - - assertEquals( - expected = hashMapOf(0 to hashSetOf(input.length)), - actual = GLL(rsmState0, listOf(readGraphFromString(input))).parse(), - ) - } - - @ParameterizedTest(name = "Should be NotNull for {0}") - @ValueSource(strings = ["", "ab", "abab", "ababab"]) - fun `test '(ab)-star' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - isFinal = true, - ) - nonterminalS.startState = rsmState0 - val rsmState1 = - RSMState( - id = 1, - nonterminal = nonterminalS, - isFinal = true, - ) - rsmState0.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("ab"), - head = rsmState1, - )) - rsmState1.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("ab"), - head = rsmState1, - )) - - val graph = GraphNode(id = 0, isStart = true) - var cur = graph - var i = 0 - while (i < input.length) { - val head = GraphNode(id = i + 1) - cur.addEdge("" + input[i] + input[i + 1], head) - cur = head - i += 2 - } - cur.isFinal = true - - assertEquals( - expected = hashMapOf(0 to hashSetOf(cur.id)), - actual = GLL(rsmState0, listOf(graph)).parse(), - ) - } - - @ParameterizedTest(name = "Should be NotNull for {0}") - @ValueSource( - strings = - [ - "", - "()", - "()()", - "()()()", - "(())", - "(())()", - "(())()()", - "(())(())", - "(())(())()", - "(())(())()()", - "(()())(()())", - "((()))", - "(((())))", - "((((()))))", - ]) - fun `test 'dyck' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - isFinal = true, - ) - nonterminalS.startState = rsmState0 - val rsmState1 = - RSMState( - id = 1, - nonterminal = nonterminalS, - ) - val rsmState2 = - RSMState( - id = 2, - nonterminal = nonterminalS, - ) - val rsmState3 = - RSMState( - id = 3, - nonterminal = nonterminalS, - ) - val rsmState4 = - RSMState( - id = 4, - nonterminal = nonterminalS, - isFinal = true, - ) - - rsmState0.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("("), - head = rsmState1, - )) - rsmState1.addNonterminalEdge( - RSMNonterminalEdge( - nonterminal = nonterminalS, - head = rsmState2, - )) - rsmState2.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal(")"), - head = rsmState3, - )) - rsmState3.addNonterminalEdge( - RSMNonterminalEdge( - nonterminal = nonterminalS, - head = rsmState4, - )) - - assertEquals( - expected = hashMapOf(0 to hashSetOf(input.length)), - actual = GLL(rsmState0, listOf(readGraphFromString(input))).parse(), - ) - } - - @ParameterizedTest(name = "Should be NotEmpty for {0}") - @ValueSource(strings = ["ab", "cd"]) - fun `test 'ab or cd' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - ) - val rsmState1 = - RSMState( - id = 1, - nonterminal = nonterminalS, - isFinal = true, - ) - - nonterminalS.startState = rsmState0 - - rsmState0.addTerminalEdge(RSMTerminalEdge(terminal = Terminal("ab"), head = rsmState1)) - rsmState0.addTerminalEdge(RSMTerminalEdge(terminal = Terminal("cd"), head = rsmState1)) - - val graph = GraphNode(id = 0, isStart = true) - val graphNode1 = GraphNode(id = 1, isFinal = true) - - graph.addEdge(input, graphNode1) - - assertEquals( - expected = hashMapOf(0 to hashSetOf(1)), actual = GLL(rsmState0, listOf(graph)).parse()) - } - - @ParameterizedTest(name = "Should be NotEmpty for {0}") - @ValueSource(strings = ["", "a"]) - fun `test 'a-optional' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - isFinal = true, - ) - val rsmState1 = - RSMState( - id = 1, - nonterminal = nonterminalS, - isFinal = true, - ) - - nonterminalS.startState = rsmState0 - - rsmState0.addTerminalEdge(RSMTerminalEdge(terminal = Terminal("a"), head = rsmState1)) - - assertEquals( - expected = hashMapOf(0 to hashSetOf(input.length)), - actual = GLL(rsmState0, listOf(readGraphFromString(input))).parse()) - } - - @ParameterizedTest(name = "Should be NotNull for {0}") - @ValueSource(strings = ["abc"]) - fun `test 'abc' ambiguous hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - val nonterminalA = Nonterminal("A") - val nonterminalB = Nonterminal("B") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - ) - nonterminalS.startState = rsmState0 - val rsmState1 = - RSMState( - id = 1, - nonterminal = nonterminalS, - ) - val rsmState2 = - RSMState( - id = 2, - nonterminal = nonterminalS, - ) - val rsmState3 = - RSMState( - id = 3, - nonterminal = nonterminalS, - isFinal = true, - ) - val rsmState4 = - RSMState( - id = 4, - nonterminal = nonterminalS, - ) - val rsmState5 = - RSMState( - id = 5, - nonterminal = nonterminalS, - isFinal = true, - ) - val rsmState6 = - RSMState( - id = 6, - nonterminal = nonterminalA, - isStart = true, - ) - nonterminalA.startState = rsmState6 - val rsmState7 = - RSMState( - id = 7, - nonterminal = nonterminalA, - ) - val rsmState8 = - RSMState( - id = 8, - nonterminal = nonterminalA, - isFinal = true, - ) - val rsmState9 = - RSMState( - id = 9, - nonterminal = nonterminalB, - isStart = true, - ) - nonterminalB.startState = rsmState9 - val rsmState10 = - RSMState( - id = 10, - nonterminal = nonterminalB, - isFinal = true, - ) - - rsmState0.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("a"), - head = rsmState1, - )) - rsmState1.addNonterminalEdge( - RSMNonterminalEdge( - nonterminal = nonterminalB, - head = rsmState2, - )) - rsmState2.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("c"), - head = rsmState3, - )) - rsmState0.addNonterminalEdge( - RSMNonterminalEdge( - nonterminal = nonterminalA, - head = rsmState4, - )) - rsmState4.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("c"), - head = rsmState5, - )) - - rsmState6.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("a"), - head = rsmState7, - )) - rsmState7.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("b"), - head = rsmState8, - )) - - rsmState9.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("b"), - head = rsmState10, - )) - - assertEquals( - expected = hashMapOf(0 to hashSetOf(input.length)), - actual = GLL(rsmState0, listOf(readGraphFromString(input))).parse(), - ) - } - - @ParameterizedTest(name = "Should be NotNull for {0}") - @ValueSource(strings = ["ab", "cd"]) - fun `test 'ab or cd' ambiguous hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - val nonterminalA = Nonterminal("A") - val nonterminalB = Nonterminal("B") - - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - ) - nonterminalS.startState = rsmState0 - val rsmState1 = - RSMState( - id = 1, - nonterminal = nonterminalS, - isFinal = true, - ) - val rsmState2 = - RSMState( - id = 2, - nonterminal = nonterminalS, - isFinal = true, - ) - val rsmState3 = - RSMState( - id = 3, - nonterminal = nonterminalA, - isStart = true, - ) - nonterminalA.startState = rsmState3 - val rsmState4 = - RSMState( - id = 4, - nonterminal = nonterminalA, - isFinal = true, - ) - val rsmState5 = - RSMState( - id = 5, - nonterminal = nonterminalA, - isFinal = true, - ) - val rsmState6 = - RSMState( - id = 6, - nonterminal = nonterminalB, - isStart = true, - ) - nonterminalB.startState = rsmState6 - val rsmState7 = RSMState(id = 7, nonterminal = nonterminalB, isFinal = true) - val rsmState8 = - RSMState( - id = 8, - nonterminal = nonterminalB, - isFinal = true, - ) - - rsmState0.addNonterminalEdge( - RSMNonterminalEdge( - nonterminal = nonterminalA, - head = rsmState1, - )) - rsmState0.addNonterminalEdge( - RSMNonterminalEdge( - nonterminal = nonterminalB, - head = rsmState2, - )) - rsmState3.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("ab"), - head = rsmState4, - )) - rsmState3.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("cd"), - head = rsmState5, - )) - rsmState6.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("ab"), - head = rsmState7, - )) - rsmState6.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("cd"), - head = rsmState8, - )) - - val graphNode0 = - GraphNode( - id = 0, - isStart = true, - ) - val graphNode1 = - GraphNode( - id = 1, - isFinal = true, - ) - - graphNode0.addEdge(input, graphNode1) - - assertEquals( - expected = hashMapOf(0 to hashSetOf(1)), - actual = GLL(rsmState0, listOf(graphNode0)).parse(), - ) - } - - @Test - fun `test 'dyck' hand-crafted grammar two cycle graph`() { - val nonterminalS = Nonterminal("S") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - isFinal = true, - ) - nonterminalS.startState = rsmState0 - val rsmState1 = - RSMState( - id = 1, - nonterminal = nonterminalS, - ) - val rsmState2 = - RSMState( - id = 2, - nonterminal = nonterminalS, - ) - val rsmState3 = - RSMState( - id = 3, - nonterminal = nonterminalS, - ) - val rsmState4 = - RSMState( - id = 4, - nonterminal = nonterminalS, - isFinal = true, - ) - - rsmState0.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("("), - head = rsmState1, - )) - rsmState1.addNonterminalEdge( - RSMNonterminalEdge( - nonterminal = nonterminalS, - head = rsmState2, - )) - rsmState2.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal(")"), - head = rsmState3, - )) - rsmState3.addNonterminalEdge( - RSMNonterminalEdge( - nonterminal = nonterminalS, - head = rsmState4, - )) - - val graphNode0 = GraphNode(id = 0, isStart = true, isFinal = true) - val graphNode1 = GraphNode(id = 1, isStart = true, isFinal = true) - val graphNode2 = GraphNode(id = 2, isStart = true, isFinal = true) - val graphNode3 = GraphNode(id = 3, isStart = true, isFinal = true) - - graphNode0.addEdge("(", graphNode1) - graphNode1.addEdge("(", graphNode2) - graphNode2.addEdge("(", graphNode0) - - graphNode2.addEdge(")", graphNode3) - graphNode3.addEdge(")", graphNode2) - - assertEquals( - expected = - hashMapOf( - 0 to hashSetOf(0, 2, 3), - 1 to hashSetOf(1, 2, 3), - 2 to hashSetOf(2, 3), - 3 to hashSetOf(3), - ), - actual = GLL(rsmState0, listOf(graphNode0, graphNode1, graphNode2, graphNode3)).parse(), - ) - } - - @Test - fun `test 'a-plus' hand-crafted grammar one cycle graph`() { - val nonterminalS = Nonterminal("S") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - ) - nonterminalS.startState = rsmState0 - val rsmState1 = - RSMState( - id = 1, - nonterminal = nonterminalS, - isFinal = true, - ) - val rsmState2 = - RSMState( - id = 2, - nonterminal = nonterminalS, - isFinal = true, - ) - - rsmState0.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("a"), - head = rsmState1, - )) - rsmState1.addNonterminalEdge( - RSMNonterminalEdge( - nonterminal = nonterminalS, - head = rsmState2, - )) - - val graphNode0 = GraphNode(id = 0, isStart = true, isFinal = true) - val graphNode1 = GraphNode(id = 1, isStart = true, isFinal = true) - - graphNode0.addEdge("a", graphNode1) - graphNode1.addEdge("a", graphNode1) - - assertEquals( - expected = hashMapOf(0 to hashSetOf(1), 1 to hashSetOf(1)), - actual = GLL(rsmState0, listOf(graphNode0, graphNode1)).parse(), - ) - } - - @Test - fun `test 'a-star' hand-crafted grammar one cycle graph`() { - val nonterminalS = Nonterminal("S") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - isFinal = true, - ) - nonterminalS.startState = rsmState0 - - rsmState0.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("a"), - head = rsmState0, - )) - - val graphNode0 = GraphNode(id = 0, isStart = true, isFinal = true) - val graphNode1 = GraphNode(id = 1, isStart = true, isFinal = true) - - graphNode0.addEdge("a", graphNode1) - graphNode1.addEdge("a", graphNode1) - - assertEquals( - expected = - hashMapOf( - 0 to hashSetOf(0, 1), - 1 to hashSetOf(1), - ), - actual = GLL(rsmState0, listOf(graphNode0, graphNode1)).parse()) - } - - @Test - fun `test 'g1' hand-crafted grammar two cycle graph`() { - val nonterminalS = Nonterminal("S") - val rsmState0 = RSMState(id = 0, nonterminal = nonterminalS, isStart = true) - val rsmState1 = RSMState(id = 1, nonterminal = nonterminalS) - val rsmState2 = RSMState(id = 2, nonterminal = nonterminalS) - val rsmState3 = RSMState(id = 3, nonterminal = nonterminalS, isFinal = true) - val rsmState4 = RSMState(id = 4, nonterminal = nonterminalS) - val rsmState5 = RSMState(id = 5, nonterminal = nonterminalS) - val rsmState6 = RSMState(id = 6, nonterminal = nonterminalS, isFinal = true) - - nonterminalS.startState = rsmState0 - - rsmState0.addTerminalEdge( - RSMTerminalEdge(terminal = Terminal("subClassOf_r"), head = rsmState1)) - rsmState1.addNonterminalEdge(RSMNonterminalEdge(nonterminal = nonterminalS, head = rsmState2)) - rsmState2.addTerminalEdge(RSMTerminalEdge(terminal = Terminal("subClassOf"), head = rsmState3)) - - rsmState1.addTerminalEdge(RSMTerminalEdge(terminal = Terminal("subClassOf"), head = rsmState3)) - - rsmState0.addTerminalEdge(RSMTerminalEdge(terminal = Terminal("type_r"), head = rsmState4)) - rsmState4.addNonterminalEdge(RSMNonterminalEdge(nonterminal = nonterminalS, head = rsmState5)) - rsmState5.addTerminalEdge(RSMTerminalEdge(terminal = Terminal("type"), head = rsmState6)) - - rsmState4.addTerminalEdge(RSMTerminalEdge(terminal = Terminal("subClassOf"), head = rsmState6)) - - val graphNode0 = GraphNode(id = 0, isStart = true, isFinal = true) - val graphNode1 = GraphNode(id = 1, isStart = true, isFinal = true) - val graphNode2 = GraphNode(id = 2, isStart = true, isFinal = true) - val graphNode3 = GraphNode(id = 3, isStart = true, isFinal = true) - - graphNode0.addEdge("subClassOf_r", graphNode1) - graphNode1.addEdge("subClassOf_r", graphNode2) - graphNode2.addEdge("subClassOf_r", graphNode0) - - graphNode2.addEdge("subClassOf", graphNode3) - graphNode3.addEdge("subClassOf", graphNode2) - - assertEquals( - expected = - hashMapOf( - 0 to hashSetOf(2, 3), - 1 to hashSetOf(2, 3), - 2 to hashSetOf(2, 3), - ), - actual = GLL(rsmState0, listOf(graphNode0, graphNode1, graphNode2, graphNode3)).parse()) - } -} diff --git a/src/test/kotlin/rsm/graphinput/withsppf/TestRSMGraphInputWithSPPFFail.kt b/src/test/kotlin/rsm/graphinput/withsppf/TestRSMGraphInputWithSPPFFail.kt deleted file mode 100644 index ab227ae9f..000000000 --- a/src/test/kotlin/rsm/graphinput/withsppf/TestRSMGraphInputWithSPPFFail.kt +++ /dev/null @@ -1,830 +0,0 @@ -package rsm.graphinput.withsppf - -import org.junit.jupiter.api.Test -import org.junit.jupiter.params.ParameterizedTest -import org.junit.jupiter.params.provider.ValueSource -import org.kotgll.graph.GraphNode -import org.kotgll.graph.readGraphFromString -import org.kotgll.rsm.grammar.RSMNonterminalEdge -import org.kotgll.rsm.grammar.RSMState -import org.kotgll.rsm.grammar.RSMTerminalEdge -import org.kotgll.rsm.grammar.symbol.Nonterminal -import org.kotgll.rsm.grammar.symbol.Terminal -import org.kotgll.rsm.graphinput.withsppf.GLL -import kotlin.test.assertEquals - -class TestRSMGraphInputWithSPPFFail { - @Test - fun `test 'empty' hand-crafted grammar`() { - val nonterminalS = Nonterminal("S") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - isFinal = true, - ) - nonterminalS.startState = rsmState0 - - val graph = GraphNode(id = 0, isStart = true) - - assertEquals(expected = hashMapOf(), actual = GLL(rsmState0, listOf(graph)).parse()) - } - - @ParameterizedTest(name = "Should be Empty for {0}") - @ValueSource(strings = ["", "b", "bb", "ab", "aa"]) - fun `test 'a' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - ) - nonterminalS.startState = rsmState0 - rsmState0.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("a"), - head = - RSMState( - id = 1, - nonterminal = nonterminalS, - isFinal = true, - ))) - - assertEquals( - expected = hashMapOf(), actual = GLL(rsmState0, listOf(readGraphFromString(input))).parse()) - } - - @ParameterizedTest(name = "Should be Empty for {0}") - @ValueSource(strings = ["", "a", "b", "aba", "ababa", "aa", "b", "bb", "c", "cc"]) - fun `test 'ab' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - ) - nonterminalS.startState = rsmState0 - val rsmState1 = - RSMState( - id = 1, - nonterminal = nonterminalS, - ) - rsmState0.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("a"), - head = rsmState1, - )) - rsmState1.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("b"), - head = - RSMState( - id = 2, - nonterminal = nonterminalS, - isFinal = true, - ))) - - assertEquals( - expected = hashMapOf(), actual = GLL(rsmState0, listOf(readGraphFromString(input))).parse()) - } - - @ParameterizedTest(name = "Should be Empty for {0}") - @ValueSource(strings = ["b", "bb", "c", "cc", "ab", "ac"]) - fun `test 'a-star' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - isFinal = true, - ) - nonterminalS.startState = rsmState0 - val rsmState1 = - RSMState( - id = 1, - nonterminal = nonterminalS, - isFinal = true, - ) - rsmState0.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("a"), - head = rsmState1, - )) - rsmState1.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("a"), - head = rsmState1, - )) - - assertEquals( - expected = hashMapOf(), actual = GLL(rsmState0, listOf(readGraphFromString(input))).parse()) - } - - @ParameterizedTest(name = "Should be Empty for {0}") - @ValueSource(strings = ["", "b", "bb", "c", "cc", "ab", "ac"]) - fun `test 'a-plus' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - ) - nonterminalS.startState = rsmState0 - val rsmState1 = - RSMState( - id = 1, - nonterminal = nonterminalS, - isFinal = true, - ) - rsmState0.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("a"), - head = rsmState1, - )) - rsmState1.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("a"), - head = rsmState1, - )) - - assertEquals( - expected = hashMapOf(), actual = GLL(rsmState0, listOf(readGraphFromString(input))).parse()) - } - - @ParameterizedTest(name = "Should be Empty for {0}") - @ValueSource( - strings = - [ - "abaa", - "abba", - "abca", - "ababaa", - "ababba", - "ababca", - "abbb", - "abcb", - "ababbb", - "ababcb", - "abac", - "abbc", - "abcc", - "ababac", - "ababbc", - "ababcc", - ]) - fun `test '(ab)-star' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - isFinal = true, - ) - nonterminalS.startState = rsmState0 - val rsmState1 = - RSMState( - id = 1, - nonterminal = nonterminalS, - isFinal = true, - ) - rsmState0.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("ab"), - head = rsmState1, - )) - rsmState1.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("ab"), - head = rsmState1, - )) - - val graph = GraphNode(id = 0, isStart = true) - var cur = graph - var i = 0 - while (i < input.length) { - val head = GraphNode(id = i + 1) - cur.addEdge("" + input[i] + input[i + 1], head) - cur = head - i += 2 - } - cur.isFinal = true - - assertEquals(expected = hashMapOf(), actual = GLL(rsmState0, listOf(graph)).parse()) - } - - @ParameterizedTest(name = "Should be Empty for {0}") - @ValueSource( - strings = - [ - "(", - ")", - "((", - "))", - "()(", - "()()(", - "()()()(", - "())", - "()())", - "()()())", - "(())(", - "(())()(", - "(())()()(", - "(()))", - "(())())", - "(())()())", - "(())(())(", - "(())(())()(", - "(())(())()()(", - "(())(()))", - "(())(())())", - "(())(())()())", - "(()())(()())(", - "(()())(()()))", - ]) - fun `test 'dyck' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - isFinal = true, - ) - nonterminalS.startState = rsmState0 - val rsmState1 = - RSMState( - id = 1, - nonterminal = nonterminalS, - ) - val rsmState2 = - RSMState( - id = 2, - nonterminal = nonterminalS, - ) - val rsmState3 = - RSMState( - id = 3, - nonterminal = nonterminalS, - ) - val rsmState4 = - RSMState( - id = 4, - nonterminal = nonterminalS, - isFinal = true, - ) - - rsmState0.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("("), - head = rsmState1, - )) - rsmState1.addNonterminalEdge( - RSMNonterminalEdge( - nonterminal = nonterminalS, - head = rsmState2, - )) - rsmState2.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal(")"), - head = rsmState3, - )) - rsmState3.addNonterminalEdge( - RSMNonterminalEdge( - nonterminal = nonterminalS, - head = rsmState4, - )) - - assertEquals( - expected = hashMapOf(), actual = GLL(rsmState0, listOf(readGraphFromString(input))).parse()) - } - - @ParameterizedTest(name = "Should be Empty for {0}") - @ValueSource( - strings = - [ - "", - "a", - "b", - "c", - "d", - "aa", - "ac", - "ad", - "ba", - "bb", - "bc", - "bd", - "ca", - "cb", - "cc", - "da", - "db", - "dc", - "dd", - ]) - fun `test 'ab or cd' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - ) - nonterminalS.startState = rsmState0 - val rsmState1 = - RSMState( - id = 1, - nonterminal = nonterminalS, - isFinal = true, - ) - val rsmState2 = - RSMState( - id = 2, - nonterminal = nonterminalS, - isFinal = true, - ) - - rsmState0.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("ab"), - head = rsmState1, - )) - rsmState0.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("cd"), - head = rsmState2, - )) - - val graph = GraphNode(id = 0, isStart = true) - graph.addEdge(input, GraphNode(id = 1, isFinal = true)) - - assertEquals(expected = hashMapOf(), actual = GLL(rsmState0, listOf(graph)).parse()) - } - - @ParameterizedTest(name = "Should be Empty for {0}") - @ValueSource(strings = ["b", "bb", "ab"]) - fun `test 'a-optional' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - isFinal = true, - ) - nonterminalS.startState = rsmState0 - val rsmState1 = - RSMState( - id = 1, - nonterminal = nonterminalS, - isFinal = true, - ) - - rsmState0.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("a"), - head = rsmState1, - )) - - assertEquals( - expected = hashMapOf(), actual = GLL(rsmState0, listOf(readGraphFromString(input))).parse()) - } - - @ParameterizedTest(name = "Should be Empty for {0}") - @ValueSource(strings = ["", "a", "b", "c", "ab", "ac", "abb", "bc", "abcd"]) - fun `test 'abc' ambiguous hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - val nonterminalA = Nonterminal("A") - val nonterminalB = Nonterminal("B") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - ) - nonterminalS.startState = rsmState0 - val rsmState1 = - RSMState( - id = 1, - nonterminal = nonterminalS, - ) - val rsmState2 = - RSMState( - id = 2, - nonterminal = nonterminalS, - ) - val rsmState3 = - RSMState( - id = 3, - nonterminal = nonterminalS, - isFinal = true, - ) - val rsmState4 = - RSMState( - id = 4, - nonterminal = nonterminalS, - ) - val rsmState5 = - RSMState( - id = 5, - nonterminal = nonterminalS, - isFinal = true, - ) - val rsmState6 = - RSMState( - id = 6, - nonterminal = nonterminalA, - isStart = true, - ) - nonterminalA.startState = rsmState6 - val rsmState7 = - RSMState( - id = 7, - nonterminal = nonterminalA, - ) - val rsmState8 = - RSMState( - id = 8, - nonterminal = nonterminalA, - isFinal = true, - ) - val rsmState9 = - RSMState( - id = 9, - nonterminal = nonterminalB, - isStart = true, - ) - nonterminalB.startState = rsmState9 - val rsmState10 = - RSMState( - id = 10, - nonterminal = nonterminalB, - isFinal = true, - ) - - rsmState0.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("a"), - head = rsmState1, - )) - rsmState1.addNonterminalEdge( - RSMNonterminalEdge( - nonterminal = nonterminalB, - head = rsmState2, - )) - rsmState2.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("c"), - head = rsmState3, - )) - rsmState0.addNonterminalEdge( - RSMNonterminalEdge( - nonterminal = nonterminalA, - head = rsmState4, - )) - rsmState4.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("c"), - head = rsmState5, - )) - - rsmState6.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("a"), - head = rsmState7, - )) - rsmState7.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("b"), - head = rsmState8, - )) - - rsmState9.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("b"), - head = rsmState10, - )) - - assertEquals( - expected = hashMapOf(), actual = GLL(rsmState0, listOf(readGraphFromString(input))).parse()) - } - - @ParameterizedTest(name = "Should be Empty for {0}") - @ValueSource( - strings = - [ - "", - "a", - "b", - "c", - "d", - "aa", - "ac", - "ad", - "ba", - "bb", - "bc", - "bd", - "ca", - "cb", - "cc", - "da", - "db", - "dc", - "dd", - ]) - fun `test 'ab or cd' ambiguous hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - val nonterminalA = Nonterminal("A") - val nonterminalB = Nonterminal("B") - - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - ) - nonterminalS.startState = rsmState0 - val rsmState1 = - RSMState( - id = 1, - nonterminal = nonterminalS, - isFinal = true, - ) - val rsmState2 = - RSMState( - id = 2, - nonterminal = nonterminalS, - isFinal = true, - ) - val rsmState3 = - RSMState( - id = 3, - nonterminal = nonterminalA, - isStart = true, - ) - nonterminalA.startState = rsmState3 - val rsmState4 = - RSMState( - id = 4, - nonterminal = nonterminalA, - isFinal = true, - ) - val rsmState5 = - RSMState( - id = 5, - nonterminal = nonterminalA, - isFinal = true, - ) - val rsmState6 = - RSMState( - id = 6, - nonterminal = nonterminalB, - isStart = true, - ) - nonterminalB.startState = rsmState6 - val rsmState7 = RSMState(id = 7, nonterminal = nonterminalB, isFinal = true) - val rsmState8 = - RSMState( - id = 8, - nonterminal = nonterminalB, - isFinal = true, - ) - - rsmState0.addNonterminalEdge( - RSMNonterminalEdge( - nonterminal = nonterminalA, - head = rsmState1, - )) - rsmState0.addNonterminalEdge( - RSMNonterminalEdge( - nonterminal = nonterminalB, - head = rsmState2, - )) - rsmState3.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("ab"), - head = rsmState4, - )) - rsmState3.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("cd"), - head = rsmState5, - )) - rsmState6.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("ab"), - head = rsmState7, - )) - rsmState6.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("cd"), - head = rsmState8, - )) - - val graphNode0 = - GraphNode( - id = 0, - isStart = true, - ) - val graphNode1 = - GraphNode( - id = 1, - isFinal = true, - ) - - graphNode0.addEdge(input, graphNode1) - - assertEquals(expected = hashMapOf(), actual = GLL(rsmState0, listOf(graphNode0)).parse()) - } - - @Test - fun `test 'dyck' hand-crafted grammar two cycle graph`() { - val nonterminalS = Nonterminal("S") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - isFinal = true, - ) - nonterminalS.startState = rsmState0 - val rsmState1 = - RSMState( - id = 1, - nonterminal = nonterminalS, - ) - val rsmState2 = - RSMState( - id = 2, - nonterminal = nonterminalS, - ) - val rsmState3 = - RSMState( - id = 3, - nonterminal = nonterminalS, - ) - val rsmState4 = - RSMState( - id = 4, - nonterminal = nonterminalS, - isFinal = true, - ) - - rsmState0.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("("), - head = rsmState1, - )) - rsmState1.addNonterminalEdge( - RSMNonterminalEdge( - nonterminal = nonterminalS, - head = rsmState2, - )) - rsmState2.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal(")"), - head = rsmState3, - )) - rsmState3.addNonterminalEdge( - RSMNonterminalEdge( - nonterminal = nonterminalS, - head = rsmState4, - )) - - val graphNode0 = GraphNode(id = 0, isStart = true, isFinal = true) - val graphNode1 = GraphNode(id = 1, isStart = true, isFinal = true) - val graphNode2 = GraphNode(id = 2, isStart = true, isFinal = true) - val graphNode3 = GraphNode(id = 3, isStart = true) - - graphNode0.addEdge("(", graphNode1) - graphNode1.addEdge("(", graphNode2) - graphNode2.addEdge("(", graphNode0) - - graphNode2.addEdge(")", graphNode3) - graphNode3.addEdge(")", graphNode2) - - assertEquals(expected = hashMapOf(), actual = GLL(rsmState0, listOf(graphNode3)).parse()) - } - - @Test - fun `test 'a-plus' hand-crafted grammar one cycle graph`() { - val nonterminalS = Nonterminal("S") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - ) - nonterminalS.startState = rsmState0 - val rsmState1 = - RSMState( - id = 1, - nonterminal = nonterminalS, - isFinal = true, - ) - val rsmState2 = - RSMState( - id = 2, - nonterminal = nonterminalS, - isFinal = true, - ) - - rsmState0.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("a"), - head = rsmState1, - )) - rsmState1.addNonterminalEdge( - RSMNonterminalEdge( - nonterminal = nonterminalS, - head = rsmState2, - )) - - val graphNode0 = GraphNode(id = 0, isStart = true, isFinal = true) - val graphNode1 = GraphNode(id = 1, isStart = true) - - graphNode0.addEdge("a", graphNode1) - graphNode1.addEdge("a", graphNode1) - - assertEquals(expected = hashMapOf(), actual = GLL(rsmState0, listOf(graphNode0)).parse()) - assertEquals(expected = hashMapOf(), actual = GLL(rsmState0, listOf(graphNode1)).parse()) - } - - @Test - fun `test 'a-star' hand-crafted grammar one cycle graph`() { - val nonterminalS = Nonterminal("S") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - isFinal = true, - ) - nonterminalS.startState = rsmState0 - - rsmState0.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("a"), - head = rsmState0, - )) - - val graphNode0 = GraphNode(id = 0, isStart = true) - val graphNode1 = GraphNode(id = 1, isStart = true) - - graphNode0.addEdge("a", graphNode1) - graphNode1.addEdge("a", graphNode1) - - assertEquals(expected = hashMapOf(), actual = GLL(rsmState0, listOf(graphNode0)).parse()) - assertEquals(expected = hashMapOf(), actual = GLL(rsmState0, listOf(graphNode1)).parse()) - } - - @Test - fun `test 'g1' hand-crafted grammar two cycle graph`() { - val nonterminalS = Nonterminal("S") - val rsmState0 = RSMState(id = 0, nonterminal = nonterminalS, isStart = true) - val rsmState1 = RSMState(id = 1, nonterminal = nonterminalS) - val rsmState2 = RSMState(id = 2, nonterminal = nonterminalS) - val rsmState3 = RSMState(id = 3, nonterminal = nonterminalS, isFinal = true) - val rsmState4 = RSMState(id = 4, nonterminal = nonterminalS) - val rsmState5 = RSMState(id = 5, nonterminal = nonterminalS) - val rsmState6 = RSMState(id = 6, nonterminal = nonterminalS, isFinal = true) - - nonterminalS.startState = rsmState0 - - rsmState0.addTerminalEdge( - RSMTerminalEdge(terminal = Terminal("subClassOf_r"), head = rsmState1)) - rsmState1.addNonterminalEdge(RSMNonterminalEdge(nonterminal = nonterminalS, head = rsmState2)) - rsmState2.addTerminalEdge(RSMTerminalEdge(terminal = Terminal("subClassOf"), head = rsmState3)) - - rsmState1.addTerminalEdge(RSMTerminalEdge(terminal = Terminal("subClassOf"), head = rsmState3)) - - rsmState0.addTerminalEdge(RSMTerminalEdge(terminal = Terminal("type_r"), head = rsmState4)) - rsmState4.addNonterminalEdge(RSMNonterminalEdge(nonterminal = nonterminalS, head = rsmState5)) - rsmState5.addTerminalEdge(RSMTerminalEdge(terminal = Terminal("type"), head = rsmState6)) - - rsmState4.addTerminalEdge(RSMTerminalEdge(terminal = Terminal("subClassOf"), head = rsmState6)) - - val graphNode0 = GraphNode(id = 0, isStart = true, isFinal = true) - val graphNode1 = GraphNode(id = 1, isStart = true, isFinal = true) - val graphNode2 = GraphNode(id = 2, isStart = true) - val graphNode3 = GraphNode(id = 3, isStart = true) - - graphNode0.addEdge("subClassOf_r", graphNode1) - graphNode1.addEdge("subClassOf_r", graphNode2) - graphNode2.addEdge("subClassOf_r", graphNode0) - - graphNode2.addEdge("subClassOf", graphNode3) - graphNode3.addEdge("subClassOf", graphNode2) - - assertEquals( - expected = hashMapOf(), - actual = GLL(rsmState0, listOf(graphNode0, graphNode1, graphNode2, graphNode3)).parse()) - } -} diff --git a/src/test/kotlin/rsm/graphinput/withsppf/TestRSMGraphInputWithSPPFSuccess.kt b/src/test/kotlin/rsm/graphinput/withsppf/TestRSMGraphInputWithSPPFSuccess.kt deleted file mode 100644 index 20a885e49..000000000 --- a/src/test/kotlin/rsm/graphinput/withsppf/TestRSMGraphInputWithSPPFSuccess.kt +++ /dev/null @@ -1,862 +0,0 @@ -package rsm.graphinput.withsppf - -import org.junit.jupiter.api.Test -import org.junit.jupiter.params.ParameterizedTest -import org.junit.jupiter.params.provider.ValueSource -import org.kotgll.graph.GraphNode -import org.kotgll.graph.readGraphFromString -import org.kotgll.rsm.grammar.RSMNonterminalEdge -import org.kotgll.rsm.grammar.RSMState -import org.kotgll.rsm.grammar.RSMTerminalEdge -import org.kotgll.rsm.grammar.symbol.Nonterminal -import org.kotgll.rsm.grammar.symbol.Terminal -import org.kotgll.rsm.graphinput.withsppf.GLL -import kotlin.test.assertEquals - -class TestRSMGraphInputWithSPPFSuccess { - @Test - fun `test 'empty' hand-crafted grammar`() { - val nonterminalS = Nonterminal("S") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - isFinal = true, - ) - nonterminalS.startState = rsmState0 - - val graph = GraphNode(id = 0, isStart = true, isFinal = true) - - val result = GLL(rsmState0, listOf(graph)).parse() - val pairs: HashMap> = HashMap() - result.keys.forEach { tail -> - if (!pairs.containsKey(tail)) pairs[tail] = HashSet() - result[tail]!!.keys.forEach { head -> pairs[tail]!!.add(head) } - } - - assertEquals(expected = hashMapOf(0 to hashSetOf(0)), actual = pairs) - } - - @Test - fun `test 'a' hand-crafted grammar`() { - val nonterminalS = Nonterminal("S") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - ) - nonterminalS.startState = rsmState0 - rsmState0.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("a"), - head = - RSMState( - id = 1, - nonterminal = nonterminalS, - isFinal = true, - ))) - - val result = GLL(rsmState0, listOf(readGraphFromString("a"))).parse() - val pairs: HashMap> = HashMap() - result.keys.forEach { tail -> - if (!pairs.containsKey(tail)) pairs[tail] = HashSet() - result[tail]!!.keys.forEach { head -> pairs[tail]!!.add(head) } - } - - assertEquals(expected = hashMapOf(0 to hashSetOf(1)), actual = pairs) - } - - @Test - fun `test 'ab' hand-crafted grammar`() { - val nonterminalS = Nonterminal("S") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - ) - nonterminalS.startState = rsmState0 - val rsmState1 = - RSMState( - id = 1, - nonterminal = nonterminalS, - ) - rsmState0.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("a"), - head = rsmState1, - )) - rsmState1.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("b"), - head = - RSMState( - id = 2, - nonterminal = nonterminalS, - isFinal = true, - ))) - - val result = GLL(rsmState0, listOf(readGraphFromString("ab"))).parse() - val pairs: HashMap> = HashMap() - result.keys.forEach { tail -> - if (!pairs.containsKey(tail)) pairs[tail] = HashSet() - result[tail]!!.keys.forEach { head -> pairs[tail]!!.add(head) } - } - - assertEquals(expected = hashMapOf(0 to hashSetOf(2)), actual = pairs) - } - - @ParameterizedTest(name = "Should be NotEmpty for {0}") - @ValueSource(strings = ["", "a", "aa", "aaa", "aaaa"]) - fun `test 'a-star' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - isFinal = true, - ) - nonterminalS.startState = rsmState0 - val rsmState1 = - RSMState( - id = 1, - nonterminal = nonterminalS, - isFinal = true, - ) - rsmState0.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("a"), - head = rsmState1, - )) - rsmState1.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("a"), - head = rsmState1, - )) - - val result = GLL(rsmState0, listOf(readGraphFromString(input))).parse() - val pairs: HashMap> = HashMap() - result.keys.forEach { tail -> - if (!pairs.containsKey(tail)) pairs[tail] = HashSet() - result[tail]!!.keys.forEach { head -> pairs[tail]!!.add(head) } - } - - assertEquals(expected = hashMapOf(0 to hashSetOf(input.length)), actual = pairs) - } - - @ParameterizedTest(name = "Should be NotEmpty for {0}") - @ValueSource(strings = ["a", "aa", "aaa"]) - fun `test 'a-plus' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - ) - nonterminalS.startState = rsmState0 - val rsmState1 = - RSMState( - id = 1, - nonterminal = nonterminalS, - isFinal = true, - ) - rsmState0.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("a"), - head = rsmState1, - )) - rsmState1.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("a"), - head = rsmState1, - )) - - val result = GLL(rsmState0, listOf(readGraphFromString(input))).parse() - val pairs: HashMap> = HashMap() - result.keys.forEach { tail -> - if (!pairs.containsKey(tail)) pairs[tail] = HashSet() - result[tail]!!.keys.forEach { head -> pairs[tail]!!.add(head) } - } - - assertEquals(expected = hashMapOf(0 to hashSetOf(input.length)), actual = pairs) - } - - @ParameterizedTest(name = "Should be NotEmpty for {0}") - @ValueSource(strings = ["", "ab", "abab", "ababab"]) - fun `test '(ab)-star' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - isFinal = true, - ) - nonterminalS.startState = rsmState0 - val rsmState1 = - RSMState( - id = 1, - nonterminal = nonterminalS, - isFinal = true, - ) - rsmState0.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("ab"), - head = rsmState1, - )) - rsmState1.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("ab"), - head = rsmState1, - )) - - val graph = GraphNode(id = 0, isStart = true) - var cur = graph - var i = 0 - while (i < input.length) { - val head = GraphNode(id = i + 1) - cur.addEdge("" + input[i] + input[i + 1], head) - cur = head - i += 2 - } - cur.isFinal = true - - val result = GLL(rsmState0, listOf(graph)).parse() - val pairs: HashMap> = HashMap() - result.keys.forEach { tail -> - if (!pairs.containsKey(tail)) pairs[tail] = HashSet() - result[tail]!!.keys.forEach { head -> pairs[tail]!!.add(head) } - } - - assertEquals(expected = hashMapOf(0 to hashSetOf(cur.id)), actual = pairs) - } - - @ParameterizedTest(name = "Should be NotEmpty for {0}") - @ValueSource( - strings = - [ - "", - "()", - "()()", - "()()()", - "(())", - "(())()", - "(())()()", - "(())(())", - "(())(())()", - "(())(())()()", - "(()())(()())", - "((()))", - "(((())))", - "((((()))))", - ]) - fun `test 'dyck' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - isFinal = true, - ) - nonterminalS.startState = rsmState0 - val rsmState1 = - RSMState( - id = 1, - nonterminal = nonterminalS, - ) - val rsmState2 = - RSMState( - id = 2, - nonterminal = nonterminalS, - ) - val rsmState3 = - RSMState( - id = 3, - nonterminal = nonterminalS, - ) - val rsmState4 = - RSMState( - id = 4, - nonterminal = nonterminalS, - isFinal = true, - ) - - rsmState0.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("("), - head = rsmState1, - )) - rsmState1.addNonterminalEdge( - RSMNonterminalEdge( - nonterminal = nonterminalS, - head = rsmState2, - )) - rsmState2.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal(")"), - head = rsmState3, - )) - rsmState3.addNonterminalEdge( - RSMNonterminalEdge( - nonterminal = nonterminalS, - head = rsmState4, - )) - - val result = GLL(rsmState0, listOf(readGraphFromString(input))).parse() - val pairs: HashMap> = HashMap() - result.keys.forEach { tail -> - if (!pairs.containsKey(tail)) pairs[tail] = HashSet() - result[tail]!!.keys.forEach { head -> pairs[tail]!!.add(head) } - } - - assertEquals(expected = hashMapOf(0 to hashSetOf(input.length)), actual = pairs) - } - - @ParameterizedTest(name = "Should be NotEmpty for {0}") - @ValueSource(strings = ["ab", "cd"]) - fun `test 'ab or cd' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - ) - val rsmState1 = - RSMState( - id = 1, - nonterminal = nonterminalS, - isFinal = true, - ) - - nonterminalS.startState = rsmState0 - - rsmState0.addTerminalEdge(RSMTerminalEdge(terminal = Terminal("ab"), head = rsmState1)) - rsmState0.addTerminalEdge(RSMTerminalEdge(terminal = Terminal("cd"), head = rsmState1)) - - val graph = GraphNode(id = 0, isStart = true) - val graphNode1 = GraphNode(id = 1, isFinal = true) - - graph.addEdge(input, graphNode1) - - val result = GLL(rsmState0, listOf(graph)).parse() - val pairs: HashMap> = HashMap() - result.keys.forEach { tail -> - if (!pairs.containsKey(tail)) pairs[tail] = HashSet() - result[tail]!!.keys.forEach { head -> pairs[tail]!!.add(head) } - } - - assertEquals(expected = hashMapOf(0 to hashSetOf(1)), actual = pairs) - } - - @ParameterizedTest(name = "Should be NotEmpty for {0}") - @ValueSource(strings = ["", "a"]) - fun `test 'a-optional' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - isFinal = true, - ) - val rsmState1 = - RSMState( - id = 1, - nonterminal = nonterminalS, - isFinal = true, - ) - - nonterminalS.startState = rsmState0 - - rsmState0.addTerminalEdge(RSMTerminalEdge(terminal = Terminal("a"), head = rsmState1)) - - val result = GLL(rsmState0, listOf(readGraphFromString(input))).parse() - val pairs: HashMap> = HashMap() - result.keys.forEach { tail -> - if (!pairs.containsKey(tail)) pairs[tail] = HashSet() - result[tail]!!.keys.forEach { head -> pairs[tail]!!.add(head) } - } - - assertEquals(expected = hashMapOf(0 to hashSetOf(input.length)), actual = pairs) - } - - @ParameterizedTest(name = "Should be NotEmpty for {0}") - @ValueSource(strings = ["abc"]) - fun `test 'abc' ambiguous hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - val nonterminalA = Nonterminal("A") - val nonterminalB = Nonterminal("B") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - ) - nonterminalS.startState = rsmState0 - val rsmState1 = - RSMState( - id = 1, - nonterminal = nonterminalS, - ) - val rsmState2 = - RSMState( - id = 2, - nonterminal = nonterminalS, - ) - val rsmState3 = - RSMState( - id = 3, - nonterminal = nonterminalS, - isFinal = true, - ) - val rsmState4 = - RSMState( - id = 4, - nonterminal = nonterminalS, - ) - val rsmState5 = - RSMState( - id = 5, - nonterminal = nonterminalS, - isFinal = true, - ) - val rsmState6 = - RSMState( - id = 6, - nonterminal = nonterminalA, - isStart = true, - ) - nonterminalA.startState = rsmState6 - val rsmState7 = - RSMState( - id = 7, - nonterminal = nonterminalA, - ) - val rsmState8 = - RSMState( - id = 8, - nonterminal = nonterminalA, - isFinal = true, - ) - val rsmState9 = - RSMState( - id = 9, - nonterminal = nonterminalB, - isStart = true, - ) - nonterminalB.startState = rsmState9 - val rsmState10 = - RSMState( - id = 10, - nonterminal = nonterminalB, - isFinal = true, - ) - - rsmState0.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("a"), - head = rsmState1, - )) - rsmState1.addNonterminalEdge( - RSMNonterminalEdge( - nonterminal = nonterminalB, - head = rsmState2, - )) - rsmState2.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("c"), - head = rsmState3, - )) - rsmState0.addNonterminalEdge( - RSMNonterminalEdge( - nonterminal = nonterminalA, - head = rsmState4, - )) - rsmState4.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("c"), - head = rsmState5, - )) - - rsmState6.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("a"), - head = rsmState7, - )) - rsmState7.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("b"), - head = rsmState8, - )) - - rsmState9.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("b"), - head = rsmState10, - )) - - val result = GLL(rsmState0, listOf(readGraphFromString(input))).parse() - val pairs: HashMap> = HashMap() - result.keys.forEach { tail -> - if (!pairs.containsKey(tail)) pairs[tail] = HashSet() - result[tail]!!.keys.forEach { head -> pairs[tail]!!.add(head) } - } - - assertEquals(expected = hashMapOf(0 to hashSetOf(input.length)), actual = pairs) - } - - @ParameterizedTest(name = "Should be NotEmpty for {0}") - @ValueSource(strings = ["ab", "cd"]) - fun `test 'ab or cd' ambiguous hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - val nonterminalA = Nonterminal("A") - val nonterminalB = Nonterminal("B") - - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - ) - nonterminalS.startState = rsmState0 - val rsmState1 = - RSMState( - id = 1, - nonterminal = nonterminalS, - isFinal = true, - ) - val rsmState2 = - RSMState( - id = 2, - nonterminal = nonterminalS, - isFinal = true, - ) - val rsmState3 = - RSMState( - id = 3, - nonterminal = nonterminalA, - isStart = true, - ) - nonterminalA.startState = rsmState3 - val rsmState4 = - RSMState( - id = 4, - nonterminal = nonterminalA, - isFinal = true, - ) - val rsmState5 = - RSMState( - id = 5, - nonterminal = nonterminalA, - isFinal = true, - ) - val rsmState6 = - RSMState( - id = 6, - nonterminal = nonterminalB, - isStart = true, - ) - nonterminalB.startState = rsmState6 - val rsmState7 = RSMState(id = 7, nonterminal = nonterminalB, isFinal = true) - val rsmState8 = - RSMState( - id = 8, - nonterminal = nonterminalB, - isFinal = true, - ) - - rsmState0.addNonterminalEdge( - RSMNonterminalEdge( - nonterminal = nonterminalA, - head = rsmState1, - )) - rsmState0.addNonterminalEdge( - RSMNonterminalEdge( - nonterminal = nonterminalB, - head = rsmState2, - )) - rsmState3.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("ab"), - head = rsmState4, - )) - rsmState3.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("cd"), - head = rsmState5, - )) - rsmState6.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("ab"), - head = rsmState7, - )) - rsmState6.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("cd"), - head = rsmState8, - )) - - val graphNode0 = - GraphNode( - id = 0, - isStart = true, - ) - val graphNode1 = - GraphNode( - id = 1, - isFinal = true, - ) - - graphNode0.addEdge(input, graphNode1) - - val result = GLL(rsmState0, listOf(graphNode0)).parse() - val pairs: HashMap> = HashMap() - result.keys.forEach { tail -> - if (!pairs.containsKey(tail)) pairs[tail] = HashSet() - result[tail]!!.keys.forEach { head -> pairs[tail]!!.add(head) } - } - - assertEquals(expected = hashMapOf(0 to hashSetOf(1)), actual = pairs) - } - - @Test - fun `test 'dyck' hand-crafted grammar two cycle graph`() { - val nonterminalS = Nonterminal("S") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - isFinal = true, - ) - nonterminalS.startState = rsmState0 - val rsmState1 = - RSMState( - id = 1, - nonterminal = nonterminalS, - ) - val rsmState2 = - RSMState( - id = 2, - nonterminal = nonterminalS, - ) - val rsmState3 = - RSMState( - id = 3, - nonterminal = nonterminalS, - ) - val rsmState4 = - RSMState( - id = 4, - nonterminal = nonterminalS, - isFinal = true, - ) - - rsmState0.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("("), - head = rsmState1, - )) - rsmState1.addNonterminalEdge( - RSMNonterminalEdge( - nonterminal = nonterminalS, - head = rsmState2, - )) - rsmState2.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal(")"), - head = rsmState3, - )) - rsmState3.addNonterminalEdge( - RSMNonterminalEdge( - nonterminal = nonterminalS, - head = rsmState4, - )) - - val graphNode0 = GraphNode(id = 0, isStart = true, isFinal = true) - val graphNode1 = GraphNode(id = 1, isStart = true, isFinal = true) - val graphNode2 = GraphNode(id = 2, isStart = true, isFinal = true) - val graphNode3 = GraphNode(id = 3, isStart = true, isFinal = true) - - graphNode0.addEdge("(", graphNode1) - graphNode1.addEdge("(", graphNode2) - graphNode2.addEdge("(", graphNode0) - - graphNode2.addEdge(")", graphNode3) - graphNode3.addEdge(")", graphNode2) - - val result = GLL(rsmState0, listOf(graphNode0, graphNode1, graphNode2, graphNode3)).parse() - val pairs: HashMap> = HashMap() - result.keys.forEach { tail -> - if (!pairs.containsKey(tail)) pairs[tail] = HashSet() - result[tail]!!.keys.forEach { head -> pairs[tail]!!.add(head) } - } - - assertEquals( - expected = - hashMapOf( - 0 to hashSetOf(0, 2, 3), - 1 to hashSetOf(1, 2, 3), - 2 to hashSetOf(2, 3), - 3 to hashSetOf(3), - ), - actual = pairs) - } - - @Test - fun `test 'a-plus' hand-crafted grammar one cycle graph`() { - val nonterminalS = Nonterminal("S") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - ) - nonterminalS.startState = rsmState0 - val rsmState1 = - RSMState( - id = 1, - nonterminal = nonterminalS, - isFinal = true, - ) - val rsmState2 = - RSMState( - id = 2, - nonterminal = nonterminalS, - isFinal = true, - ) - - rsmState0.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("a"), - head = rsmState1, - )) - rsmState1.addNonterminalEdge( - RSMNonterminalEdge( - nonterminal = nonterminalS, - head = rsmState2, - )) - - val graphNode0 = GraphNode(id = 0, isStart = true, isFinal = true) - val graphNode1 = GraphNode(id = 1, isStart = true, isFinal = true) - - graphNode0.addEdge("a", graphNode1) - graphNode1.addEdge("a", graphNode1) - - val result = GLL(rsmState0, listOf(graphNode0, graphNode1)).parse() - val pairs: HashMap> = HashMap() - result.keys.forEach { tail -> - if (!pairs.containsKey(tail)) pairs[tail] = HashSet() - result[tail]!!.keys.forEach { head -> pairs[tail]!!.add(head) } - } - - assertEquals( - expected = - hashMapOf( - 0 to hashSetOf(1), - 1 to hashSetOf(1), - ), - actual = pairs) - } - - @Test - fun `test 'a-star' hand-crafted grammar one cycle graph`() { - val nonterminalS = Nonterminal("S") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - isFinal = true, - ) - nonterminalS.startState = rsmState0 - - rsmState0.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("a"), - head = rsmState0, - )) - - val graphNode0 = GraphNode(id = 0, isStart = true, isFinal = true) - val graphNode1 = GraphNode(id = 1, isStart = true, isFinal = true) - - graphNode0.addEdge("a", graphNode1) - graphNode1.addEdge("a", graphNode1) - - val result = GLL(rsmState0, listOf(graphNode0, graphNode1)).parse() - val pairs: HashMap> = HashMap() - result.keys.forEach { tail -> - if (!pairs.containsKey(tail)) pairs[tail] = HashSet() - result[tail]!!.keys.forEach { head -> pairs[tail]!!.add(head) } - } - - assertEquals( - expected = - hashMapOf( - 0 to hashSetOf(0, 1), - 1 to hashSetOf(1), - ), - actual = pairs) - } - - @Test - fun `test 'g1' hand-crafted grammar two cycle graph`() { - val nonterminalS = Nonterminal("S") - val rsmState0 = RSMState(id = 0, nonterminal = nonterminalS, isStart = true) - val rsmState1 = RSMState(id = 1, nonterminal = nonterminalS) - val rsmState2 = RSMState(id = 2, nonterminal = nonterminalS) - val rsmState3 = RSMState(id = 3, nonterminal = nonterminalS, isFinal = true) - val rsmState4 = RSMState(id = 4, nonterminal = nonterminalS) - val rsmState5 = RSMState(id = 5, nonterminal = nonterminalS) - val rsmState6 = RSMState(id = 6, nonterminal = nonterminalS, isFinal = true) - - nonterminalS.startState = rsmState0 - - rsmState0.addTerminalEdge( - RSMTerminalEdge(terminal = Terminal("subClassOf_r"), head = rsmState1)) - rsmState1.addNonterminalEdge(RSMNonterminalEdge(nonterminal = nonterminalS, head = rsmState2)) - rsmState2.addTerminalEdge(RSMTerminalEdge(terminal = Terminal("subClassOf"), head = rsmState3)) - - rsmState1.addTerminalEdge(RSMTerminalEdge(terminal = Terminal("subClassOf"), head = rsmState3)) - - rsmState0.addTerminalEdge(RSMTerminalEdge(terminal = Terminal("type_r"), head = rsmState4)) - rsmState4.addNonterminalEdge(RSMNonterminalEdge(nonterminal = nonterminalS, head = rsmState5)) - rsmState5.addTerminalEdge(RSMTerminalEdge(terminal = Terminal("type"), head = rsmState6)) - - rsmState4.addTerminalEdge(RSMTerminalEdge(terminal = Terminal("subClassOf"), head = rsmState6)) - - val graphNode0 = GraphNode(id = 0, isStart = true, isFinal = true) - val graphNode1 = GraphNode(id = 1, isStart = true, isFinal = true) - val graphNode2 = GraphNode(id = 2, isStart = true, isFinal = true) - val graphNode3 = GraphNode(id = 3, isStart = true, isFinal = true) - - graphNode0.addEdge("subClassOf_r", graphNode1) - graphNode1.addEdge("subClassOf_r", graphNode2) - graphNode2.addEdge("subClassOf_r", graphNode0) - - graphNode2.addEdge("subClassOf", graphNode3) - graphNode3.addEdge("subClassOf", graphNode2) - - val result = GLL(rsmState0, listOf(graphNode0, graphNode1, graphNode2, graphNode3)).parse() - val pairs: HashMap> = HashMap() - result.keys.forEach { tail -> - if (!pairs.containsKey(tail)) pairs[tail] = HashSet() - result[tail]!!.keys.forEach { head -> pairs[tail]!!.add(head) } - } - - assertEquals( - expected = - hashMapOf( - 0 to hashSetOf(2, 3), - 1 to hashSetOf(2, 3), - 2 to hashSetOf(2, 3), - ), - actual = pairs) - } -} diff --git a/src/test/kotlin/rsm/stringinput/withoutsppf/TestRSMStringInputWithoutSPPFFail.kt b/src/test/kotlin/rsm/stringinput/withoutsppf/TestRSMStringInputWithoutSPPFFail.kt deleted file mode 100644 index 7fa945913..000000000 --- a/src/test/kotlin/rsm/stringinput/withoutsppf/TestRSMStringInputWithoutSPPFFail.kt +++ /dev/null @@ -1,592 +0,0 @@ -package rsm.stringinput.withoutsppf - -import org.junit.jupiter.api.Test -import org.junit.jupiter.params.ParameterizedTest -import org.junit.jupiter.params.provider.ValueSource -import org.kotgll.rsm.grammar.RSMNonterminalEdge -import org.kotgll.rsm.grammar.RSMState -import org.kotgll.rsm.grammar.RSMTerminalEdge -import org.kotgll.rsm.grammar.symbol.Nonterminal -import org.kotgll.rsm.grammar.symbol.Terminal -import org.kotgll.rsm.stringinput.withoutsppf.GLL -import kotlin.test.assertFalse - -class TestRSMStringInputWithoutSPPFFail { - @Test - fun `test 'empty' hand-crafted grammar`() { - val nonterminalS = Nonterminal("S") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - isFinal = true, - ) - nonterminalS.startState = rsmState0 - - assertFalse(GLL(rsmState0, "a").parse()) - } - - @ParameterizedTest(name = "Should be False for {0}") - @ValueSource(strings = ["", "b", "bb", "ab", "aa"]) - fun `test 'a' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - ) - nonterminalS.startState = rsmState0 - rsmState0.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("a"), - head = - RSMState( - id = 1, - nonterminal = nonterminalS, - isFinal = true, - ))) - - assertFalse(GLL(rsmState0, input).parse()) - } - - @ParameterizedTest(name = "Should be False for {0}") - @ValueSource(strings = ["", "a", "b", "aba", "ababa", "aa", "b", "bb", "c", "cc"]) - fun `test 'ab' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - ) - nonterminalS.startState = rsmState0 - val rsmState1 = - RSMState( - id = 1, - nonterminal = nonterminalS, - ) - rsmState0.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("a"), - head = rsmState1, - )) - rsmState1.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("b"), - head = - RSMState( - id = 2, - nonterminal = nonterminalS, - isFinal = true, - ))) - - assertFalse(GLL(rsmState0, input).parse()) - } - - @ParameterizedTest(name = "Should be False for {0}") - @ValueSource(strings = ["b", "bb", "c", "cc", "ab", "ac"]) - fun `test 'a-star' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - isFinal = true, - ) - nonterminalS.startState = rsmState0 - val rsmState1 = - RSMState( - id = 1, - nonterminal = nonterminalS, - isFinal = true, - ) - rsmState0.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("a"), - head = rsmState1, - )) - rsmState1.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("a"), - head = rsmState1, - )) - - assertFalse(GLL(rsmState0, input).parse()) - } - - @ParameterizedTest(name = "Should be False for {0}") - @ValueSource(strings = ["", "b", "bb", "c", "cc", "ab", "ac"]) - fun `test 'a-plus' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - ) - nonterminalS.startState = rsmState0 - val rsmState1 = - RSMState( - id = 1, - nonterminal = nonterminalS, - isFinal = true, - ) - rsmState0.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("a"), - head = rsmState1, - )) - rsmState1.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("a"), - head = rsmState1, - )) - - assertFalse(GLL(rsmState0, input).parse()) - } - - @ParameterizedTest(name = "Should be False for {0}") - @ValueSource( - strings = - [ - "abaa", - "abba", - "abca", - "ababaa", - "ababba", - "ababca", - "abbb", - "abcb", - "ababbb", - "ababcb", - "abac", - "abbc", - "abcc", - "ababac", - "ababbc", - "ababcc", - ]) - fun `test '(ab)-star' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - isFinal = true, - ) - nonterminalS.startState = rsmState0 - val rsmState1 = - RSMState( - id = 1, - nonterminal = nonterminalS, - isFinal = true, - ) - rsmState0.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("ab"), - head = rsmState1, - )) - rsmState1.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("ab"), - head = rsmState1, - )) - - assertFalse(GLL(rsmState0, input).parse()) - } - - @ParameterizedTest(name = "Should be False for {0}") - @ValueSource( - strings = - [ - "(", - ")", - "((", - "))", - "()(", - "()()(", - "()()()(", - "())", - "()())", - "()()())", - "(())(", - "(())()(", - "(())()()(", - "(()))", - "(())())", - "(())()())", - "(())(())(", - "(())(())()(", - "(())(())()()(", - "(())(()))", - "(())(())())", - "(())(())()())", - "(()())(()())(", - "(()())(()()))", - ]) - fun `test 'dyck' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - isFinal = true, - ) - nonterminalS.startState = rsmState0 - val rsmState1 = - RSMState( - id = 1, - nonterminal = nonterminalS, - ) - val rsmState2 = - RSMState( - id = 2, - nonterminal = nonterminalS, - ) - val rsmState3 = - RSMState( - id = 3, - nonterminal = nonterminalS, - ) - val rsmState4 = - RSMState( - id = 4, - nonterminal = nonterminalS, - isFinal = true, - ) - - rsmState0.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("("), - head = rsmState1, - )) - rsmState1.addNonterminalEdge( - RSMNonterminalEdge( - nonterminal = nonterminalS, - head = rsmState2, - )) - rsmState2.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal(")"), - head = rsmState3, - )) - rsmState3.addNonterminalEdge( - RSMNonterminalEdge( - nonterminal = nonterminalS, - head = rsmState4, - )) - - assertFalse(GLL(rsmState0, input).parse()) - } - - @ParameterizedTest(name = "Should be False for {0}") - @ValueSource( - strings = - [ - "", - "a", - "b", - "c", - "d", - "aa", - "ac", - "ad", - "ba", - "bb", - "bc", - "bd", - "ca", - "cb", - "cc", - "da", - "db", - "dc", - "dd", - ]) - fun `test 'ab or cd' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - ) - val rsmState1 = - RSMState( - id = 1, - nonterminal = nonterminalS, - isFinal = true, - ) - - nonterminalS.startState = rsmState0 - - rsmState0.addTerminalEdge(RSMTerminalEdge(terminal = Terminal("ab"), head = rsmState1)) - rsmState0.addTerminalEdge(RSMTerminalEdge(terminal = Terminal("cd"), head = rsmState1)) - - assertFalse(GLL(rsmState0, input).parse()) - } - - @ParameterizedTest(name = "Should be False for {0}") - @ValueSource(strings = ["b", "bb", "ab"]) - fun `test 'a-optional' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - isFinal = true, - ) - val rsmState1 = - RSMState( - id = 1, - nonterminal = nonterminalS, - isFinal = true, - ) - - nonterminalS.startState = rsmState0 - - rsmState0.addTerminalEdge(RSMTerminalEdge(terminal = Terminal("a"), head = rsmState1)) - - assertFalse(GLL(rsmState0, input).parse()) - } - - @ParameterizedTest(name = "Should be False for {0}") - @ValueSource(strings = ["", "a", "b", "c", "ab", "ac", "abb", "bc", "abcd"]) - fun `test 'abc' ambiguous hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - val nonterminalA = Nonterminal("A") - val nonterminalB = Nonterminal("B") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - ) - nonterminalS.startState = rsmState0 - val rsmState1 = - RSMState( - id = 1, - nonterminal = nonterminalS, - ) - val rsmState2 = - RSMState( - id = 2, - nonterminal = nonterminalS, - ) - val rsmState3 = - RSMState( - id = 3, - nonterminal = nonterminalS, - isFinal = true, - ) - val rsmState4 = - RSMState( - id = 4, - nonterminal = nonterminalS, - ) - val rsmState5 = - RSMState( - id = 5, - nonterminal = nonterminalS, - isFinal = true, - ) - val rsmState6 = - RSMState( - id = 6, - nonterminal = nonterminalA, - isStart = true, - ) - nonterminalA.startState = rsmState6 - val rsmState7 = - RSMState( - id = 7, - nonterminal = nonterminalA, - ) - val rsmState8 = - RSMState( - id = 8, - nonterminal = nonterminalA, - isFinal = true, - ) - val rsmState9 = - RSMState( - id = 9, - nonterminal = nonterminalB, - isStart = true, - ) - nonterminalB.startState = rsmState9 - val rsmState10 = - RSMState( - id = 10, - nonterminal = nonterminalB, - isFinal = true, - ) - - rsmState0.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("a"), - head = rsmState1, - )) - rsmState1.addNonterminalEdge( - RSMNonterminalEdge( - nonterminal = nonterminalB, - head = rsmState2, - )) - rsmState2.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("c"), - head = rsmState3, - )) - rsmState0.addNonterminalEdge( - RSMNonterminalEdge( - nonterminal = nonterminalA, - head = rsmState4, - )) - rsmState4.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("c"), - head = rsmState5, - )) - - rsmState6.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("a"), - head = rsmState7, - )) - rsmState7.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("b"), - head = rsmState8, - )) - - rsmState9.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("b"), - head = rsmState10, - )) - - assertFalse(GLL(rsmState0, input).parse()) - } - - @ParameterizedTest(name = "Should be False for {0}") - @ValueSource( - strings = - [ - "", - "a", - "b", - "c", - "d", - "aa", - "ac", - "ad", - "ba", - "bb", - "bc", - "bd", - "ca", - "cb", - "cc", - "da", - "db", - "dc", - "dd", - ]) - fun `test 'ab or cd' ambiguous hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - val nonterminalA = Nonterminal("A") - val nonterminalB = Nonterminal("B") - - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - ) - nonterminalS.startState = rsmState0 - val rsmState1 = - RSMState( - id = 1, - nonterminal = nonterminalS, - isFinal = true, - ) - val rsmState2 = - RSMState( - id = 2, - nonterminal = nonterminalS, - isFinal = true, - ) - val rsmState3 = - RSMState( - id = 3, - nonterminal = nonterminalA, - isStart = true, - ) - nonterminalA.startState = rsmState3 - val rsmState4 = - RSMState( - id = 4, - nonterminal = nonterminalA, - isFinal = true, - ) - val rsmState5 = - RSMState( - id = 5, - nonterminal = nonterminalA, - isFinal = true, - ) - val rsmState6 = - RSMState( - id = 6, - nonterminal = nonterminalB, - isStart = true, - ) - nonterminalB.startState = rsmState6 - val rsmState7 = RSMState(id = 7, nonterminal = nonterminalB, isFinal = true) - val rsmState8 = - RSMState( - id = 8, - nonterminal = nonterminalB, - isFinal = true, - ) - - rsmState0.addNonterminalEdge( - RSMNonterminalEdge( - nonterminal = nonterminalA, - head = rsmState1, - )) - rsmState0.addNonterminalEdge( - RSMNonterminalEdge( - nonterminal = nonterminalB, - head = rsmState2, - )) - rsmState3.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("ab"), - head = rsmState4, - )) - rsmState3.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("cd"), - head = rsmState5, - )) - rsmState6.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("ab"), - head = rsmState7, - )) - rsmState6.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("cd"), - head = rsmState8, - )) - - assertFalse(GLL(rsmState0, input).parse()) - } -} diff --git a/src/test/kotlin/rsm/stringinput/withoutsppf/TestRSMStringInputWithoutSPPFSuccess.kt b/src/test/kotlin/rsm/stringinput/withoutsppf/TestRSMStringInputWithoutSPPFSuccess.kt deleted file mode 100644 index 10eddc1be..000000000 --- a/src/test/kotlin/rsm/stringinput/withoutsppf/TestRSMStringInputWithoutSPPFSuccess.kt +++ /dev/null @@ -1,517 +0,0 @@ -package rsm.stringinput.withoutsppf - -import org.junit.jupiter.api.Test -import org.junit.jupiter.params.ParameterizedTest -import org.junit.jupiter.params.provider.ValueSource -import org.kotgll.rsm.grammar.RSMNonterminalEdge -import org.kotgll.rsm.grammar.RSMState -import org.kotgll.rsm.grammar.RSMTerminalEdge -import org.kotgll.rsm.grammar.symbol.Nonterminal -import org.kotgll.rsm.grammar.symbol.Terminal -import org.kotgll.rsm.stringinput.withoutsppf.GLL -import kotlin.test.assertTrue - -class TestRSMStringInputWithoutSPPFSuccess { - @Test - fun `test 'empty' hand-crafted grammar`() { - val nonterminalS = Nonterminal("S") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - isFinal = true, - ) - nonterminalS.startState = rsmState0 - - assertTrue(GLL(rsmState0, "").parse()) - } - - @Test - fun `test 'a' hand-crafted grammar`() { - val nonterminalS = Nonterminal("S") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - ) - nonterminalS.startState = rsmState0 - rsmState0.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("a"), - head = - RSMState( - id = 1, - nonterminal = nonterminalS, - isFinal = true, - ))) - - assertTrue(GLL(rsmState0, "a").parse()) - } - - @Test - fun `test 'ab' hand-crafted grammar`() { - val nonterminalS = Nonterminal("S") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - ) - nonterminalS.startState = rsmState0 - val rsmState1 = - RSMState( - id = 1, - nonterminal = nonterminalS, - ) - rsmState0.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("a"), - head = rsmState1, - )) - rsmState1.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("b"), - head = - RSMState( - id = 2, - nonterminal = nonterminalS, - isFinal = true, - ))) - - assertTrue(GLL(rsmState0, "ab").parse()) - } - - @ParameterizedTest(name = "Should be True for {0}") - @ValueSource(strings = ["", "a", "aa", "aaa", "aaaa"]) - fun `test 'a-star' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - isFinal = true, - ) - nonterminalS.startState = rsmState0 - val rsmState1 = - RSMState( - id = 1, - nonterminal = nonterminalS, - isFinal = true, - ) - rsmState0.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("a"), - head = rsmState1, - )) - rsmState1.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("a"), - head = rsmState1, - )) - - assertTrue(GLL(rsmState0, input).parse()) - } - - @ParameterizedTest(name = "Should be True for {0}") - @ValueSource(strings = ["a", "aa", "aaa"]) - fun `test 'a-plus' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - ) - nonterminalS.startState = rsmState0 - val rsmState1 = - RSMState( - id = 1, - nonterminal = nonterminalS, - isFinal = true, - ) - rsmState0.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("a"), - head = rsmState1, - )) - rsmState1.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("a"), - head = rsmState1, - )) - - assertTrue(GLL(rsmState0, input).parse()) - } - - @ParameterizedTest(name = "Should be True for {0}") - @ValueSource(strings = ["", "ab", "abab", "ababab"]) - fun `test '(ab)-star' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - isFinal = true, - ) - nonterminalS.startState = rsmState0 - val rsmState1 = - RSMState( - id = 1, - nonterminal = nonterminalS, - isFinal = true, - ) - rsmState0.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("ab"), - head = rsmState1, - )) - rsmState1.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("ab"), - head = rsmState1, - )) - - assertTrue(GLL(rsmState0, input).parse()) - } - - @ParameterizedTest(name = "Should be True for {0}") - @ValueSource( - strings = - [ - "", - "()", - "()()", - "()()()", - "(())", - "(())()", - "(())()()", - "(())(())", - "(())(())()", - "(())(())()()", - "(()())(()())", - "((()))", - "(((())))", - "((((()))))", - ]) - fun `test 'dyck' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - isFinal = true, - ) - nonterminalS.startState = rsmState0 - val rsmState1 = - RSMState( - id = 1, - nonterminal = nonterminalS, - ) - val rsmState2 = - RSMState( - id = 2, - nonterminal = nonterminalS, - ) - val rsmState3 = - RSMState( - id = 3, - nonterminal = nonterminalS, - ) - val rsmState4 = - RSMState( - id = 4, - nonterminal = nonterminalS, - isFinal = true, - ) - - rsmState0.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("("), - head = rsmState1, - )) - rsmState1.addNonterminalEdge( - RSMNonterminalEdge( - nonterminal = nonterminalS, - head = rsmState2, - )) - rsmState2.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal(")"), - head = rsmState3, - )) - rsmState3.addNonterminalEdge( - RSMNonterminalEdge( - nonterminal = nonterminalS, - head = rsmState4, - )) - - assertTrue(GLL(rsmState0, input).parse()) - } - - @ParameterizedTest(name = "Should be True for {0}") - @ValueSource(strings = ["ab", "cd"]) - fun `test 'ab or cd' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - ) - val rsmState1 = - RSMState( - id = 1, - nonterminal = nonterminalS, - isFinal = true, - ) - - nonterminalS.startState = rsmState0 - - rsmState0.addTerminalEdge(RSMTerminalEdge(terminal = Terminal("ab"), head = rsmState1)) - rsmState0.addTerminalEdge(RSMTerminalEdge(terminal = Terminal("cd"), head = rsmState1)) - - assertTrue(GLL(rsmState0, input).parse()) - } - - @ParameterizedTest(name = "Should be True for {0}") - @ValueSource(strings = ["", "a"]) - fun `test 'a-optional' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - isFinal = true, - ) - val rsmState1 = - RSMState( - id = 1, - nonterminal = nonterminalS, - isFinal = true, - ) - - nonterminalS.startState = rsmState0 - - rsmState0.addTerminalEdge(RSMTerminalEdge(terminal = Terminal("a"), head = rsmState1)) - - assertTrue(GLL(rsmState0, input).parse()) - } - - @ParameterizedTest(name = "Should be True for {0}") - @ValueSource(strings = ["abc"]) - fun `test 'abc' ambiguous hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - val nonterminalA = Nonterminal("A") - val nonterminalB = Nonterminal("B") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - ) - nonterminalS.startState = rsmState0 - val rsmState1 = - RSMState( - id = 1, - nonterminal = nonterminalS, - ) - val rsmState2 = - RSMState( - id = 2, - nonterminal = nonterminalS, - ) - val rsmState3 = - RSMState( - id = 3, - nonterminal = nonterminalS, - isFinal = true, - ) - val rsmState4 = - RSMState( - id = 4, - nonterminal = nonterminalS, - ) - val rsmState5 = - RSMState( - id = 5, - nonterminal = nonterminalS, - isFinal = true, - ) - val rsmState6 = - RSMState( - id = 6, - nonterminal = nonterminalA, - isStart = true, - ) - nonterminalA.startState = rsmState6 - val rsmState7 = - RSMState( - id = 7, - nonterminal = nonterminalA, - ) - val rsmState8 = - RSMState( - id = 8, - nonterminal = nonterminalA, - isFinal = true, - ) - val rsmState9 = - RSMState( - id = 9, - nonterminal = nonterminalB, - isStart = true, - ) - nonterminalB.startState = rsmState9 - val rsmState10 = - RSMState( - id = 10, - nonterminal = nonterminalB, - isFinal = true, - ) - - rsmState0.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("a"), - head = rsmState1, - )) - rsmState1.addNonterminalEdge( - RSMNonterminalEdge( - nonterminal = nonterminalB, - head = rsmState2, - )) - rsmState2.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("c"), - head = rsmState3, - )) - rsmState0.addNonterminalEdge( - RSMNonterminalEdge( - nonterminal = nonterminalA, - head = rsmState4, - )) - rsmState4.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("c"), - head = rsmState5, - )) - - rsmState6.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("a"), - head = rsmState7, - )) - rsmState7.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("b"), - head = rsmState8, - )) - - rsmState9.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("b"), - head = rsmState10, - )) - - assertTrue(GLL(rsmState0, input).parse()) - } - - @ParameterizedTest(name = "Should be True for {0}") - @ValueSource(strings = ["ab", "cd"]) - fun `test 'ab or cd' ambiguous hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - val nonterminalA = Nonterminal("A") - val nonterminalB = Nonterminal("B") - - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - ) - nonterminalS.startState = rsmState0 - val rsmState1 = - RSMState( - id = 1, - nonterminal = nonterminalS, - isFinal = true, - ) - val rsmState2 = - RSMState( - id = 2, - nonterminal = nonterminalS, - isFinal = true, - ) - val rsmState3 = - RSMState( - id = 3, - nonterminal = nonterminalA, - isStart = true, - ) - nonterminalA.startState = rsmState3 - val rsmState4 = - RSMState( - id = 4, - nonterminal = nonterminalA, - isFinal = true, - ) - val rsmState5 = - RSMState( - id = 5, - nonterminal = nonterminalA, - isFinal = true, - ) - val rsmState6 = - RSMState( - id = 6, - nonterminal = nonterminalB, - isStart = true, - ) - nonterminalB.startState = rsmState6 - val rsmState7 = RSMState(id = 7, nonterminal = nonterminalB, isFinal = true) - val rsmState8 = - RSMState( - id = 8, - nonterminal = nonterminalB, - isFinal = true, - ) - - rsmState0.addNonterminalEdge( - RSMNonterminalEdge( - nonterminal = nonterminalA, - head = rsmState1, - )) - rsmState0.addNonterminalEdge( - RSMNonterminalEdge( - nonterminal = nonterminalB, - head = rsmState2, - )) - rsmState3.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("ab"), - head = rsmState4, - )) - rsmState3.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("cd"), - head = rsmState5, - )) - rsmState6.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("ab"), - head = rsmState7, - )) - rsmState6.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("cd"), - head = rsmState8, - )) - - assertTrue(GLL(rsmState0, input).parse()) - } -} diff --git a/src/test/kotlin/rsm/stringinput/withsppf/TestRSMStringInputWithSPPFFail.kt b/src/test/kotlin/rsm/stringinput/withsppf/TestRSMStringInputWithSPPFFail.kt deleted file mode 100644 index 8d08a7631..000000000 --- a/src/test/kotlin/rsm/stringinput/withsppf/TestRSMStringInputWithSPPFFail.kt +++ /dev/null @@ -1,592 +0,0 @@ -package rsm.stringinput.withsppf - -import org.junit.jupiter.api.Test -import org.junit.jupiter.params.ParameterizedTest -import org.junit.jupiter.params.provider.ValueSource -import org.kotgll.rsm.grammar.RSMNonterminalEdge -import org.kotgll.rsm.grammar.RSMState -import org.kotgll.rsm.grammar.RSMTerminalEdge -import org.kotgll.rsm.grammar.symbol.Nonterminal -import org.kotgll.rsm.grammar.symbol.Terminal -import org.kotgll.rsm.stringinput.withsppf.GLL -import kotlin.test.assertNull - -class TestRSMStringInputWithSPPFFail { - @Test - fun `test 'empty' hand-crafted grammar`() { - val nonterminalS = Nonterminal("S") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - isFinal = true, - ) - nonterminalS.startState = rsmState0 - - assertNull(GLL(rsmState0, "a").parse()) - } - - @ParameterizedTest(name = "Should be Null for {0}") - @ValueSource(strings = ["", "b", "bb", "ab", "aa"]) - fun `test 'a' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - ) - nonterminalS.startState = rsmState0 - rsmState0.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("a"), - head = - RSMState( - id = 1, - nonterminal = nonterminalS, - isFinal = true, - ))) - - assertNull(GLL(rsmState0, input).parse()) - } - - @ParameterizedTest(name = "Should be Null for {0}") - @ValueSource(strings = ["", "a", "b", "aba", "ababa", "aa", "b", "bb", "c", "cc"]) - fun `test 'ab' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - ) - nonterminalS.startState = rsmState0 - val rsmState1 = - RSMState( - id = 1, - nonterminal = nonterminalS, - ) - rsmState0.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("a"), - head = rsmState1, - )) - rsmState1.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("b"), - head = - RSMState( - id = 2, - nonterminal = nonterminalS, - isFinal = true, - ))) - - assertNull(GLL(rsmState0, input).parse()) - } - - @ParameterizedTest(name = "Should be Null for {0}") - @ValueSource(strings = ["b", "bb", "c", "cc", "ab", "ac"]) - fun `test 'a-star' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - isFinal = true, - ) - nonterminalS.startState = rsmState0 - val rsmState1 = - RSMState( - id = 1, - nonterminal = nonterminalS, - isFinal = true, - ) - rsmState0.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("a"), - head = rsmState1, - )) - rsmState1.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("a"), - head = rsmState1, - )) - - assertNull(GLL(rsmState0, input).parse()) - } - - @ParameterizedTest(name = "Should be Null for {0}") - @ValueSource(strings = ["", "b", "bb", "c", "cc", "ab", "ac"]) - fun `test 'a-plus' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - ) - nonterminalS.startState = rsmState0 - val rsmState1 = - RSMState( - id = 1, - nonterminal = nonterminalS, - isFinal = true, - ) - rsmState0.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("a"), - head = rsmState1, - )) - rsmState1.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("a"), - head = rsmState1, - )) - - assertNull(GLL(rsmState0, input).parse()) - } - - @ParameterizedTest(name = "Should be Null for {0}") - @ValueSource( - strings = - [ - "abaa", - "abba", - "abca", - "ababaa", - "ababba", - "ababca", - "abbb", - "abcb", - "ababbb", - "ababcb", - "abac", - "abbc", - "abcc", - "ababac", - "ababbc", - "ababcc", - ]) - fun `test '(ab)-star' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - isFinal = true, - ) - nonterminalS.startState = rsmState0 - val rsmState1 = - RSMState( - id = 1, - nonterminal = nonterminalS, - isFinal = true, - ) - rsmState0.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("ab"), - head = rsmState1, - )) - rsmState1.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("ab"), - head = rsmState1, - )) - - assertNull(GLL(rsmState0, input).parse()) - } - - @ParameterizedTest(name = "Should be Null for {0}") - @ValueSource( - strings = - [ - "(", - ")", - "((", - "))", - "()(", - "()()(", - "()()()(", - "())", - "()())", - "()()())", - "(())(", - "(())()(", - "(())()()(", - "(()))", - "(())())", - "(())()())", - "(())(())(", - "(())(())()(", - "(())(())()()(", - "(())(()))", - "(())(())())", - "(())(())()())", - "(()())(()())(", - "(()())(()()))", - ]) - fun `test 'dyck' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - isFinal = true, - ) - nonterminalS.startState = rsmState0 - val rsmState1 = - RSMState( - id = 1, - nonterminal = nonterminalS, - ) - val rsmState2 = - RSMState( - id = 2, - nonterminal = nonterminalS, - ) - val rsmState3 = - RSMState( - id = 3, - nonterminal = nonterminalS, - ) - val rsmState4 = - RSMState( - id = 4, - nonterminal = nonterminalS, - isFinal = true, - ) - - rsmState0.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("("), - head = rsmState1, - )) - rsmState1.addNonterminalEdge( - RSMNonterminalEdge( - nonterminal = nonterminalS, - head = rsmState2, - )) - rsmState2.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal(")"), - head = rsmState3, - )) - rsmState3.addNonterminalEdge( - RSMNonterminalEdge( - nonterminal = nonterminalS, - head = rsmState4, - )) - - assertNull(GLL(rsmState0, input).parse()) - } - - @ParameterizedTest(name = "Should be Null for {0}") - @ValueSource( - strings = - [ - "", - "a", - "b", - "c", - "d", - "aa", - "ac", - "ad", - "ba", - "bb", - "bc", - "bd", - "ca", - "cb", - "cc", - "da", - "db", - "dc", - "dd", - ]) - fun `test 'ab or cd' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - ) - val rsmState1 = - RSMState( - id = 1, - nonterminal = nonterminalS, - isFinal = true, - ) - - nonterminalS.startState = rsmState0 - - rsmState0.addTerminalEdge(RSMTerminalEdge(terminal = Terminal("ab"), head = rsmState1)) - rsmState0.addTerminalEdge(RSMTerminalEdge(terminal = Terminal("cd"), head = rsmState1)) - - assertNull(GLL(rsmState0, input).parse()) - } - - @ParameterizedTest(name = "Should be Null for {0}") - @ValueSource(strings = ["b", "bb", "ab"]) - fun `test 'a-optional' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - isFinal = true, - ) - val rsmState1 = - RSMState( - id = 1, - nonterminal = nonterminalS, - isFinal = true, - ) - - nonterminalS.startState = rsmState0 - - rsmState0.addTerminalEdge(RSMTerminalEdge(terminal = Terminal("a"), head = rsmState1)) - - assertNull(GLL(rsmState0, input).parse()) - } - - @ParameterizedTest(name = "Should be Null for {0}") - @ValueSource(strings = ["", "a", "b", "c", "ab", "ac", "abb", "bc", "abcd"]) - fun `test 'abc' ambiguous hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - val nonterminalA = Nonterminal("A") - val nonterminalB = Nonterminal("B") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - ) - nonterminalS.startState = rsmState0 - val rsmState1 = - RSMState( - id = 1, - nonterminal = nonterminalS, - ) - val rsmState2 = - RSMState( - id = 2, - nonterminal = nonterminalS, - ) - val rsmState3 = - RSMState( - id = 3, - nonterminal = nonterminalS, - isFinal = true, - ) - val rsmState4 = - RSMState( - id = 4, - nonterminal = nonterminalS, - ) - val rsmState5 = - RSMState( - id = 5, - nonterminal = nonterminalS, - isFinal = true, - ) - val rsmState6 = - RSMState( - id = 6, - nonterminal = nonterminalA, - isStart = true, - ) - nonterminalA.startState = rsmState6 - val rsmState7 = - RSMState( - id = 7, - nonterminal = nonterminalA, - ) - val rsmState8 = - RSMState( - id = 8, - nonterminal = nonterminalA, - isFinal = true, - ) - val rsmState9 = - RSMState( - id = 9, - nonterminal = nonterminalB, - isStart = true, - ) - nonterminalB.startState = rsmState9 - val rsmState10 = - RSMState( - id = 10, - nonterminal = nonterminalB, - isFinal = true, - ) - - rsmState0.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("a"), - head = rsmState1, - )) - rsmState1.addNonterminalEdge( - RSMNonterminalEdge( - nonterminal = nonterminalB, - head = rsmState2, - )) - rsmState2.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("c"), - head = rsmState3, - )) - rsmState0.addNonterminalEdge( - RSMNonterminalEdge( - nonterminal = nonterminalA, - head = rsmState4, - )) - rsmState4.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("c"), - head = rsmState5, - )) - - rsmState6.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("a"), - head = rsmState7, - )) - rsmState7.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("b"), - head = rsmState8, - )) - - rsmState9.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("b"), - head = rsmState10, - )) - - assertNull(GLL(rsmState0, input).parse()) - } - - @ParameterizedTest(name = "Should be Null for {0}") - @ValueSource( - strings = - [ - "", - "a", - "b", - "c", - "d", - "aa", - "ac", - "ad", - "ba", - "bb", - "bc", - "bd", - "ca", - "cb", - "cc", - "da", - "db", - "dc", - "dd", - ]) - fun `test 'ab or cd' ambiguous hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - val nonterminalA = Nonterminal("A") - val nonterminalB = Nonterminal("B") - - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - ) - nonterminalS.startState = rsmState0 - val rsmState1 = - RSMState( - id = 1, - nonterminal = nonterminalS, - isFinal = true, - ) - val rsmState2 = - RSMState( - id = 2, - nonterminal = nonterminalS, - isFinal = true, - ) - val rsmState3 = - RSMState( - id = 3, - nonterminal = nonterminalA, - isStart = true, - ) - nonterminalA.startState = rsmState3 - val rsmState4 = - RSMState( - id = 4, - nonterminal = nonterminalA, - isFinal = true, - ) - val rsmState5 = - RSMState( - id = 5, - nonterminal = nonterminalA, - isFinal = true, - ) - val rsmState6 = - RSMState( - id = 6, - nonterminal = nonterminalB, - isStart = true, - ) - nonterminalB.startState = rsmState6 - val rsmState7 = RSMState(id = 7, nonterminal = nonterminalB, isFinal = true) - val rsmState8 = - RSMState( - id = 8, - nonterminal = nonterminalB, - isFinal = true, - ) - - rsmState0.addNonterminalEdge( - RSMNonterminalEdge( - nonterminal = nonterminalA, - head = rsmState1, - )) - rsmState0.addNonterminalEdge( - RSMNonterminalEdge( - nonterminal = nonterminalB, - head = rsmState2, - )) - rsmState3.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("ab"), - head = rsmState4, - )) - rsmState3.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("cd"), - head = rsmState5, - )) - rsmState6.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("ab"), - head = rsmState7, - )) - rsmState6.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("cd"), - head = rsmState8, - )) - - assertNull(GLL(rsmState0, input).parse()) - } -} diff --git a/src/test/kotlin/rsm/stringinput/withsppf/TestRSMStringInputWithSPPFSuccess.kt b/src/test/kotlin/rsm/stringinput/withsppf/TestRSMStringInputWithSPPFSuccess.kt deleted file mode 100644 index 65d140065..000000000 --- a/src/test/kotlin/rsm/stringinput/withsppf/TestRSMStringInputWithSPPFSuccess.kt +++ /dev/null @@ -1,517 +0,0 @@ -package rsm.stringinput.withsppf - -import org.junit.jupiter.api.Test -import org.junit.jupiter.params.ParameterizedTest -import org.junit.jupiter.params.provider.ValueSource -import org.kotgll.rsm.grammar.RSMNonterminalEdge -import org.kotgll.rsm.grammar.RSMState -import org.kotgll.rsm.grammar.RSMTerminalEdge -import org.kotgll.rsm.grammar.symbol.Nonterminal -import org.kotgll.rsm.grammar.symbol.Terminal -import org.kotgll.rsm.stringinput.withsppf.GLL -import kotlin.test.assertNotNull - -class TestRSMStringInputWithSPPFSuccess { - @Test - fun `test 'empty' hand-crafted grammar`() { - val nonterminalS = Nonterminal("S") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - isFinal = true, - ) - nonterminalS.startState = rsmState0 - - assertNotNull(GLL(rsmState0, "").parse()) - } - - @Test - fun `test 'a' hand-crafted grammar`() { - val nonterminalS = Nonterminal("S") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - ) - nonterminalS.startState = rsmState0 - rsmState0.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("a"), - head = - RSMState( - id = 1, - nonterminal = nonterminalS, - isFinal = true, - ))) - - assertNotNull(GLL(rsmState0, "a").parse()) - } - - @Test - fun `test 'ab' hand-crafted grammar`() { - val nonterminalS = Nonterminal("S") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - ) - nonterminalS.startState = rsmState0 - val rsmState1 = - RSMState( - id = 1, - nonterminal = nonterminalS, - ) - rsmState0.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("a"), - head = rsmState1, - )) - rsmState1.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("b"), - head = - RSMState( - id = 2, - nonterminal = nonterminalS, - isFinal = true, - ))) - - assertNotNull(GLL(rsmState0, "ab").parse()) - } - - @ParameterizedTest(name = "Should be NotNull for {0}") - @ValueSource(strings = ["", "a", "aa", "aaa", "aaaa"]) - fun `test 'a-star' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - isFinal = true, - ) - nonterminalS.startState = rsmState0 - val rsmState1 = - RSMState( - id = 1, - nonterminal = nonterminalS, - isFinal = true, - ) - rsmState0.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("a"), - head = rsmState1, - )) - rsmState1.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("a"), - head = rsmState1, - )) - - assertNotNull(GLL(rsmState0, input).parse()) - } - - @ParameterizedTest(name = "Should be NotNull for {0}") - @ValueSource(strings = ["a", "aa", "aaa"]) - fun `test 'a-plus' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - ) - nonterminalS.startState = rsmState0 - val rsmState1 = - RSMState( - id = 1, - nonterminal = nonterminalS, - isFinal = true, - ) - rsmState0.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("a"), - head = rsmState1, - )) - rsmState1.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("a"), - head = rsmState1, - )) - - assertNotNull(GLL(rsmState0, input).parse()) - } - - @ParameterizedTest(name = "Should be NotNull for {0}") - @ValueSource(strings = ["", "ab", "abab", "ababab"]) - fun `test '(ab)-star' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - isFinal = true, - ) - nonterminalS.startState = rsmState0 - val rsmState1 = - RSMState( - id = 1, - nonterminal = nonterminalS, - isFinal = true, - ) - rsmState0.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("ab"), - head = rsmState1, - )) - rsmState1.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("ab"), - head = rsmState1, - )) - - assertNotNull(GLL(rsmState0, input).parse()) - } - - @ParameterizedTest(name = "Should be NotNull for {0}") - @ValueSource( - strings = - [ - "", - "()", - "()()", - "()()()", - "(())", - "(())()", - "(())()()", - "(())(())", - "(())(())()", - "(())(())()()", - "(()())(()())", - "((()))", - "(((())))", - "((((()))))", - ]) - fun `test 'dyck' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - isFinal = true, - ) - nonterminalS.startState = rsmState0 - val rsmState1 = - RSMState( - id = 1, - nonterminal = nonterminalS, - ) - val rsmState2 = - RSMState( - id = 2, - nonterminal = nonterminalS, - ) - val rsmState3 = - RSMState( - id = 3, - nonterminal = nonterminalS, - ) - val rsmState4 = - RSMState( - id = 4, - nonterminal = nonterminalS, - isFinal = true, - ) - - rsmState0.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("("), - head = rsmState1, - )) - rsmState1.addNonterminalEdge( - RSMNonterminalEdge( - nonterminal = nonterminalS, - head = rsmState2, - )) - rsmState2.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal(")"), - head = rsmState3, - )) - rsmState3.addNonterminalEdge( - RSMNonterminalEdge( - nonterminal = nonterminalS, - head = rsmState4, - )) - - assertNotNull(GLL(rsmState0, input).parse()) - } - - @ParameterizedTest(name = "Should be NotNull for {0}") - @ValueSource(strings = ["ab", "cd"]) - fun `test 'ab or cd' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - ) - val rsmState1 = - RSMState( - id = 1, - nonterminal = nonterminalS, - isFinal = true, - ) - - nonterminalS.startState = rsmState0 - - rsmState0.addTerminalEdge(RSMTerminalEdge(terminal = Terminal("ab"), head = rsmState1)) - rsmState0.addTerminalEdge(RSMTerminalEdge(terminal = Terminal("cd"), head = rsmState1)) - - assertNotNull(GLL(rsmState0, input).parse()) - } - - @ParameterizedTest(name = "Should be NotNull for {0}") - @ValueSource(strings = ["", "a"]) - fun `test 'a-optional' hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - isFinal = true, - ) - val rsmState1 = - RSMState( - id = 1, - nonterminal = nonterminalS, - isFinal = true, - ) - - nonterminalS.startState = rsmState0 - - rsmState0.addTerminalEdge(RSMTerminalEdge(terminal = Terminal("a"), head = rsmState1)) - - assertNotNull(GLL(rsmState0, input).parse()) - } - - @ParameterizedTest(name = "Should be NotNull for {0}") - @ValueSource(strings = ["abc"]) - fun `test 'abc' ambiguous hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - val nonterminalA = Nonterminal("A") - val nonterminalB = Nonterminal("B") - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - ) - nonterminalS.startState = rsmState0 - val rsmState1 = - RSMState( - id = 1, - nonterminal = nonterminalS, - ) - val rsmState2 = - RSMState( - id = 2, - nonterminal = nonterminalS, - ) - val rsmState3 = - RSMState( - id = 3, - nonterminal = nonterminalS, - isFinal = true, - ) - val rsmState4 = - RSMState( - id = 4, - nonterminal = nonterminalS, - ) - val rsmState5 = - RSMState( - id = 5, - nonterminal = nonterminalS, - isFinal = true, - ) - val rsmState6 = - RSMState( - id = 6, - nonterminal = nonterminalA, - isStart = true, - ) - nonterminalA.startState = rsmState6 - val rsmState7 = - RSMState( - id = 7, - nonterminal = nonterminalA, - ) - val rsmState8 = - RSMState( - id = 8, - nonterminal = nonterminalA, - isFinal = true, - ) - val rsmState9 = - RSMState( - id = 9, - nonterminal = nonterminalB, - isStart = true, - ) - nonterminalB.startState = rsmState9 - val rsmState10 = - RSMState( - id = 10, - nonterminal = nonterminalB, - isFinal = true, - ) - - rsmState0.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("a"), - head = rsmState1, - )) - rsmState1.addNonterminalEdge( - RSMNonterminalEdge( - nonterminal = nonterminalB, - head = rsmState2, - )) - rsmState2.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("c"), - head = rsmState3, - )) - rsmState0.addNonterminalEdge( - RSMNonterminalEdge( - nonterminal = nonterminalA, - head = rsmState4, - )) - rsmState4.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("c"), - head = rsmState5, - )) - - rsmState6.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("a"), - head = rsmState7, - )) - rsmState7.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("b"), - head = rsmState8, - )) - - rsmState9.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("b"), - head = rsmState10, - )) - - assertNotNull(GLL(rsmState0, input).parse()) - } - - @ParameterizedTest(name = "Should be NotNull for {0}") - @ValueSource(strings = ["ab", "cd"]) - fun `test 'ab or cd' ambiguous hand-crafted grammar`(input: String) { - val nonterminalS = Nonterminal("S") - val nonterminalA = Nonterminal("A") - val nonterminalB = Nonterminal("B") - - val rsmState0 = - RSMState( - id = 0, - nonterminal = nonterminalS, - isStart = true, - ) - nonterminalS.startState = rsmState0 - val rsmState1 = - RSMState( - id = 1, - nonterminal = nonterminalS, - isFinal = true, - ) - val rsmState2 = - RSMState( - id = 2, - nonterminal = nonterminalS, - isFinal = true, - ) - val rsmState3 = - RSMState( - id = 3, - nonterminal = nonterminalA, - isStart = true, - ) - nonterminalA.startState = rsmState3 - val rsmState4 = - RSMState( - id = 4, - nonterminal = nonterminalA, - isFinal = true, - ) - val rsmState5 = - RSMState( - id = 5, - nonterminal = nonterminalA, - isFinal = true, - ) - val rsmState6 = - RSMState( - id = 6, - nonterminal = nonterminalB, - isStart = true, - ) - nonterminalB.startState = rsmState6 - val rsmState7 = RSMState(id = 7, nonterminal = nonterminalB, isFinal = true) - val rsmState8 = - RSMState( - id = 8, - nonterminal = nonterminalB, - isFinal = true, - ) - - rsmState0.addNonterminalEdge( - RSMNonterminalEdge( - nonterminal = nonterminalA, - head = rsmState1, - )) - rsmState0.addNonterminalEdge( - RSMNonterminalEdge( - nonterminal = nonterminalB, - head = rsmState2, - )) - rsmState3.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("ab"), - head = rsmState4, - )) - rsmState3.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("cd"), - head = rsmState5, - )) - rsmState6.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("ab"), - head = rsmState7, - )) - rsmState6.addTerminalEdge( - RSMTerminalEdge( - terminal = Terminal("cd"), - head = rsmState8, - )) - - assertNotNull(GLL(rsmState0, input).parse()) - } -} diff --git a/src/test/resources/cli/TestCFGReadWriteTXT/a.txt b/src/test/resources/cli/TestCFGReadWriteTXT/a.txt deleted file mode 100644 index 1e317cf69..000000000 --- a/src/test/resources/cli/TestCFGReadWriteTXT/a.txt +++ /dev/null @@ -1,2 +0,0 @@ -StartNonterminal("S") -Nonterminal("S") -> Terminal("a") diff --git a/src/test/resources/cli/TestCFGReadWriteTXT/a_star.txt b/src/test/resources/cli/TestCFGReadWriteTXT/a_star.txt deleted file mode 100644 index dd3287a07..000000000 --- a/src/test/resources/cli/TestCFGReadWriteTXT/a_star.txt +++ /dev/null @@ -1,3 +0,0 @@ -StartNonterminal("S") -Nonterminal("S") -> Terminal("a") -Nonterminal("S") -> Terminal("a") Nonterminal("S") diff --git a/src/test/resources/cli/TestCFGReadWriteTXT/c_analysis.txt b/src/test/resources/cli/TestCFGReadWriteTXT/c_analysis.txt deleted file mode 100644 index 5d70e103c..000000000 --- a/src/test/resources/cli/TestCFGReadWriteTXT/c_analysis.txt +++ /dev/null @@ -1,9 +0,0 @@ -StartNonterminal("S") -Nonterminal("S") -> Terminal("d_r") Nonterminal("V") Terminal("d") -Nonterminal("V") -> Nonterminal("V1") Nonterminal("V2") Nonterminal("V3") -Nonterminal("V1") -> -Nonterminal("V1") -> Nonterminal("V2") Terminal("a_r") Nonterminal("V1") -Nonterminal("V2") -> -Nonterminal("V2") -> Nonterminal("S") -Nonterminal("V3") -> -Nonterminal("V3") -> Terminal("a") Nonterminal("V2") Nonterminal("V3") diff --git a/src/test/resources/cli/TestCFGReadWriteTXT/c_analysis_reg1.txt b/src/test/resources/cli/TestCFGReadWriteTXT/c_analysis_reg1.txt deleted file mode 100644 index 0d653be32..000000000 --- a/src/test/resources/cli/TestCFGReadWriteTXT/c_analysis_reg1.txt +++ /dev/null @@ -1,3 +0,0 @@ -StartNonterminal("S") -Nonterminal("S") -> -Nonterminal("S") -> Terminal("a") Nonterminal("S") diff --git a/src/test/resources/cli/TestCFGReadWriteTXT/c_analysis_reg2.txt b/src/test/resources/cli/TestCFGReadWriteTXT/c_analysis_reg2.txt deleted file mode 100644 index 7d5695f9d..000000000 --- a/src/test/resources/cli/TestCFGReadWriteTXT/c_analysis_reg2.txt +++ /dev/null @@ -1,5 +0,0 @@ -StartNonterminal("S") -Nonterminal("S") -> -Nonterminal("S") -> Terminal("a") Nonterminal("A") -Nonterminal("A") -> -Nonterminal("A") -> Terminal("d") Nonterminal("A") diff --git a/src/test/resources/cli/TestCFGReadWriteTXT/c_analysis_reg3.txt b/src/test/resources/cli/TestCFGReadWriteTXT/c_analysis_reg3.txt deleted file mode 100644 index 91ab7213f..000000000 --- a/src/test/resources/cli/TestCFGReadWriteTXT/c_analysis_reg3.txt +++ /dev/null @@ -1,4 +0,0 @@ -StartNonterminal("S") -Nonterminal("S") -> -Nonterminal("S") -> Terminal("a") Nonterminal("S") -Nonterminal("S") -> Terminal("d") Nonterminal("S") diff --git a/src/test/resources/cli/TestCFGReadWriteTXT/c_analysis_reg4.txt b/src/test/resources/cli/TestCFGReadWriteTXT/c_analysis_reg4.txt deleted file mode 100644 index f58049c21..000000000 --- a/src/test/resources/cli/TestCFGReadWriteTXT/c_analysis_reg4.txt +++ /dev/null @@ -1,6 +0,0 @@ -StartNonterminal("S") -Nonterminal("S") -> Nonterminal("A") Nonterminal("B") -Nonterminal("A") -> -Nonterminal("A") -> Terminal("a") Nonterminal("A") -Nonterminal("B") -> -Nonterminal("B") -> Terminal("d") Nonterminal("B") diff --git a/src/test/resources/cli/TestCFGReadWriteTXT/dyck.txt b/src/test/resources/cli/TestCFGReadWriteTXT/dyck.txt deleted file mode 100644 index ac8777c95..000000000 --- a/src/test/resources/cli/TestCFGReadWriteTXT/dyck.txt +++ /dev/null @@ -1,3 +0,0 @@ -StartNonterminal("S") -Nonterminal("S") -> Terminal("(") Nonterminal("S") Terminal(")") Nonterminal("S") -Nonterminal("S") -> diff --git a/src/test/resources/cli/TestCFGReadWriteTXT/g1.txt b/src/test/resources/cli/TestCFGReadWriteTXT/g1.txt deleted file mode 100644 index 875461d1b..000000000 --- a/src/test/resources/cli/TestCFGReadWriteTXT/g1.txt +++ /dev/null @@ -1,5 +0,0 @@ -StartNonterminal("S") -Nonterminal("S") -> Terminal("subClassOf_r") Nonterminal("S") Terminal("subClassOf") -Nonterminal("S") -> Terminal("subClassOf_r") Terminal("subClassOf") -Nonterminal("S") -> Terminal("type_r") Nonterminal("S") Terminal("type") -Nonterminal("S") -> Terminal("type_r") Terminal("type") diff --git a/src/test/resources/cli/TestCFGReadWriteTXT/g2.txt b/src/test/resources/cli/TestCFGReadWriteTXT/g2.txt deleted file mode 100644 index 60a21b666..000000000 --- a/src/test/resources/cli/TestCFGReadWriteTXT/g2.txt +++ /dev/null @@ -1,3 +0,0 @@ -StartNonterminal("S") -Nonterminal("S") -> Terminal("subClassOf_r") Nonterminal("S") Terminal("subClassOf") -Nonterminal("S") -> Terminal("subClassOf") diff --git a/src/test/resources/cli/TestCFGReadWriteTXT/geo.txt b/src/test/resources/cli/TestCFGReadWriteTXT/geo.txt deleted file mode 100644 index 801a1b6cd..000000000 --- a/src/test/resources/cli/TestCFGReadWriteTXT/geo.txt +++ /dev/null @@ -1,3 +0,0 @@ -StartNonterminal("S") -Nonterminal("S") -> Terminal("broaderTransitive") Nonterminal("S") Terminal("broaderTransitive_r") -Nonterminal("S") -> Terminal("broaderTransitive") Terminal("broaderTransitive_r") diff --git a/src/test/resources/cli/TestCFGReadWriteTXT/rdf_reg1.txt b/src/test/resources/cli/TestCFGReadWriteTXT/rdf_reg1.txt deleted file mode 100644 index 202095205..000000000 --- a/src/test/resources/cli/TestCFGReadWriteTXT/rdf_reg1.txt +++ /dev/null @@ -1,3 +0,0 @@ -StartNonterminal("S") -Nonterminal("S") -> -Nonterminal("S") -> Terminal("type") Nonterminal("S") diff --git a/src/test/resources/cli/TestCFGReadWriteTXT/rdf_reg2.txt b/src/test/resources/cli/TestCFGReadWriteTXT/rdf_reg2.txt deleted file mode 100644 index 3f77af871..000000000 --- a/src/test/resources/cli/TestCFGReadWriteTXT/rdf_reg2.txt +++ /dev/null @@ -1,5 +0,0 @@ -StartNonterminal("S") -Nonterminal("S") -> -Nonterminal("S") -> Terminal("type") Nonterminal("A") -Nonterminal("A") -> -Nonterminal("A") -> Terminal("subClassOf") Nonterminal("A") diff --git a/src/test/resources/cli/TestCFGReadWriteTXT/rdf_reg3.txt b/src/test/resources/cli/TestCFGReadWriteTXT/rdf_reg3.txt deleted file mode 100644 index 3488f18f8..000000000 --- a/src/test/resources/cli/TestCFGReadWriteTXT/rdf_reg3.txt +++ /dev/null @@ -1,4 +0,0 @@ -StartNonterminal("S") -Nonterminal("S") -> -Nonterminal("S") -> Terminal("type") Nonterminal("S") -Nonterminal("S") -> Terminal("subClassOf") Nonterminal("S") diff --git a/src/test/resources/cli/TestCFGReadWriteTXT/rdf_reg4.txt b/src/test/resources/cli/TestCFGReadWriteTXT/rdf_reg4.txt deleted file mode 100644 index 5c3a208a5..000000000 --- a/src/test/resources/cli/TestCFGReadWriteTXT/rdf_reg4.txt +++ /dev/null @@ -1,6 +0,0 @@ -StartNonterminal("S") -Nonterminal("S") -> Nonterminal("A") Nonterminal("B") -Nonterminal("A") -> -Nonterminal("A") -> Terminal("type") Nonterminal("A") -Nonterminal("B") -> -Nonterminal("B") -> Terminal("subClassOf") Nonterminal("B") diff --git a/src/test/resources/cli/TestGraphReadWriteCSV/OneCycleGraph.csv b/src/test/resources/cli/TestGraphReadWriteCSV/OneCycleGraph.csv deleted file mode 100644 index 713ac3d17..000000000 --- a/src/test/resources/cli/TestGraphReadWriteCSV/OneCycleGraph.csv +++ /dev/null @@ -1,3 +0,0 @@ -0 1 a -1 2 a -2 0 a diff --git a/src/test/resources/cli/TestGraphReadWriteCSV/OneEdgeGraph.csv b/src/test/resources/cli/TestGraphReadWriteCSV/OneEdgeGraph.csv deleted file mode 100644 index 3ac778d22..000000000 --- a/src/test/resources/cli/TestGraphReadWriteCSV/OneEdgeGraph.csv +++ /dev/null @@ -1 +0,0 @@ -0 1 a diff --git a/src/test/resources/cli/TestGraphReadWriteCSV/TwoEdgesGraph.csv b/src/test/resources/cli/TestGraphReadWriteCSV/TwoEdgesGraph.csv deleted file mode 100644 index dffa820e8..000000000 --- a/src/test/resources/cli/TestGraphReadWriteCSV/TwoEdgesGraph.csv +++ /dev/null @@ -1,2 +0,0 @@ -0 1 a -0 2 b diff --git a/src/test/resources/cli/TestGraphReadWriteCSV/dyck.csv b/src/test/resources/cli/TestGraphReadWriteCSV/dyck.csv deleted file mode 100644 index 8caf7cda2..000000000 --- a/src/test/resources/cli/TestGraphReadWriteCSV/dyck.csv +++ /dev/null @@ -1,5 +0,0 @@ -0 1 ( -1 2 ( -2 0 ( -2 3 ) -3 2 ) diff --git a/src/test/resources/cli/TestRSMReadWriteTXT/a.txt b/src/test/resources/cli/TestRSMReadWriteTXT/a.txt deleted file mode 100644 index b2a2b54ba..000000000 --- a/src/test/resources/cli/TestRSMReadWriteTXT/a.txt +++ /dev/null @@ -1,4 +0,0 @@ -StartState(id=0,nonterminal=Nonterminal("S"),isStart=true,isFinal=false) -State(id=0,nonterminal=Nonterminal("S"),isStart=true,isFinal=false) -State(id=1,nonterminal=Nonterminal("S"),isStart=false,isFinal=true) -TerminalEdge(tail=0,head=1,terminal=Terminal("a")) diff --git a/src/test/resources/cli/TestRSMReadWriteTXT/a_star.txt b/src/test/resources/cli/TestRSMReadWriteTXT/a_star.txt deleted file mode 100644 index 3d7c00e23..000000000 --- a/src/test/resources/cli/TestRSMReadWriteTXT/a_star.txt +++ /dev/null @@ -1,5 +0,0 @@ -StartState(id=0,nonterminal=Nonterminal("S"),isStart=true,isFinal=false) -State(id=0,nonterminal=Nonterminal("S"),isStart=true,isFinal=false) -State(id=1,nonterminal=Nonterminal("S"),isStart=false,isFinal=true) -TerminalEdge(tail=0,head=1,terminal=Terminal("a")) -TerminalEdge(tail=1,head=1,terminal=Terminal("a")) diff --git a/src/test/resources/cli/TestRSMReadWriteTXT/abc.txt b/src/test/resources/cli/TestRSMReadWriteTXT/abc.txt deleted file mode 100644 index aafaacad3..000000000 --- a/src/test/resources/cli/TestRSMReadWriteTXT/abc.txt +++ /dev/null @@ -1,20 +0,0 @@ -StartState(id=0,nonterminal=Nonterminal("S"),isStart=true,isFinal=false) -State(id=0,nonterminal=Nonterminal("S"),isStart=true,isFinal=false) -State(id=1,nonterminal=Nonterminal("S"),isStart=false,isFinal=false) -State(id=4,nonterminal=Nonterminal("S"),isStart=false,isFinal=false) -State(id=6,nonterminal=Nonterminal("A"),isStart=true,isFinal=false) -State(id=2,nonterminal=Nonterminal("S"),isStart=false,isFinal=false) -State(id=9,nonterminal=Nonterminal("B"),isStart=true,isFinal=false) -State(id=5,nonterminal=Nonterminal("S"),isStart=false,isFinal=true) -State(id=7,nonterminal=Nonterminal("A"),isStart=false,isFinal=false) -State(id=3,nonterminal=Nonterminal("S"),isStart=false,isFinal=true) -State(id=10,nonterminal=Nonterminal("B"),isStart=false,isFinal=true) -State(id=8,nonterminal=Nonterminal("A"),isStart=false,isFinal=true) -TerminalEdge(tail=0,head=1,terminal=Terminal("a")) -NonterminalEdge(tail=0,head=4,nonterminal=Nonterminal("A")) -NonterminalEdge(tail=1,head=2,nonterminal=Nonterminal("B")) -TerminalEdge(tail=4,head=5,terminal=Terminal("c")) -TerminalEdge(tail=6,head=7,terminal=Terminal("a")) -TerminalEdge(tail=2,head=3,terminal=Terminal("c")) -TerminalEdge(tail=9,head=10,terminal=Terminal("b")) -TerminalEdge(tail=7,head=8,terminal=Terminal("b")) diff --git a/src/test/resources/cli/TestRSMReadWriteTXT/c_analysis.txt b/src/test/resources/cli/TestRSMReadWriteTXT/c_analysis.txt deleted file mode 100644 index a8f53a1f1..000000000 --- a/src/test/resources/cli/TestRSMReadWriteTXT/c_analysis.txt +++ /dev/null @@ -1,27 +0,0 @@ -StartState(id=0,nonterminal=Nonterminal("S"),isStart=true,isFinal=false) -State(id=0,nonterminal=Nonterminal("S"),isStart=true,isFinal=false) -State(id=1,nonterminal=Nonterminal("S"),isStart=false,isFinal=false) -State(id=2,nonterminal=Nonterminal("S"),isStart=false,isFinal=false) -State(id=4,nonterminal=Nonterminal("V"),isStart=true,isFinal=true) -State(id=3,nonterminal=Nonterminal("S"),isStart=false,isFinal=true) -State(id=6,nonterminal=Nonterminal("V"),isStart=false,isFinal=true) -State(id=8,nonterminal=Nonterminal("V"),isStart=false,isFinal=true) -State(id=5,nonterminal=Nonterminal("V"),isStart=false,isFinal=false) -State(id=7,nonterminal=Nonterminal("V"),isStart=false,isFinal=true) -State(id=9,nonterminal=Nonterminal("V"),isStart=false,isFinal=true) -TerminalEdge(tail=0,head=1,terminal=Terminal("d_r")) -NonterminalEdge(tail=1,head=2,nonterminal=Nonterminal("V")) -TerminalEdge(tail=2,head=3,terminal=Terminal("d")) -TerminalEdge(tail=4,head=6,terminal=Terminal("a_r")) -TerminalEdge(tail=4,head=8,terminal=Terminal("a")) -NonterminalEdge(tail=4,head=5,nonterminal=Nonterminal("S")) -NonterminalEdge(tail=4,head=7,nonterminal=Nonterminal("S")) -TerminalEdge(tail=6,head=8,terminal=Terminal("a")) -TerminalEdge(tail=6,head=6,terminal=Terminal("a_r")) -NonterminalEdge(tail=6,head=5,nonterminal=Nonterminal("S")) -NonterminalEdge(tail=6,head=7,nonterminal=Nonterminal("S")) -TerminalEdge(tail=8,head=8,terminal=Terminal("a")) -NonterminalEdge(tail=8,head=9,nonterminal=Nonterminal("S")) -TerminalEdge(tail=5,head=6,terminal=Terminal("a_r")) -TerminalEdge(tail=7,head=8,terminal=Terminal("a")) -TerminalEdge(tail=9,head=8,terminal=Terminal("a")) diff --git a/src/test/resources/cli/TestRSMReadWriteTXT/c_analysis_reg1.txt b/src/test/resources/cli/TestRSMReadWriteTXT/c_analysis_reg1.txt deleted file mode 100644 index 2ce711d42..000000000 --- a/src/test/resources/cli/TestRSMReadWriteTXT/c_analysis_reg1.txt +++ /dev/null @@ -1,3 +0,0 @@ -StartState(id=0,nonterminal=Nonterminal("S"),isStart=true,isFinal=true) -State(id=0,nonterminal=Nonterminal("S"),isStart=true,isFinal=true) -TerminalEdge(tail=0,head=0,terminal=Terminal("a")) diff --git a/src/test/resources/cli/TestRSMReadWriteTXT/c_analysis_reg2.txt b/src/test/resources/cli/TestRSMReadWriteTXT/c_analysis_reg2.txt deleted file mode 100644 index 0083b84d3..000000000 --- a/src/test/resources/cli/TestRSMReadWriteTXT/c_analysis_reg2.txt +++ /dev/null @@ -1,5 +0,0 @@ -StartState(id=0,nonterminal=Nonterminal("S"),isStart=true,isFinal=false) -State(id=0,nonterminal=Nonterminal("S"),isStart=true,isFinal=false) -State(id=1,nonterminal=Nonterminal("S"),isStart=false,isFinal=true) -TerminalEdge(tail=0,head=1,terminal=Terminal("a")) -TerminalEdge(tail=1,head=1,terminal=Terminal("d")) diff --git a/src/test/resources/cli/TestRSMReadWriteTXT/c_analysis_reg3.txt b/src/test/resources/cli/TestRSMReadWriteTXT/c_analysis_reg3.txt deleted file mode 100644 index a1a04dcf2..000000000 --- a/src/test/resources/cli/TestRSMReadWriteTXT/c_analysis_reg3.txt +++ /dev/null @@ -1,4 +0,0 @@ -StartState(id=0,nonterminal=Nonterminal("S"),isStart=true,isFinal=true) -State(id=0,nonterminal=Nonterminal("S"),isStart=true,isFinal=true) -TerminalEdge(tail=0,head=0,terminal=Terminal("a")) -TerminalEdge(tail=0,head=0,terminal=Terminal("d")) diff --git a/src/test/resources/cli/TestRSMReadWriteTXT/c_analysis_reg4.txt b/src/test/resources/cli/TestRSMReadWriteTXT/c_analysis_reg4.txt deleted file mode 100644 index b013ce1e2..000000000 --- a/src/test/resources/cli/TestRSMReadWriteTXT/c_analysis_reg4.txt +++ /dev/null @@ -1,6 +0,0 @@ -StartState(id=0,nonterminal=Nonterminal("S"),isStart=true,isFinal=true) -State(id=0,nonterminal=Nonterminal("S"),isStart=true,isFinal=true) -State(id=1,nonterminal=Nonterminal("S"),isStart=false,isFinal=true) -TerminalEdge(tail=0,head=0,terminal=Terminal("a")) -TerminalEdge(tail=0,head=1,terminal=Terminal("d")) -TerminalEdge(tail=1,head=1,terminal=Terminal("d")) diff --git a/src/test/resources/cli/TestRSMReadWriteTXT/dyck.txt b/src/test/resources/cli/TestRSMReadWriteTXT/dyck.txt deleted file mode 100644 index 26f196c63..000000000 --- a/src/test/resources/cli/TestRSMReadWriteTXT/dyck.txt +++ /dev/null @@ -1,10 +0,0 @@ -StartState(id=0,nonterminal=Nonterminal("S"),isStart=true,isFinal=true) -State(id=0,nonterminal=Nonterminal("S"),isStart=true,isFinal=true) -State(id=1,nonterminal=Nonterminal("S"),isStart=false,isFinal=false) -State(id=2,nonterminal=Nonterminal("S"),isStart=false,isFinal=false) -State(id=3,nonterminal=Nonterminal("S"),isStart=false,isFinal=false) -State(id=4,nonterminal=Nonterminal("S"),isStart=false,isFinal=true) -TerminalEdge(tail=0,head=1,terminal=Terminal("(")) -NonterminalEdge(tail=1,head=2,nonterminal=Nonterminal("S")) -TerminalEdge(tail=2,head=3,terminal=Terminal(")")) -NonterminalEdge(tail=3,head=4,nonterminal=Nonterminal("S")) diff --git a/src/test/resources/cli/TestRSMReadWriteTXT/g1.txt b/src/test/resources/cli/TestRSMReadWriteTXT/g1.txt deleted file mode 100644 index 699a9bfc1..000000000 --- a/src/test/resources/cli/TestRSMReadWriteTXT/g1.txt +++ /dev/null @@ -1,15 +0,0 @@ -StartState(id=0,nonterminal=Nonterminal("S"),isStart=true,isFinal=false) -State(id=0,nonterminal=Nonterminal("S"),isStart=true,isFinal=false) -State(id=1,nonterminal=Nonterminal("S"),isStart=false,isFinal=false) -State(id=4,nonterminal=Nonterminal("S"),isStart=false,isFinal=false) -State(id=3,nonterminal=Nonterminal("S"),isStart=false,isFinal=true) -State(id=2,nonterminal=Nonterminal("S"),isStart=false,isFinal=false) -State(id=5,nonterminal=Nonterminal("S"),isStart=false,isFinal=false) -TerminalEdge(tail=0,head=1,terminal=Terminal("subClassOf_r")) -TerminalEdge(tail=0,head=4,terminal=Terminal("type_r")) -TerminalEdge(tail=1,head=3,terminal=Terminal("subClassOf")) -NonterminalEdge(tail=1,head=2,nonterminal=Nonterminal("S")) -TerminalEdge(tail=4,head=3,terminal=Terminal("type")) -NonterminalEdge(tail=4,head=5,nonterminal=Nonterminal("S")) -TerminalEdge(tail=2,head=3,terminal=Terminal("subClassOf")) -TerminalEdge(tail=5,head=3,terminal=Terminal("type")) diff --git a/src/test/resources/cli/TestRSMReadWriteTXT/g2.txt b/src/test/resources/cli/TestRSMReadWriteTXT/g2.txt deleted file mode 100644 index ff63c938c..000000000 --- a/src/test/resources/cli/TestRSMReadWriteTXT/g2.txt +++ /dev/null @@ -1,9 +0,0 @@ -StartState(id=0,nonterminal=Nonterminal("S"),isStart=true,isFinal=false) -State(id=0,nonterminal=Nonterminal("S"),isStart=true,isFinal=false) -State(id=1,nonterminal=Nonterminal("S"),isStart=false,isFinal=false) -State(id=3,nonterminal=Nonterminal("S"),isStart=false,isFinal=true) -State(id=2,nonterminal=Nonterminal("S"),isStart=false,isFinal=false) -TerminalEdge(tail=0,head=1,terminal=Terminal("subClassOf_r")) -TerminalEdge(tail=0,head=3,terminal=Terminal("subClassOf")) -NonterminalEdge(tail=1,head=2,nonterminal=Nonterminal("S")) -TerminalEdge(tail=2,head=3,terminal=Terminal("subClassOf")) diff --git a/src/test/resources/cli/TestRSMReadWriteTXT/geo.txt b/src/test/resources/cli/TestRSMReadWriteTXT/geo.txt deleted file mode 100644 index 8f103bc81..000000000 --- a/src/test/resources/cli/TestRSMReadWriteTXT/geo.txt +++ /dev/null @@ -1,9 +0,0 @@ -StartState(id=0,nonterminal=Nonterminal("S"),isStart=true,isFinal=false) -State(id=0,nonterminal=Nonterminal("S"),isStart=true,isFinal=false) -State(id=1,nonterminal=Nonterminal("S"),isStart=false,isFinal=false) -State(id=3,nonterminal=Nonterminal("S"),isStart=false,isFinal=true) -State(id=2,nonterminal=Nonterminal("S"),isStart=false,isFinal=false) -TerminalEdge(tail=0,head=1,terminal=Terminal("broaderTransitive")) -TerminalEdge(tail=1,head=3,terminal=Terminal("broaderTransitive_r")) -NonterminalEdge(tail=1,head=2,nonterminal=Nonterminal("S")) -TerminalEdge(tail=2,head=3,terminal=Terminal("broaderTransitive_r")) diff --git a/src/test/resources/cli/TestRSMReadWriteTXT/rdf_reg1.txt b/src/test/resources/cli/TestRSMReadWriteTXT/rdf_reg1.txt deleted file mode 100644 index d427dd630..000000000 --- a/src/test/resources/cli/TestRSMReadWriteTXT/rdf_reg1.txt +++ /dev/null @@ -1,3 +0,0 @@ -StartState(id=0,nonterminal=Nonterminal("S"),isStart=true,isFinal=true) -State(id=0,nonterminal=Nonterminal("S"),isStart=true,isFinal=true) -TerminalEdge(tail=0,head=0,terminal=Terminal("type")) diff --git a/src/test/resources/cli/TestRSMReadWriteTXT/rdf_reg2.txt b/src/test/resources/cli/TestRSMReadWriteTXT/rdf_reg2.txt deleted file mode 100644 index 4a0397dcc..000000000 --- a/src/test/resources/cli/TestRSMReadWriteTXT/rdf_reg2.txt +++ /dev/null @@ -1,5 +0,0 @@ -StartState(id=0,nonterminal=Nonterminal("S"),isStart=true,isFinal=false) -State(id=0,nonterminal=Nonterminal("S"),isStart=true,isFinal=false) -State(id=1,nonterminal=Nonterminal("S"),isStart=false,isFinal=true) -TerminalEdge(tail=0,head=1,terminal=Terminal("type")) -TerminalEdge(tail=1,head=1,terminal=Terminal("subClassOf")) diff --git a/src/test/resources/cli/TestRSMReadWriteTXT/rdf_reg3.txt b/src/test/resources/cli/TestRSMReadWriteTXT/rdf_reg3.txt deleted file mode 100644 index d7d9d74c2..000000000 --- a/src/test/resources/cli/TestRSMReadWriteTXT/rdf_reg3.txt +++ /dev/null @@ -1,4 +0,0 @@ -StartState(id=0,nonterminal=Nonterminal("S"),isStart=true,isFinal=true) -State(id=0,nonterminal=Nonterminal("S"),isStart=true,isFinal=true) -TerminalEdge(tail=0,head=0,terminal=Terminal("type")) -TerminalEdge(tail=0,head=0,terminal=Terminal("subClassOf")) diff --git a/src/test/resources/cli/TestRSMReadWriteTXT/rdf_reg4.txt b/src/test/resources/cli/TestRSMReadWriteTXT/rdf_reg4.txt deleted file mode 100644 index 34d8f940d..000000000 --- a/src/test/resources/cli/TestRSMReadWriteTXT/rdf_reg4.txt +++ /dev/null @@ -1,6 +0,0 @@ -StartState(id=0,nonterminal=Nonterminal("S"),isStart=true,isFinal=true) -State(id=0,nonterminal=Nonterminal("S"),isStart=true,isFinal=true) -State(id=1,nonterminal=Nonterminal("S"),isStart=false,isFinal=true) -TerminalEdge(tail=0,head=0,terminal=Terminal("type")) -TerminalEdge(tail=0,head=1,terminal=Terminal("subClassOf")) -TerminalEdge(tail=1,head=1,terminal=Terminal("subClassOf")) diff --git a/test-shared/src/test/kotlin/parser/generated/GllGeneratedTest.kt b/test-shared/src/test/kotlin/parser/generated/GllGeneratedTest.kt deleted file mode 100644 index e69de29bb..000000000 diff --git a/test-shared/src/test/kotlin/parser/generated/IOfflineGllTest.kt b/test-shared/src/test/kotlin/parser/generated/IOfflineGllTest.kt deleted file mode 100644 index e69de29bb..000000000 diff --git a/test-shared/src/test/kotlin/parser/generated/RuntimeCompiler.kt b/test-shared/src/test/kotlin/parser/generated/RuntimeCompiler.kt deleted file mode 100644 index e69de29bb..000000000 diff --git a/test-shared/src/test/kotlin/parser/generated/ScanerlessGllGeneratedTest.kt b/test-shared/src/test/kotlin/parser/generated/ScanerlessGllGeneratedTest.kt deleted file mode 100644 index e69de29bb..000000000