diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index 83fa0bad9..5c933d8f4 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -1,42 +1,36 @@ -name: Build +name: Build project -on: [ push, pull_request, workflow_dispatch ] - -env: - GRADLE_BUILD_ACTION_CACHE_DEBUG_ENABLED: true +#workflow_dispatch -- for manual trigger +on: [ push, workflow_dispatch ] jobs: build: - strategy: - matrix: - os: [ ubuntu-latest, macos-latest, windows-latest ] - runs-on: ${{ matrix.os }} + + runs-on: ubuntu-latest steps: - name: Checkout - uses: actions/checkout@v4 + uses: actions/checkout@v3 - - name: Setup JDK 11 + - name: Set up JDK 11 uses: actions/setup-java@v3 with: - distribution: temurin - java-version: 11 + java-version: '11' + distribution: 'temurin' - - name: Execute Gradle `build` task - uses: gradle/gradle-build-action@v2 - with: - arguments: build --scan - cache-read-only: | - ${{ github.ref != 'refs/heads/main' && - github.ref != 'refs/heads/dev' }} - gradle-home-cache-includes: | - caches - notifications - jdks - - - name: Upload `build` report - if: always() - uses: actions/upload-artifact@v3 + - 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: - name: BuildReport-${{ matrix.os }} - path: build/reports/ \ No newline at end of file + arguments: build diff --git a/.gitignore b/.gitignore index 0c8ea9a61..4be53026b 100644 --- a/.gitignore +++ b/.gitignore @@ -1,57 +1,31 @@ -# Compiled class file -*.class - # Log file *.log - -# BlueJ files -*.ctxt - -# Mobile Tools for Java (J2ME) -.mtj.tmp/ - -# Package Files # -*.jar -*.war -*.nar -*.ear -*.zip -*.tar.gz -*.rar - -# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml -hs_err_pid* +*.logs .gradle -build/ !gradle/wrapper/gradle-wrapper.jar -!**/src/main/**/build/ -!**/src/test/**/build/ +**/build/ ### IntelliJ IDEA ### .idea - -### Eclipse ### -.apt_generated -.classpath -.factorypath -.project -.settings -.springBeans -.sts4-cache -bin/ -!**/src/main/**/bin/ -!**/src/test/**/bin/ - -### NetBeans ### -/nbproject/private/ -/nbbuild/ -/dist/ -/nbdist/ -/.nb-gradle/ - +./test-shared/gen ### VS Code ### .vscode/ ### Mac OS ### -.DS_Store \ No newline at end of file +.DS_Store + +### Generated files ### +/benchmarks/gen/ +/benchmarks/logs/ + +### Antlr parsers ### +/benchmarks/src/main/java/org/antlr/* +!/benchmarks/src/main/java/org/antlr/*.g4 + +### Jflex scanner ### +/benchmarks/src/main/java/org/ucfs/scanner/* +!/benchmarks/src/main/java/org/ucfs/scanner/*.flex + +### Large datasets ### +/benchmarks/src/test/resources/java/correct/* \ No newline at end of file diff --git a/README.md b/README.md index dfac771ed..d85f79c7f 100644 --- a/README.md +++ b/README.md @@ -1,191 +1,139 @@ + # UCFS -[![Build](https://github.com/FormalLanguageConstrainedPathQuerying/kotgll/actions/workflows/build.yml/badge.svg?branch=main)](https://github.com/FormalLanguageConstrainedPathQuerying/kotgll/actions/workflows/build.yml) -[![Test](https://github.com/FormalLanguageConstrainedPathQuerying/kotgll/actions/workflows/test.yml/badge.svg?branch=main)](https://github.com/FormalLanguageConstrainedPathQuerying/kotgll/actions/workflows/test.yml) - -* [About](https://github.com/FormalLanguageConstrainedPathQuerying/kotgll#about) -* [Usage](https://github.com/FormalLanguageConstrainedPathQuerying/kotgll#usage) - * [From sources](https://github.com/FormalLanguageConstrainedPathQuerying/kotgll#from-sources) - * [Using JAR](https://github.com/FormalLanguageConstrainedPathQuerying/kotgll#using-jar) - * [CFG Format Example](https://github.com/FormalLanguageConstrainedPathQuerying/kotgll#cfg-format-example) - * [RSM Format Example](https://github.com/FormalLanguageConstrainedPathQuerying/kotgll#rsm-format-example) -* [Performance](https://github.com/FormalLanguageConstrainedPathQuerying/kotgll#performance) - * [Graphs](https://github.com/FormalLanguageConstrainedPathQuerying/kotgll#graphs) - * [Grammars](https://github.com/FormalLanguageConstrainedPathQuerying/kotgll#grammars) - * [Results](https://github.com/FormalLanguageConstrainedPathQuerying/kotgll#results) - * [More results](https://github.com/FormalLanguageConstrainedPathQuerying/kotgll#more-results) > Note: project under heavy development! ## About -**UCFS** is an **U**nuversal **C**ontext-**F**ree **S**olver: a tool to solve problems related to context-free and regular language intersection. Examples of such problems: +**UCFS** is an **U**niversal **C**ontext-**F**ree **S**olver: a tool to solve problems related to context-free and regular language intersection. Examples of such problems: - Parsing - Context-free path querying (CFPQ) -- Context-free language reachability (CFL-r) - - - -## Usage - -### Command Line Interface - -```text -Usage: kotgll options_list -Options: - --input -> Input format (always required) { Value should be one of [string, graph] } - --grammar -> Grammar format (always required) { Value should be one of [cfg, rsm] } - --sppf [ON] -> Sppf mode { Value should be one of [on, off] } - --inputPath -> Path to input txt file (always required) { String } - --grammarPath -> Path to grammar txt file (always required) { String } - --outputPath -> Path to output txt file (always required) { String } - --help, -h -> Usage info +- Context-free language reachability (CFL-R) + + + +## Project structure +``` +├── solver -- base ucfs logic +├── benchmarks -- comparison with antlr4 +├── generator -- parser and ast node classes generator +├── examples -- examples of grammars +└── test-shared -- test cases + └── src + └── test + └── resources -- grammars' description and inputs ``` -### From sources - -#### Step 1. Clone repository - -`git clone https://github.com/FormalLanguageConstrainedPathQuerying/kotgll.git` - -or - -`git clone git@github.com:FormalLanguageConstrainedPathQuerying/kotgll.git` - -or - -`gh repo clone FormalLanguageConstrainedPathQuerying/kotgll` - -#### Step 2. Go to the folder - -`cd kotgll` +## 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). -#### Step 3. Run the help command +## Grammar Combinator -`gradle run --args="--help"` +Kotlin DSL for describing context-free grammars. -You will see the ["Options list"](https://github.com/FormalLanguageConstrainedPathQuerying/kotgll#command-line-interface) message. -#### Example -```text -gradle run --args="--input graph --grammar rsm --sppf off --inputPath src/test/resources/cli/TestGraphReadWriteCSV/dyck.csv --grammarPath src/test/resources/cli/TestRSMReadWriteTXT/dyck.txt --outputPath ./result.txt" -``` +### Declaration -### Using JAR +Example for A* grammar -#### Step 1. Download the latest JAR +*EBNF* +``` +A = "a" +S = A* +``` +*DSL* +```kotlin +class AStar : Grammar() { + var A = Term("a") + val S by Nt().asStart(many(A)) + } +``` +### Non-terminals -```text -curl -L -O https://github.com/FormalLanguageConstrainedPathQuerying/kotgll/releases/download/v1.0.0/kotgll-1.0.0.jar -``` +`val S by Nt()` -#### Step 2. Run JAR with Java +Non-terminals must be fields of the grammar class. Make sure to declare using delegation `by Nt()`! -```text -java -jar kotgll-1.0.0.jar --input graph --grammar rsm --sppf off --inputPath src/test/resources/cli/TestGraphReadWriteCSV/dyck.csv --grammarPath src/test/resources/cli/TestRSMReadWriteTXT/dyck.txt --outputPath ./result.txt -``` -### CFG Format Example - -```text -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") -``` +Start non-terminal set with method `setStart(nt)`. Or in initialization with Nt method `asStart`. -### RSM Format Example - -```text -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=6,nonterminal=Nonterminal("S"),isStart=false,isFinal=true) -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=6,terminal=Terminal("type")) -NonterminalEdge(tail=4,head=5,nonterminal=Nonterminal("S")) -TerminalEdge(tail=2,head=3,terminal=Terminal("subClassOf")) -TerminalEdge(tail=5,head=6,terminal=Terminal("type")) -``` + Can be set only once for grammar. -## Performance +### Terminals -The GLL algorithm has been modified to support graph input. -The proposed modification has been evaluated on several real graphs for the scenario of finding all pairs of reachability. +`val A = Term("a")` -**Machine configuration**: PC with Ubuntu 20.04, Intel Core i7-6700 3.40GHz CPU, DDR4 64Gb RAM. +`val B = Term(42)` -**Enviroment configuration**: -* Java HotSpot(TM) 64-Bit server virtual machine (build 15.0.2+7-27, mixed mode, sharing). -* JVM heap configuration: 55Gb both xms and xmx. +Terminal is a generic class. Can store terminals of any type. Terminals are compared based on their content. -### Graphs +They can be declared as fields of a grammar class or directly in productions. -The graph data is selected from [CFPQ_Data dataset](https://formallanguageconstrainedpathquerying.github.io/CFPQ_Data). +### Operations +Example for Dyck language -A detailed description of the graphs is listed bellow. +*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 * "}") -#### RDF analysis graphs + init { + //recursive nonterminals initialize in `init` block + S /= S * (Round or Quadrat or Curly) or Epsilon + } +} +``` +### Production +$A \Longrightarrow B \hspace{4pt} \overset{def}{=} \hspace{4pt} A$ \\= $B$ -| Graph name | \|*V*\| | \|*E*\| | #subClassOf | #type | #broaderTransitive | -|:------------|----------:|------------:|-------------:|-----------:|--------------------:| -| [Enzyme](https://formallanguageconstrainedpathquerying.github.io/CFPQ_Data/graphs/data/enzyme.html#enzyme) | 48 815 | 86 543 | 8 163 | 14 989 | 8 156 | -| [Eclass](https://formallanguageconstrainedpathquerying.github.io/CFPQ_Data/graphs/data/eclass.html#eclass) | 239 111 | 360 248 | 90 962 | 72 517 | 0 | -| [Go hierarchy](https://formallanguageconstrainedpathquerying.github.io/CFPQ_Data/graphs/data/go_hierarchy.html#go-hierarchy) | 45 007 | 490 109 | 490 109 | 0 | 0 | -| [Go](https://formallanguageconstrainedpathquerying.github.io/CFPQ_Data/graphs/data/go.html#go) | 582 929 | 1 437 437 | 94 514 | 226 481 | 0 | -| [Geospecies](https://formallanguageconstrainedpathquerying.github.io/CFPQ_Data/graphs/data/geospecies.html#geospecies) | 450 609 | 2 201 532 | 0 | 89 065 | 20 867 | -| [Taxonomy](https://formallanguageconstrainedpathquerying.github.io/CFPQ_Data/graphs/data/taxonomy.html#taxonomy) | 5 728 398 | 14 922 125 | 2 112 637 | 2 508 635 | 0 | +$A \Longrightarrow B \hspace{4pt} \overset{def}{=} \hspace{4pt} A~by~Nt(B)$ -### Grammars +### Concatenation +$( \hspace{4pt} \cdot \hspace{4pt} ) : \sum_∗ \times \sum_∗ → \sum_∗$ -All queries used in evaluation are variants of same-generation query. -The inverse of an ```x``` relation and the respective edge is denoted as ```x_r```. +$a \cdot b \hspace{4pt} \overset{def}{=} \hspace{4pt} a * b$ -
+### Alternative +$( \hspace{4pt} | \hspace{4pt} ) : \sum_∗ \times \sum_∗ → \sum_∗$ -Grammars used for **RDF** graphs: +$a \hspace{4pt} | \hspace{4pt} b \hspace{4pt} \overset{def}{=} \hspace{4pt} a \hspace{4pt} or \hspace{4pt} b$ -**G1** -``` -S -> subClassOf_r S subClassOf | subClassOf_r subClassOf - | type_r S type | type_r type -``` +### Kleene Star -The representation of **G1** context-free grammar in the repository can be found [here](https://github.com/FormalLanguageConstrainedPathQuerying/kotgll/blob/main/src/test/resources/cli/TestCFGReadWriteTXT/g1.txt). +$( \hspace{4pt} * \hspace{4pt} ) : \sum \to \sum_∗$ -The representation of **G1** context-free grammar as recursive automaton in the repository can be found [here](https://github.com/FormalLanguageConstrainedPathQuerying/kotgll/blob/main/src/test/resources/cli/TestRSMReadWriteTXT/g1.txt). +$a^* \hspace{4pt} \overset{def}{=} \hspace{4pt} \displaystyle\bigcup_{i = 0}^{\infty}a^i$ -### Results +$a^* \hspace{4pt} \overset{def}{=} \hspace{4pt} many(a)$ -The results of the **all pairs reachability** queries evaluation on graphs related to **RDF analysis** are listed below. +$a^+ \hspace{4pt} \overset{def}{=} \hspace{4pt} some(a)$ -In each row, the best mean time in seconds is highlighted in **bold**. +### Optional +$a? \hspace{4pt} \overset{def}{=} \hspace{4pt} a \hspace{4pt} or \hspace{4pt} Epsilon$ -| Graph | [CFG](https://github.com/FormalLanguageConstrainedPathQuerying/kotgll/tree/main/src/main/kotlin/org/kotgll/cfg/graphinput/withoutsppf) | [RSM](https://github.com/FormalLanguageConstrainedPathQuerying/kotgll/tree/main/src/main/kotlin/org/kotgll/rsm/graphinput/withoutsppf) | [GLL4Graph](https://github.com/FormalLanguageConstrainedPathQuerying/GLL4Graph) | -|-------------- |:-----: |:---------: |:---------: | -| [Enzyme](https://formallanguageconstrainedpathquerying.github.io/CFPQ_Data/graphs/data/enzyme.html#enzyme) | 0.107 | **0.044** | 0.22 | -| [Eclass](https://formallanguageconstrainedpathquerying.github.io/CFPQ_Data/graphs/data/eclass.html#eclass) | 0.94 | **0.43** | 1.5 | -| [Go hierarchy](https://formallanguageconstrainedpathquerying.github.io/CFPQ_Data/graphs/data/go_hierarchy.html#go-hierarchy) | 4.1 | **3.0** | 3.6 | -| [Go](https://formallanguageconstrainedpathquerying.github.io/CFPQ_Data/graphs/data/go.html#go) | 3.2 | **1.86** | 5.55 | -| [Geospecies](https://formallanguageconstrainedpathquerying.github.io/CFPQ_Data/graphs/data/geospecies.html#geospecies) | 0.97 | **0.34** | 2.89 | -| [Taxonomy](https://formallanguageconstrainedpathquerying.github.io/CFPQ_Data/graphs/data/taxonomy.html#taxonomy) | 31.2 | **14.8** | 45.4 | +Epsilon -- constant terminal with behavior corresponding to the $\varepsilon$ -- terminal (empty string). -#### More results +$a? \hspace{4pt} \overset{def}{=} \hspace{4pt} opt(a)$ -More results, but in raw form, can be found in the repository [kotgll_benchmarks](https://github.com/vadyushkins/kotgll_benchmarks/) +### RSM +DSL provides access to the RSM corresponding to the grammar using the `getRsm` method. +The algorithm for RSM construction is based on Brzozowski derivations. diff --git a/all_test.py b/all_test.py new file mode 100644 index 000000000..01859f050 --- /dev/null +++ b/all_test.py @@ -0,0 +1,85 @@ +import os +import subprocess +import sys + +gradlew = "./gradlew" +task = ":test-shared:test" + +test_name = "" # example "solver.correctnessTests.AmbiguousAStar3GrammarTest.AmbiguousAStar3GrammarTreeCorrectnessTest" +test_case_name = "" # example "small_test" +def run_test_for_mem(test_name): + def get_cmd(mem): + return [ + gradlew, + task, + f"-DtestMaxHeapSize={mem}m", + "--tests", test_name, + f"-Dspecial_case={test_case_name}", + f"-Dcount_for_case=1", + f"-Dwrite_case_time=0" + ] + + cache = {} + + def execute(mem): + if mem in cache: + return cache[mem] + + cmd = get_cmd(mem) + try: + process = subprocess.run(cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,timeout=60) + return_code = process.returncode + except: + return_code = 1 + cache[mem] = return_code + return return_code + + l = 1 + r = 64 + max_mem = 4*1024 + while r <= max_mem: + return_code = execute(r) + print(r) + if return_code != 0: + l = r + r *= 2 + else: + break + if r == 2*max_mem: + return r + + while l < r - 1: + m = (l + r) // 2 + print(m) + return_code = execute(m) + + if return_code != 0: + l = m + else: + r = m + + return r + + +with open("tests_list.conf", "r") as input: + with open(f"res.txt", "w") as output: + output.write(f"test,case,mem\n") + for line in input: + config = line.split() + test_name = config[0] + test_case_name = config[1] + print(test_name) + print(test_case_name) + mem = run_test_for_mem(test_name) + cmd = [ + gradlew, + task, + f"-DtestMaxHeapSize=15m", + "--tests", test_name, + f"-Dspecial_case={test_case_name}", + f"-Dcount_for_case=1" + ] + process = subprocess.run(cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL) + return_code = process.returncode + print(f"Got for test = {test_name}: {mem}mb") + output.write(f"{test_name},{test_case_name},{mem}\n") diff --git a/benchmarks/README.md b/benchmarks/README.md new file mode 100644 index 000000000..afccf1dce --- /dev/null +++ b/benchmarks/README.md @@ -0,0 +1,19 @@ +# 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 new file mode 100644 index 000000000..a2944b5b1 --- /dev/null +++ b/benchmarks/build.gradle.kts @@ -0,0 +1,36 @@ +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 new file mode 100644 index 000000000..2de43ab72 --- /dev/null +++ b/benchmarks/gradle.properties @@ -0,0 +1,3 @@ +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 new file mode 100644 index 000000000..06febab41 --- /dev/null +++ b/benchmarks/gradle/wrapper/gradle-wrapper.properties @@ -0,0 +1,5 @@ +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 new file mode 100755 index 000000000..1b6c78733 --- /dev/null +++ b/benchmarks/gradlew @@ -0,0 +1,234 @@ +#!/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 new file mode 100644 index 000000000..107acd32c --- /dev/null +++ b/benchmarks/gradlew.bat @@ -0,0 +1,89 @@ +@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 new file mode 100755 index 000000000..a626537d3 --- /dev/null +++ b/benchmarks/scripts/extract_all_java_files.sh @@ -0,0 +1,43 @@ +#!/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 new file mode 100755 index 000000000..d8b8ba3ec --- /dev/null +++ b/benchmarks/scripts/generate_all.sh @@ -0,0 +1,42 @@ +#!/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 new file mode 100644 index 000000000..ccf3d38e7 --- /dev/null +++ b/benchmarks/scripts/mem_measure_bin_search.py @@ -0,0 +1,71 @@ + +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 new file mode 100644 index 000000000..7beefbe55 --- /dev/null +++ b/benchmarks/src/main/java/org/antlr/Java8Lexer.g4 @@ -0,0 +1,977 @@ +/* + * [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 new file mode 100644 index 000000000..8b6b46615 --- /dev/null +++ b/benchmarks/src/main/java/org/antlr/Java8Parser.g4 @@ -0,0 +1,1335 @@ +/* + * [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 new file mode 100644 index 000000000..b3de61fea --- /dev/null +++ b/benchmarks/src/main/java/org/antlr/fast/JavaLexer.g4 @@ -0,0 +1,233 @@ +/* + [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 new file mode 100644 index 000000000..a240eb308 --- /dev/null +++ b/benchmarks/src/main/java/org/antlr/fast/JavaParser.g4 @@ -0,0 +1,800 @@ +/* + [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 new file mode 100644 index 000000000..4d958c0dc --- /dev/null +++ b/benchmarks/src/main/java/org/ucfs/scanner/java.flex @@ -0,0 +1,281 @@ +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 new file mode 100644 index 000000000..bf567873d --- /dev/null +++ b/benchmarks/src/main/kotlin/Benchmarks.kt @@ -0,0 +1,56 @@ +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 new file mode 100644 index 000000000..a9f17c943 --- /dev/null +++ b/benchmarks/src/main/kotlin/UcfsRunExample.kt @@ -0,0 +1,14 @@ +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 new file mode 100644 index 000000000..01dce4c42 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/Generator.kt @@ -0,0 +1,35 @@ +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 new file mode 100644 index 000000000..8068df8e5 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/Java8.kt @@ -0,0 +1,933 @@ +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 new file mode 100644 index 000000000..adef2a51d --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/Java8Parser.kt @@ -0,0 +1,8655 @@ +@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 new file mode 100644 index 000000000..15a29e389 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/Java8ParserRecovery.kt @@ -0,0 +1,8659 @@ +@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 new file mode 100644 index 000000000..22e7115ba --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/JavaToken.kt @@ -0,0 +1,141 @@ +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 new file mode 100644 index 000000000..b3f815d13 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/AdditionalBoundNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..e8fe1d130 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/AdditiveExpressionNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..b645a83d4 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/AmbiguousNameNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..aa7004a5b --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/AndExpressionNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..133fac9a6 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/AnnotationNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..e2be87410 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/AnnotationTypeBodyNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..c3e6c4d32 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/AnnotationTypeDeclarationNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..efa568653 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/AnnotationTypeElementDeclarationNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..ab2f26049 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/AnnotationTypeElementModifierNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..ec0dd8d25 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/AnnotationTypeMemberDeclarationNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..12e8c8711 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/ArgumentListNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..e71758a66 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/ArrayAccessNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..6d4800a45 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/ArrayCreationExpressionNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..8fade6d36 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/ArrayInitializerNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..b8089fca3 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/ArrayTypeNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..62da27891 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/AssertStatementNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..118faf29e --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/AssignmentExpressionNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..853ba4130 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/AssignmentNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..5e312bf0c --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/AssignmentOperatorNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..140db0192 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/BasicForStatementNoShortIfNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..eb515045f --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/BasicForStatementNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..a2b1051f7 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/BlockNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..978df848a --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/BlockStatementNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..47247dc97 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/BlockStatementsNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..d982bc223 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/BreakStatementNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..249aa0ccd --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/CastExpressionNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..9aec602c5 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/CatchClauseNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..f100ecaed --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/CatchFormalParameterNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..364d604b0 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/CatchTypeNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..5d57b7567 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/CatchesNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..52ecbbe54 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/ClassBodyDeclarationNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..12cba5038 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/ClassBodyNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..8f824702d --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/ClassDeclarationNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..82fcf29b3 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/ClassInstanceCreationExpressionNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..43e71b58b --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/ClassLiteralNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..1733834d6 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/ClassMemberDeclarationNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..ec0b2dee0 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/ClassModifierNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..1b0dc2570 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/ClassOrInterfaceTypeNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..174111858 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/ClassTypeNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..ab84a346e --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/CompilationUnitNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..b719b6b3d --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/ConditionalAndExpressionNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..830854722 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/ConditionalExpressionNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..156243887 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/ConditionalOrExpressionNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..1c913a226 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/ConstantDeclarationNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..c43f1a398 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/ConstantExpressionNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..85f4cbaa3 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/ConstantModifierNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..4bdee3711 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/ConstructorBodyNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..1180cfa1e --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/ConstructorDeclarationNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..01aaaf4d5 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/ConstructorDeclaratorNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..d1de5c80c --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/ConstructorModifierNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..115223a0a --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/ContinueStatementNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..e63be6a8c --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/DefaultValueNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..22d51bf62 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/DimExprNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..ff24208c4 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/DimExprsNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..a666d2e93 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/DimsNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..40aa07c7e --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/DoStatementNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..701becd9f --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/ElementValueArrayInitializerNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..3dae2e432 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/ElementValueListNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..e9962da92 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/ElementValueNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..d87a7c26c --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/ElementValuePairListNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..2f2fd5d93 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/ElementValuePairNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..349fee518 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/EmptyStatementNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..aca13e448 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/EnhancedForStatementNoShortIfNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..3f63d7ee2 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/EnhancedForStatementNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..b420f7227 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/EnumBodyDeclarationsNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..454caddea --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/EnumBodyNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..3f7d1671f --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/EnumConstantListNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..5598360da --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/EnumConstantModifierNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..63e7d6364 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/EnumConstantNameNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..2df87c23d --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/EnumConstantNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..83d10b116 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/EnumDeclarationNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..669c4d453 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/EqualityExpressionNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..738efb3ce --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/ExceptionTypeListNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..41e372323 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/ExceptionTypeNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..ca5cd8a41 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/ExclusiveOrExpressionNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..b31e0cd6e --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/ExplicitConstructorInvocationNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..ebda33bbf --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/ExpressionNameNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..940032f81 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/ExpressionNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..838a64934 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/ExpressionStatementNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..ea31ad4ee --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/ExtendsInterfacesNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..dbb01d625 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/FieldAccessNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..67eb602f6 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/FieldDeclarationNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..469807d6a --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/FieldModifierNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..84cb69834 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/FinallyNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..3eb98cbba --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/FloatingPointTypeNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..dc4c6c092 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/ForInitNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..a07549fab --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/ForStatementNoShortIfNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..484d12d1f --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/ForStatementNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..f64143ee9 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/ForUpdateNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..8a5ddda55 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/FormalParameterListNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..05c97cf86 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/FormalParameterNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..433403768 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/FormalParametersNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..c5d712b09 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/IdentifierNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..1da59045a --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/IfThenElseStatementNoShortIfNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..8edd3fb6a --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/IfThenElseStatementNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..955429e87 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/IfThenStatementNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..9500c16c8 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/ImportDeclarationNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..e84921a34 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/InclusiveOrExpressionNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..9dc006af3 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/InferredFormalParameterListNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..bf2d4ae42 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/InstanceInitializerNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..6c79174e7 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/IntegralTypeNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..a46117b66 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/InterfaceBodyNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..c15375ee6 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/InterfaceDeclarationNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..d10a7ca4a --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/InterfaceMemberDeclarationNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..2834da498 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/InterfaceMethodDeclarationNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..7b90d35b8 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/InterfaceMethodModifierNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..3bfcbbf62 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/InterfaceModifierNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..1ff315e2d --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/InterfaceTypeListNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..2dc2c32c1 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/InterfaceTypeNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..f4327984c --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/LabeledStatementNoShortIfNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..d9bd07aff --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/LabeledStatementNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..60c09bfce --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/LambdaBodyNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..91ad4adaa --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/LambdaExpressionNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..36fe1452e --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/LambdaParametersNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..160268657 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/LastFormalParameterNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..7885ff07c --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/LeftHandSideNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..14d24d739 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/LiteralNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..13b8876f2 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/LocalVariableDeclarationNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..c1a363f1c --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/LocalVariableDeclarationStatementNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..19e6757fd --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/MarkerAnnotationNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..1174eb55a --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/MethodBodyNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..4311a9247 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/MethodDeclarationNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..88b15b184 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/MethodDeclaratorNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..1c637fa2c --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/MethodHeaderNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..ee167325d --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/MethodInvocationNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..7b8aaa622 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/MethodModifierNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..1fd8367d5 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/MethodNameNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..58ec328d8 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/MethodReferenceNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..60fb3b992 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/MultiplicativeExpressionNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..150f8acfb --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/NormalAnnotationNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..507bc740c --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/NormalClassDeclarationNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..4485a4502 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/NormalInterfaceDeclarationNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..f1024a098 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/NumericTypeNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..e4d17f3d9 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/PackageDeclarationNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..c4c53b9dc --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/PackageModifierNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..eae277938 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/PackageNameNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..f0038b29f --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/PackageOrTypeNameNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..3a04bb185 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/PostDecrementExpressionNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..7e0329142 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/PostIncrementExpressionNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..e5c6b303e --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/PostfixExpressionNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..0cc31c6c0 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/PreDecrementExpressionNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..3feccc98c --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/PreIncrementExpressionNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..d7d28757e --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/PrimaryNoNewArrayNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..7b5139137 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/PrimaryNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..7ed2ae42b --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/PrimitiveTypeNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..211bf8113 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/ReceiverParameterNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..0a6641f95 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/ReferenceTypeNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..f3923a551 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/RelationalExpressionNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..dc126a5b1 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/ResourceListNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..3cbf5da98 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/ResourceNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..ca07f616b --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/ResourceSpecificationNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..af9bfbc77 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/ResultNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..02ce51c51 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/ReturnStatementNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..f13b40256 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/ShiftExpressionNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..3fa663977 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/SimpleTypeNameNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..2b688f399 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/SingleElementAnnotationNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..32fb724bf --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/SingleStaticImportDeclarationNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..e5865efad --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/SingleTypeImportDeclarationNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..898f471e5 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/StatementExpressionListNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..205992200 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/StatementExpressionNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..12128b7f9 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/StatementNoShortIfNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..9300340ee --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/StatementNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..aea92a033 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/StatementWithoutTrailingSubstatementNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..8e20b5454 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/StaticImportOnDemandDeclarationNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..effe06e97 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/StaticInitializerNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..fb3e6dfde --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/SuperclassNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..144baad23 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/SuperinterfacesNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..8bd22f917 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/SwitchBlockNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..3a8520d6b --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/SwitchBlockStatementGroupNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..400652ebc --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/SwitchLabelNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..27883b82a --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/SwitchLabelsNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..99d6fc6d8 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/SwitchStatementNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..4101b1f70 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/SynchronizedStatementNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..6e1ab8e9b --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/ThrowStatementNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..40510a8f5 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/ThrowsNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..226610bbd --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/TryStatementNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..718d21dd7 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/TryWithResourcesStatementNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..80aaaf96a --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/TypeArgumentListNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..07f514746 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/TypeArgumentNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..ea44d42ea --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/TypeArgumentsNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..577e6ffed --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/TypeArgumentsOrDiamondNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..4fd1c0fe4 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/TypeBoundNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..0eb038188 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/TypeDeclarationNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..0817f34f2 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/TypeImportOnDemandDeclarationNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..389122be4 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/TypeNameNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..3c10a7bdf --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/TypeNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..6bfa42c40 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/TypeParameterListNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..617d7504b --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/TypeParameterModifierNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..1972f3d37 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/TypeParameterNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..5ee6b192d --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/TypeParametersNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..3964144ba --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/TypeVariableNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..c2278a181 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/UnannArrayTypeNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..a7d417913 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/UnannClassOrInterfaceTypeNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..a8683d364 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/UnannClassTypeNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..88f78f1bd --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/UnannInterfaceTypeNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..79ce09411 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/UnannPrimitiveTypeNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..775da4c51 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/UnannReferenceTypeNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..d168f97c8 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/UnannTypeNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..756dc0a5b --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/UnannTypeVariableNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..faa0c3d21 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/UnaryExpressionNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..947450ced --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/UnaryExpressionNotPlusMinusNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..b04f84922 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/UnqualifiedClassInstanceCreationExpressionNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..2725db344 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/VariableDeclaratorIdNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..6b78d37d5 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/VariableDeclaratorListNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..9fc775a97 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/VariableDeclaratorNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..7c6e6022e --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/VariableInitializerListNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..6d5151ceb --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/VariableInitializerNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..8df24b3d4 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/VariableModifierNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..d7693c538 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/WhileStatementNoShortIfNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..02d819f26 --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/WhileStatementNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..2e48d514f --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/WildcardBoundsNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..8ffa41a8c --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/WildcardNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..06710e50d --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/nodes/classOrInterfaceTypeToInstantiateNode.kt @@ -0,0 +1,10 @@ +@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 new file mode 100644 index 000000000..906b1b39b --- /dev/null +++ b/benchmarks/src/main/kotlin/org/ucfs/simple/SimpleGrammar.kt @@ -0,0 +1,20 @@ +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 new file mode 100644 index 000000000..73259039c --- /dev/null +++ b/benchmarks/src/test/kotlin/AntlrBenchmark.kt @@ -0,0 +1,39 @@ +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 new file mode 100644 index 000000000..8d14079a6 --- /dev/null +++ b/benchmarks/src/test/kotlin/AntlrFastBenchmark.kt @@ -0,0 +1,80 @@ +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 new file mode 100644 index 000000000..298f0ec08 --- /dev/null +++ b/benchmarks/src/test/kotlin/OfflineUcfsBenchmark.kt @@ -0,0 +1,26 @@ +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 new file mode 100644 index 000000000..f3647689c --- /dev/null +++ b/benchmarks/src/test/kotlin/OnlineUcfsBenchmark.kt @@ -0,0 +1,28 @@ +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 new file mode 100644 index 000000000..c5ad685cf --- /dev/null +++ b/benchmarks/src/test/kotlin/ParsingBenchmarks.kt @@ -0,0 +1,115 @@ +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 new file mode 100644 index 000000000..66399eec2 --- /dev/null +++ b/benchmarks/src/test/kotlin/RecoveryOfflineUcfsBenchmark.kt @@ -0,0 +1,12 @@ +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 new file mode 100644 index 000000000..1818e35a1 --- /dev/null +++ b/benchmarks/src/test/kotlin/RecoveryOnlineUcfsBenchmark.kt @@ -0,0 +1,17 @@ +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 new file mode 100644 index 000000000..601b0cc01 --- /dev/null +++ b/benchmarks/src/test/kotlin/SimpleUcfsCorrect.kt @@ -0,0 +1,43 @@ +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 new file mode 100644 index 000000000..3b0212b31 --- /dev/null +++ b/benchmarks/src/test/plots.py @@ -0,0 +1,44 @@ +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 new file mode 100644 index 000000000..b8442a072 --- /dev/null +++ b/benchmarks/src/test/resources/test_for_test/Wrong.java @@ -0,0 +1 @@ +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 new file mode 100644 index 000000000..f17d3bcd0 --- /dev/null +++ b/benchmarks/src/test/result/Antlr/20times_Antlr_java_correct_rxjava-2-2-2.csv @@ -0,0 +1,507 @@ +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 new file mode 100644 index 000000000..7805b8931 --- /dev/null +++ b/benchmarks/src/test/result/Antlr/Antlr_java_correct_junit-4-12.csv @@ -0,0 +1,353 @@ +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 new file mode 100644 index 000000000..c0780155b --- /dev/null +++ b/benchmarks/src/test/result/Antlr/Antlr_java_correct_rxjava-2-2-2.csv @@ -0,0 +1,1614 @@ +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 new file mode 100644 index 000000000..8cd89e01a --- /dev/null +++ b/benchmarks/src/test/result/AntlrFast/AntlrFast_java_correct_junit-4-12.csv @@ -0,0 +1,353 @@ +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 new file mode 100644 index 000000000..94438ea1f --- /dev/null +++ b/benchmarks/src/test/result/AntlrFast/AntlrFast_java_correct_rxjava-2-2-2.csv @@ -0,0 +1,1614 @@ +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 new file mode 100644 index 000000000..a61093453 --- /dev/null +++ b/benchmarks/src/test/result/UcfsOff/UcfsOff_java_correct_junit-4-12.csv @@ -0,0 +1,353 @@ +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 new file mode 100644 index 000000000..31dc68ee4 --- /dev/null +++ b/benchmarks/src/test/result/UcfsOff/UcfsOff_java_correct_rxjava-2-2-2.csv @@ -0,0 +1,1614 @@ +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 new file mode 100644 index 000000000..7d1160917 --- /dev/null +++ b/benchmarks/src/test/result/UcfsOn/UcfsOn_java_correct_junit-4-12.csv @@ -0,0 +1,353 @@ +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 new file mode 100644 index 000000000..d2b51734c --- /dev/null +++ b/benchmarks/src/test/result/UcfsOn/UcfsOn_java_correct_rxjava-2-2-2.csv @@ -0,0 +1,1614 @@ +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 new file mode 100644 index 000000000..5b299b55d --- /dev/null +++ b/benchmarks/src/test/result/UcfsSimple/UcfsSimple_java_correct_junit-4-12.csv @@ -0,0 +1,5 @@ +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 new file mode 100644 index 000000000..2e996c1b5 --- /dev/null +++ b/benchmarks/tokens_count.csv @@ -0,0 +1 @@ +filename,tokens diff --git a/examples/build.gradle.kts b/examples/build.gradle.kts new file mode 100644 index 000000000..888751046 --- /dev/null +++ b/examples/build.gradle.kts @@ -0,0 +1,19 @@ +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 new file mode 100644 index 000000000..7b67f7308 --- /dev/null +++ b/examples/src/main/kotlin/dyck/DyckGrammar.kt @@ -0,0 +1,22 @@ +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/generator/build.gradle.kts b/generator/build.gradle.kts new file mode 100644 index 000000000..133781def --- /dev/null +++ b/generator/build.gradle.kts @@ -0,0 +1,20 @@ +plugins { + kotlin("jvm") version "1.9.20" +} + +repositories { + mavenCentral() +} + +dependencies { + implementation(project(":solver")) + implementation("com.squareup:kotlinpoet:1.16.0") + testImplementation(kotlin("test")) +} + +tasks.test { + useJUnitPlatform() +} +kotlin { + jvmToolchain(11) +} \ No newline at end of file diff --git a/generator/src/main/kotlin/org/ucfs/GeneratorException.kt b/generator/src/main/kotlin/org/ucfs/GeneratorException.kt new file mode 100644 index 000000000..bcb9885ca --- /dev/null +++ b/generator/src/main/kotlin/org/ucfs/GeneratorException.kt @@ -0,0 +1,7 @@ +package org.ucfs + +class GeneratorException(msg: String = "") : Exception("Generator exception$msg") { + companion object { + const val GRAMMAR_EXPECTED = "Only subclass of Grammar class can be used for parser generation" + } +} \ No newline at end of file diff --git a/generator/src/main/kotlin/org/ucfs/IGeneratorFromGrammar.kt b/generator/src/main/kotlin/org/ucfs/IGeneratorFromGrammar.kt new file mode 100644 index 000000000..47dcbe4f6 --- /dev/null +++ b/generator/src/main/kotlin/org/ucfs/IGeneratorFromGrammar.kt @@ -0,0 +1,44 @@ +package org.ucfs + +import com.squareup.kotlinpoet.AnnotationSpec +import com.squareup.kotlinpoet.ClassName +import com.squareup.kotlinpoet.FileSpec +import com.squareup.kotlinpoet.TypeName +import org.ucfs.grammar.combinator.Grammar + +/** + * Common logic for generators that use a Grammar class + */ +interface IGeneratorFromGrammar { + val grammarClazz: Class<*> + + /** + * Build a grammar object from Class<*> + */ + fun buildGrammar(grammarClazz: Class<*>): Grammar { + if (!Grammar::class.java.isAssignableFrom(grammarClazz)) { + throw GeneratorException(GeneratorException.GRAMMAR_EXPECTED) + } + val grammar = grammarClazz.getConstructor().newInstance() + if (grammar is Grammar) { + grammar.rsm + return grammar + } + throw GeneratorException(GeneratorException.GRAMMAR_EXPECTED) + } +} + +internal fun FileSpec.Builder.suppressWarningTypes(vararg types: String) { + if (types.isEmpty()) { + return + } + + val format = "%S,".repeat(types.count()).trimEnd(',') + addAnnotation( + AnnotationSpec.builder(ClassName("", "Suppress")) + .addMember(format, *types) + .build() + ) +} + +fun TypeName.nullable(): TypeName = this.copy(nullable = true) diff --git a/generator/src/main/kotlin/org/ucfs/ast/AstExtractor.kt b/generator/src/main/kotlin/org/ucfs/ast/AstExtractor.kt new file mode 100644 index 000000000..e69de29bb diff --git a/generator/src/main/kotlin/org/ucfs/ast/DotWriter.kt b/generator/src/main/kotlin/org/ucfs/ast/DotWriter.kt new file mode 100644 index 000000000..f023fad6c --- /dev/null +++ b/generator/src/main/kotlin/org/ucfs/ast/DotWriter.kt @@ -0,0 +1,81 @@ +package org.ucfs.ast + +import java.nio.file.Files +import java.nio.file.Path + +class DotWriter { + private var lastId = 0 + var showSiblings = true + val ids: HashMap = HashMap() + fun getId(node: Node): Int { + return ids.getOrPut(node) { lastId++ } + } + + fun getDotView(root: Node, label: String = "AST"): String { + val view = StringBuilder("digraph g {") + view.append("label=\"$label\"") + view.append(handleNode(root)) + view.append("}") + return view.toString() + } + + private fun getNodeLabel(node: Node): String { + val view = StringBuilder("label = \"") + when (node) { + is TerminalNode<*> -> { + view.append(node.terminal.toString()) + } + + else -> { + view.append(node.javaClass.simpleName) + } + } + view.append("\noffset = ${node.offset}") + view.append("\nlength = ${node.length}") + view.append("\"") + return view.toString() + } + + private fun getNodeView(node: Node): StringBuilder { + val view = StringBuilder("\n${getId(node)} [ ${getNodeLabel(node)}") + if (node is TerminalNode<*>) { + if(node.isRecovered) { + view.append(", color = red") + } + else{ + view.append(", color = green") + } + } + view.append("]") + return view + } + + fun handleNode(node: Node): String { + val id = getId(node) + val view = getNodeView(node) + val left = node.left + + if (showSiblings && left != null) { + view.append("\n$id -> ${getId(left)} [color=blue]") + } + + for (child in node.children) { + view.append("\n$id -> ${getId(child)}") + view.append(handleNode(child)) + } + return view.toString() + } + + fun writeToFile(view: String, filePath: Path) { + val genPath = Path.of("gen", "ast") + Files.createDirectories(genPath) + val file = genPath.resolve(filePath).toFile() + file.writeText(view) + } + + fun writeToFile(root: Node, fileName: String, label: String = "AST", showSiblings: Boolean) { + this.showSiblings = showSiblings + writeToFile(getDotView(root, label), Path.of("$fileName.dot")) + } + +} \ No newline at end of file diff --git a/generator/src/main/kotlin/org/ucfs/ast/Node.kt b/generator/src/main/kotlin/org/ucfs/ast/Node.kt new file mode 100644 index 000000000..9a82c34b5 --- /dev/null +++ b/generator/src/main/kotlin/org/ucfs/ast/Node.kt @@ -0,0 +1,17 @@ +package org.ucfs.ast + +/** + * TODO add methods below + * - sppfNode (internalNode) + * - constructor (parent, sppfNode, offset) + */ +open class Node( + var parent: Node?, + var offset: Int, +) { + var length: Int = 0 + open var left: Node? = null + var right: Node? = null + var children: ArrayList = ArrayList() + var isRecovered: Boolean = false +} \ No newline at end of file diff --git a/generator/src/main/kotlin/org/ucfs/ast/NodeClassesGenerator.kt b/generator/src/main/kotlin/org/ucfs/ast/NodeClassesGenerator.kt new file mode 100644 index 000000000..9e8980f8b --- /dev/null +++ b/generator/src/main/kotlin/org/ucfs/ast/NodeClassesGenerator.kt @@ -0,0 +1,94 @@ +package org.ucfs.ast + +import com.squareup.kotlinpoet.* +import com.squareup.kotlinpoet.ParameterizedTypeName.Companion.parameterizedBy +import org.ucfs.IGeneratorFromGrammar +import org.ucfs.grammar.combinator.Grammar +import org.ucfs.grammar.combinator.regexp.* +import org.ucfs.rsm.symbol.Nonterminal +import org.ucfs.suppressWarningTypes +import java.nio.file.Path + +/** + * Generate Ast node class for each nonterminal in grammar. + */ +class NodeClassesGenerator(override val grammarClazz: Class<*>) : + IGeneratorFromGrammar { + val grammar: Grammar = buildGrammar(grammarClazz) + + private val superClass: Class<*> = Node::class.java + + companion object { + fun getClassName(nt: Nt): String = getClassName(nt.nonterm) + fun getClassName(nt: Nonterminal): String = "${nt.name}Node" + + //TODO add extensions `TerminalType: ITerminal` + val terminalType = TypeVariableName("TerminalType") + const val FUN_GET_CHILDREN = "getChildren" + const val OFFSET = "offset" + const val PARENT = "parent" + const val LENGTH = "length" + + } + + /** + * Generate class for each nonterminal in grammar + */ + fun generate(location: Path, pkg: String) { + for (nt in grammar.nonTerms) { + val file = generateClassFile(nt, pkg) + file.writeTo(location) + } + } + + /** + * Generate class for concrete nonterminal + */ + private fun generateClassFile(nt: Nt, pkg: String): FileSpec { + val fileName = getClassName(nt) + val ntClass = ClassName(pkg, fileName).parameterizedBy(terminalType) + val nodeClassBuilder = TypeSpec.classBuilder(ntClass.rawType.simpleName) + .addTypeVariable(terminalType) + .superclass(superClass.asTypeName()) + .addFunction(generateConstructor()) + + val fileBuilder = FileSpec + .builder(pkg, ntClass.rawType.simpleName) + .addType(nodeClassBuilder.build()) + + fileBuilder.suppressWarningTypes("RedundantVisibilityModifier") + return fileBuilder.build() + } + + /** + * Generate constructor + */ + private fun generateConstructor(): FunSpec { + return FunSpec.constructorBuilder() + .addParameter(PARENT, superClass) + .addParameter(OFFSET, Int::class) + .callSuperConstructor(PARENT, OFFSET) + .build() + } + + private fun extractChildren(re: Regexp, isOptional: Boolean): List { + return when (re) { + is Alternative -> extractChildren(re.left, true) + + extractChildren(re.right, true) + + is Concat -> extractChildren(re.head, isOptional) + + extractChildren(re.tail, isOptional) + + is Empty -> listOf() + is Epsilon -> listOf() + is Many -> extractChildren(re.exp, true) + is DerivedSymbol -> listOf(generateProperty(re, isOptional)) + } + } + + + private fun generateProperty(value: T, isOptional: Boolean): PropertySpec { + TODO() + } + +} \ No newline at end of file diff --git a/generator/src/main/kotlin/org/ucfs/ast/TerminalNode.kt b/generator/src/main/kotlin/org/ucfs/ast/TerminalNode.kt new file mode 100644 index 000000000..98ade18f2 --- /dev/null +++ b/generator/src/main/kotlin/org/ucfs/ast/TerminalNode.kt @@ -0,0 +1,10 @@ +package org.ucfs.ast + +import org.ucfs.rsm.symbol.ITerminal + +class TerminalNode(parent: Node, offset: Int, val terminal: T?, override var left: Node?) : + Node(parent, offset) { + init { + length = terminal.toString().length + } +} \ No newline at end of file diff --git a/generator/src/main/kotlin/org/ucfs/examples/Examples.kt b/generator/src/main/kotlin/org/ucfs/examples/Examples.kt new file mode 100644 index 000000000..e69de29bb diff --git a/generator/src/main/kotlin/org/ucfs/examples/dyck/DyckGrammar.kt b/generator/src/main/kotlin/org/ucfs/examples/dyck/DyckGrammar.kt new file mode 100644 index 000000000..96a9ee3c9 --- /dev/null +++ b/generator/src/main/kotlin/org/ucfs/examples/dyck/DyckGrammar.kt @@ -0,0 +1,18 @@ +package org.ucfs.examples.dyck + +import org.ucfs.grammar.combinator.Grammar +import org.ucfs.grammar.combinator.extension.StringExtension.times +import org.ucfs.grammar.combinator.regexp.Nt +import org.ucfs.grammar.combinator.regexp.many +import org.ucfs.grammar.combinator.regexp.or + +class DyckGrammar : Grammar() { + val S by Nt().asStart() + val Round by Nt("(" * S * ")") + val Quadrat by Nt("[" * S * "]") + val Curly by Nt("{" * S * "}") + + init { + S /= many(Round or Quadrat or Curly) + } +} diff --git a/generator/src/main/kotlin/org/ucfs/examples/golang/SimpleGolang.kt b/generator/src/main/kotlin/org/ucfs/examples/golang/SimpleGolang.kt new file mode 100644 index 000000000..59bb2217f --- /dev/null +++ b/generator/src/main/kotlin/org/ucfs/examples/golang/SimpleGolang.kt @@ -0,0 +1,15 @@ +package org.ucfs.examples.golang + +import org.ucfs.grammar.combinator.Grammar +import org.ucfs.grammar.combinator.extension.StringExtension.or +import org.ucfs.grammar.combinator.extension.StringExtension.times +import org.ucfs.grammar.combinator.regexp.Many +import org.ucfs.grammar.combinator.regexp.Nt +import org.ucfs.grammar.combinator.regexp.or + +class SimpleGolang : Grammar() { + val IntExpr by Nt("1" or "1" * "+" * "1") + val Statement by Nt(IntExpr * ";" or "r" * IntExpr * ";") + val Block by Nt(Many(Statement)) + val Program by Nt(Block).asStart() +} diff --git a/generator/src/main/kotlin/org/ucfs/parser/AbstractParserGenerator.kt b/generator/src/main/kotlin/org/ucfs/parser/AbstractParserGenerator.kt new file mode 100644 index 000000000..e69de29bb diff --git a/generator/src/main/kotlin/org/ucfs/parser/GeneratedParser.kt b/generator/src/main/kotlin/org/ucfs/parser/GeneratedParser.kt new file mode 100644 index 000000000..e69de29bb diff --git a/generator/src/main/kotlin/org/ucfs/parser/ParserGenerator.kt b/generator/src/main/kotlin/org/ucfs/parser/ParserGenerator.kt new file mode 100644 index 000000000..3086c390b --- /dev/null +++ b/generator/src/main/kotlin/org/ucfs/parser/ParserGenerator.kt @@ -0,0 +1,10 @@ +package org.ucfs.parser + +import com.squareup.kotlinpoet.FileSpec +import org.ucfs.rsm.symbol.ITerminal + +/** + * Generator for a parser that uses a third-party lexer. + * Unlike the scannerless parser , it uses scanner enumeration objects as terminals. + */ +open class ParserGenerator(grammarClazz: Class<*>, private val terminalsEnum: Class<*>) diff --git a/generator/src/main/kotlin/org/ucfs/parser/RecoveryParserGenerator.kt b/generator/src/main/kotlin/org/ucfs/parser/RecoveryParserGenerator.kt new file mode 100644 index 000000000..e69de29bb diff --git a/generator/src/main/kotlin/org/ucfs/parser/ScanerlessParserGenerator.kt b/generator/src/main/kotlin/org/ucfs/parser/ScanerlessParserGenerator.kt new file mode 100644 index 000000000..e69de29bb diff --git a/gradle.properties b/gradle.properties index 7fc6f1ff2..2de43ab72 100644 --- a/gradle.properties +++ b/gradle.properties @@ -1 +1,3 @@ kotlin.code.style=official +org.gradle.daemon=true +org.gradle.jvmargs=-Xmx4096m -Xss4m -XX:+UseG1GC \ No newline at end of file diff --git a/gradle/wrapper/gradle-wrapper.jar b/gradle/wrapper/gradle-wrapper.jar index 41d9927a4..a4b76b953 100644 Binary files a/gradle/wrapper/gradle-wrapper.jar and b/gradle/wrapper/gradle-wrapper.jar differ diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties index aa991fcea..df97d72b8 100644 --- a/gradle/wrapper/gradle-wrapper.properties +++ b/gradle/wrapper/gradle-wrapper.properties @@ -1,5 +1,7 @@ distributionBase=GRADLE_USER_HOME distributionPath=wrapper/dists -distributionUrl=https\://services.gradle.org/distributions/gradle-7.4.2-bin.zip +distributionUrl=https\://services.gradle.org/distributions/gradle-8.10.2-bin.zip +networkTimeout=10000 +validateDistributionUrl=true zipStoreBase=GRADLE_USER_HOME zipStorePath=wrapper/dists diff --git a/gradlew b/gradlew index 1b6c78733..f5feea6d6 100755 --- a/gradlew +++ b/gradlew @@ -15,6 +15,8 @@ # See the License for the specific language governing permissions and # limitations under the License. # +# SPDX-License-Identifier: Apache-2.0 +# ############################################################################## # @@ -55,7 +57,7 @@ # 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 +# https://github.com/gradle/gradle/blob/HEAD/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt # within the Gradle project. # # You can find Gradle at https://github.com/gradle/gradle/. @@ -80,13 +82,12 @@ do esac done -APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit - -APP_NAME="Gradle" +# This is normally unused +# shellcheck disable=SC2034 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"' +# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036) +APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s +' "$PWD" ) || exit # Use the maximum available, or set MAX_FD != -1 to use that value. MAX_FD=maximum @@ -133,22 +134,29 @@ 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. + if ! command -v java >/dev/null 2>&1 + then + 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 fi # Increase the maximum file descriptors if we can. if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then case $MAX_FD in #( max*) + # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked. + # shellcheck disable=SC2039,SC3045 MAX_FD=$( ulimit -H -n ) || warn "Could not query maximum file descriptor limit" esac case $MAX_FD in #( '' | soft) :;; #( *) + # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked. + # shellcheck disable=SC2039,SC3045 ulimit -n "$MAX_FD" || warn "Could not set maximum file descriptor limit to $MAX_FD" esac @@ -193,11 +201,15 @@ if "$cygwin" || "$msys" ; then 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. + +# 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"' + +# Collect all arguments for the java command: +# * DEFAULT_JVM_OPTS, JAVA_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments, +# and any embedded shellness will be escaped. +# * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be +# treated as '${Hostname}' itself on the command line. set -- \ "-Dorg.gradle.appname=$APP_BASE_NAME" \ @@ -205,6 +217,12 @@ set -- \ org.gradle.wrapper.GradleWrapperMain \ "$@" +# Stop when "xargs" is not available. +if ! command -v xargs >/dev/null 2>&1 +then + die "xargs is not available" +fi + # Use "xargs" to parse quoted args. # # With -n1 it outputs one arg per line, with the quotes and backslashes removed. diff --git a/gradlew.bat b/gradlew.bat index ac1b06f93..9b42019c7 100644 --- a/gradlew.bat +++ b/gradlew.bat @@ -13,8 +13,10 @@ @rem See the License for the specific language governing permissions and @rem limitations under the License. @rem +@rem SPDX-License-Identifier: Apache-2.0 +@rem -@if "%DEBUG%" == "" @echo off +@if "%DEBUG%"=="" @echo off @rem ########################################################################## @rem @rem Gradle startup script for Windows @@ -25,7 +27,8 @@ if "%OS%"=="Windows_NT" setlocal set DIRNAME=%~dp0 -if "%DIRNAME%" == "" set DIRNAME=. +if "%DIRNAME%"=="" set DIRNAME=. +@rem This is normally unused set APP_BASE_NAME=%~n0 set APP_HOME=%DIRNAME% @@ -40,13 +43,13 @@ if defined JAVA_HOME goto findJavaFromJavaHome set JAVA_EXE=java.exe %JAVA_EXE% -version >NUL 2>&1 -if "%ERRORLEVEL%" == "0" goto execute +if %ERRORLEVEL% equ 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. +echo. 1>&2 +echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 1>&2 +echo. 1>&2 +echo Please set the JAVA_HOME variable in your environment to match the 1>&2 +echo location of your Java installation. 1>&2 goto fail @@ -56,11 +59,11 @@ 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. +echo. 1>&2 +echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 1>&2 +echo. 1>&2 +echo Please set the JAVA_HOME variable in your environment to match the 1>&2 +echo location of your Java installation. 1>&2 goto fail @@ -75,13 +78,15 @@ set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar :end @rem End local scope for the variables with windows NT shell -if "%ERRORLEVEL%"=="0" goto mainEnd +if %ERRORLEVEL% equ 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 +set EXIT_CODE=%ERRORLEVEL% +if %EXIT_CODE% equ 0 set EXIT_CODE=1 +if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE% +exit /b %EXIT_CODE% :mainEnd if "%OS%"=="Windows_NT" endlocal diff --git a/runTests.sh b/runTests.sh new file mode 100644 index 000000000..e69de29bb diff --git a/settings.gradle.kts b/settings.gradle.kts index 7fece77cc..9d660d937 100644 --- a/settings.gradle.kts +++ b/settings.gradle.kts @@ -1,16 +1,9 @@ - -rootProject.name = "kotgll" - plugins { - id("com.gradle.enterprise") version("3.9") -} - -gradleEnterprise { - if (System.getenv("CI") != null) { - buildScan { - publishAlways() - termsOfServiceUrl = "https://gradle.com/terms-of-service" - termsOfServiceAgree = "yes" - } - } + id("org.gradle.toolchains.foojay-resolver-convention") version "0.5.0" } +rootProject.name = "ucfs" +include("solver") +include("benchmarks") +include("generator") +include("test-shared") +include("examples") diff --git a/single_test.py b/single_test.py new file mode 100644 index 000000000..dae1bfb60 --- /dev/null +++ b/single_test.py @@ -0,0 +1,66 @@ +import os +import subprocess +import sys + +gradlew = "./gradlew" +task = ":test-shared:test" + +test_name = sys.argv[1] # example "solver.correctnessTests.AmbiguousAStar3GrammarTest.AmbiguousAStar3GrammarTreeCorrectnessTest" +test_case_name = sys.argv[2] # example "small_test" +def run_test_for_mem(test_name): + def get_cmd(mem): + return [ + gradlew, + task, + f"-DtestMaxHeapSize={mem}m", + "--tests", test_name, + f"-Dspecial_case = {test_case_name}", + f"-Dcount_for_case=1" + ] + + 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 + cache[mem] = return_code + print(return_code) + return return_code + + l = 1 + r = 64 + max_mem = 4*1024 + while r <= max_mem: + return_code = execute(r) + if return_code != 0: + l = r + r *= 2 + else: + break + print(f"calculate r = {r}") + if r == 2*max_mem: + return r + + while l < r - 1: + m = (l + r) // 2 + print(m) + return_code = execute(m) + print(f"for {m} mem got code {return_code}") + + if return_code != 0: + l = m + else: + r = m + + return r + +print(test_name) +mem = run_test_for_mem(test_name) +print(f"Got for test = {test_name}: {mem}mb") +with open(f"{test_name.replace('.', '_')}_res.txt", "w") as output: + output.write(f"test,mem\n") + output.write(f"{test_name},{mem}\n") diff --git a/solver/build.gradle.kts b/solver/build.gradle.kts new file mode 100644 index 000000000..c234a8ef2 --- /dev/null +++ b/solver/build.gradle.kts @@ -0,0 +1,28 @@ +plugins { + java + kotlin("jvm") version "1.9.20" + kotlin("plugin.allopen") version "1.9.20" +} + +repositories { + mavenCentral() + maven("https://releases.usethesource.io/maven/") +} + +dependencies { + implementation("org.jetbrains.kotlinx:kotlinx-cli:0.3.5") + implementation ("io.github.oshai:kotlin-logging-jvm:5.1.0") + //needed for .dot parsing + implementation("org.antlr:antlr4:4.13.1") + // https://mvnrepository.com/artifact/org.slf4j/slf4j-api + //needed for kotlin-logging + implementation("org.slf4j:slf4j-api:2.0.17") + implementation("ch.qos.logback:logback-classic:1.5.18") + + testImplementation(kotlin("test")) + testImplementation("org.junit.jupiter:junit-jupiter:5.8.1") +} + +kotlin { jvmToolchain(11) } + +tasks.test { useJUnitPlatform() } \ No newline at end of file diff --git a/solver/src/main/java/org/ucfs/input/utils/dot/Dot.g4 b/solver/src/main/java/org/ucfs/input/utils/dot/Dot.g4 new file mode 100644 index 000000000..a80f1901d --- /dev/null +++ b/solver/src/main/java/org/ucfs/input/utils/dot/Dot.g4 @@ -0,0 +1,180 @@ +/* + [The "BSD licence"] + Copyright (c) 2013 Terence Parr + 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. +*/ +/** Derived from http://www.graphviz.org/doc/info/lang.html. + Comments pulled from spec. + */ + +// $antlr-format alignTrailingComments true, columnLimit 150, minEmptyLines 1, maxEmptyLinesToKeep 1, reflowComments false, useTab false +// $antlr-format allowShortRulesOnASingleLine false, allowShortBlocksOnASingleLine true, alignSemicolons hanging, alignColons hanging + +grammar Dot; + +graph + : STRICT? (GRAPH | DIGRAPH) id_? '{' stmt_list '}' EOF + ; + +stmt_list + : (stmt ';'?)* + ; + +stmt + : node_stmt + | edge_stmt + | attr_stmt + | id_ '=' id_ + | subgraph + ; + +attr_stmt + : (GRAPH | NODE | EDGE) attr_list + ; + +attr_list + : ('[' attr* ']')+ + ; + +attr + : label_name=id_ ( '=' label_value=id_)? (';' | ',')? + ; + +edge_stmt + : (node_id | subgraph) edgeRHS attr_list? + ; + +edgeRHS + : (edgeop ( node_id | subgraph))+ + ; + +edgeop + : '->' + | '--' + ; + +node_stmt + : node_id attr_list? + ; + +node_id + : id_ port? + ; + +port + : ':' id_ (':' id_)? + ; + +subgraph + : (SUBGRAPH id_?)? '{' stmt_list '}' + ; + +id_ + : ID + | STRING + | HTML_STRING + | NUMBER + ; + +// "The keywords node, edge, graph, digraph, subgraph, and strict are +// case-independent" +STRICT + : [Ss] [Tt] [Rr] [Ii] [Cc] [Tt] + ; + +GRAPH + : [Gg] [Rr] [Aa] [Pp] [Hh] + ; + +DIGRAPH + : [Dd] [Ii] [Gg] [Rr] [Aa] [Pp] [Hh] + ; + +NODE + : [Nn] [Oo] [Dd] [Ee] + ; + +EDGE + : [Ee] [Dd] [Gg] [Ee] + ; + +SUBGRAPH + : [Ss] [Uu] [Bb] [Gg] [Rr] [Aa] [Pp] [Hh] + ; + +/** "a numeral [-]?(.[0-9]+ | [0-9]+(.[0-9]*)? )" */ +NUMBER + : '-'? ('.' DIGIT+ | DIGIT+ ( '.' DIGIT*)?) + ; + +fragment DIGIT + : [0-9] + ; + +/** "any double-quoted string ("...") possibly containing escaped quotes" */ +STRING + : '"' ('\\"' | .)*? '"' + ; + +/** "Any string of alphabetic ([a-zA-Z\200-\377]) characters, underscores + * ('_') or digits ([0-9]), not beginning with a digit" + */ +ID + : LETTER (LETTER | DIGIT)* + ; + +fragment LETTER + : [a-zA-Z\u0080-\u00FF_] + ; + +/** "HTML strings, angle brackets must occur in matched pairs, and + * unescaped newlines are allowed." + */ +HTML_STRING + : '<' (TAG | ~ [<>])* '>' + ; + +fragment TAG + : '<' .*? '>' + ; + +COMMENT + : '/*' .*? '*/' -> skip + ; + +LINE_COMMENT + : '//' .*? '\r'? '\n' -> skip + ; + +/** "a '#' character is considered a line output from a C preprocessor (e.g., + * # 34 to indicate line 34 ) and discarded" + */ +PREPROC + : '#' ~[\r\n]* -> skip + ; + +WS + : [ \t\n\r]+ -> skip + ; \ No newline at end of file diff --git a/solver/src/main/java/org/ucfs/input/utils/dot/Dot.interp b/solver/src/main/java/org/ucfs/input/utils/dot/Dot.interp new file mode 100644 index 000000000..8b74aeb02 --- /dev/null +++ b/solver/src/main/java/org/ucfs/input/utils/dot/Dot.interp @@ -0,0 +1,73 @@ +token literal names: +null +'{' +'}' +';' +'=' +'[' +']' +',' +'->' +'--' +':' +null +null +null +null +null +null +null +null +null +null +null +null +null +null + +token symbolic names: +null +null +null +null +null +null +null +null +null +null +null +STRICT +GRAPH +DIGRAPH +NODE +EDGE +SUBGRAPH +NUMBER +STRING +ID +HTML_STRING +COMMENT +LINE_COMMENT +PREPROC +WS + +rule names: +graph +stmt_list +stmt +attr_stmt +attr_list +attr +edge_stmt +edgeRHS +edgeop +node_stmt +node_id +port +subgraph +id_ + + +atn: +[4, 1, 24, 128, 2, 0, 7, 0, 2, 1, 7, 1, 2, 2, 7, 2, 2, 3, 7, 3, 2, 4, 7, 4, 2, 5, 7, 5, 2, 6, 7, 6, 2, 7, 7, 7, 2, 8, 7, 8, 2, 9, 7, 9, 2, 10, 7, 10, 2, 11, 7, 11, 2, 12, 7, 12, 2, 13, 7, 13, 1, 0, 3, 0, 30, 8, 0, 1, 0, 1, 0, 3, 0, 34, 8, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 3, 1, 43, 8, 1, 5, 1, 45, 8, 1, 10, 1, 12, 1, 48, 9, 1, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 3, 2, 58, 8, 2, 1, 3, 1, 3, 1, 3, 1, 4, 1, 4, 5, 4, 65, 8, 4, 10, 4, 12, 4, 68, 9, 4, 1, 4, 4, 4, 71, 8, 4, 11, 4, 12, 4, 72, 1, 5, 1, 5, 1, 5, 3, 5, 78, 8, 5, 1, 5, 3, 5, 81, 8, 5, 1, 6, 1, 6, 3, 6, 85, 8, 6, 1, 6, 1, 6, 3, 6, 89, 8, 6, 1, 7, 1, 7, 1, 7, 3, 7, 94, 8, 7, 4, 7, 96, 8, 7, 11, 7, 12, 7, 97, 1, 8, 1, 8, 1, 9, 1, 9, 3, 9, 104, 8, 9, 1, 10, 1, 10, 3, 10, 108, 8, 10, 1, 11, 1, 11, 1, 11, 1, 11, 3, 11, 114, 8, 11, 1, 12, 1, 12, 3, 12, 118, 8, 12, 3, 12, 120, 8, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 13, 1, 13, 1, 13, 0, 0, 14, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 0, 5, 1, 0, 12, 13, 2, 0, 12, 12, 14, 15, 2, 0, 3, 3, 7, 7, 1, 0, 8, 9, 1, 0, 17, 20, 134, 0, 29, 1, 0, 0, 0, 2, 46, 1, 0, 0, 0, 4, 57, 1, 0, 0, 0, 6, 59, 1, 0, 0, 0, 8, 70, 1, 0, 0, 0, 10, 74, 1, 0, 0, 0, 12, 84, 1, 0, 0, 0, 14, 95, 1, 0, 0, 0, 16, 99, 1, 0, 0, 0, 18, 101, 1, 0, 0, 0, 20, 105, 1, 0, 0, 0, 22, 109, 1, 0, 0, 0, 24, 119, 1, 0, 0, 0, 26, 125, 1, 0, 0, 0, 28, 30, 5, 11, 0, 0, 29, 28, 1, 0, 0, 0, 29, 30, 1, 0, 0, 0, 30, 31, 1, 0, 0, 0, 31, 33, 7, 0, 0, 0, 32, 34, 3, 26, 13, 0, 33, 32, 1, 0, 0, 0, 33, 34, 1, 0, 0, 0, 34, 35, 1, 0, 0, 0, 35, 36, 5, 1, 0, 0, 36, 37, 3, 2, 1, 0, 37, 38, 5, 2, 0, 0, 38, 39, 5, 0, 0, 1, 39, 1, 1, 0, 0, 0, 40, 42, 3, 4, 2, 0, 41, 43, 5, 3, 0, 0, 42, 41, 1, 0, 0, 0, 42, 43, 1, 0, 0, 0, 43, 45, 1, 0, 0, 0, 44, 40, 1, 0, 0, 0, 45, 48, 1, 0, 0, 0, 46, 44, 1, 0, 0, 0, 46, 47, 1, 0, 0, 0, 47, 3, 1, 0, 0, 0, 48, 46, 1, 0, 0, 0, 49, 58, 3, 18, 9, 0, 50, 58, 3, 12, 6, 0, 51, 58, 3, 6, 3, 0, 52, 53, 3, 26, 13, 0, 53, 54, 5, 4, 0, 0, 54, 55, 3, 26, 13, 0, 55, 58, 1, 0, 0, 0, 56, 58, 3, 24, 12, 0, 57, 49, 1, 0, 0, 0, 57, 50, 1, 0, 0, 0, 57, 51, 1, 0, 0, 0, 57, 52, 1, 0, 0, 0, 57, 56, 1, 0, 0, 0, 58, 5, 1, 0, 0, 0, 59, 60, 7, 1, 0, 0, 60, 61, 3, 8, 4, 0, 61, 7, 1, 0, 0, 0, 62, 66, 5, 5, 0, 0, 63, 65, 3, 10, 5, 0, 64, 63, 1, 0, 0, 0, 65, 68, 1, 0, 0, 0, 66, 64, 1, 0, 0, 0, 66, 67, 1, 0, 0, 0, 67, 69, 1, 0, 0, 0, 68, 66, 1, 0, 0, 0, 69, 71, 5, 6, 0, 0, 70, 62, 1, 0, 0, 0, 71, 72, 1, 0, 0, 0, 72, 70, 1, 0, 0, 0, 72, 73, 1, 0, 0, 0, 73, 9, 1, 0, 0, 0, 74, 77, 3, 26, 13, 0, 75, 76, 5, 4, 0, 0, 76, 78, 3, 26, 13, 0, 77, 75, 1, 0, 0, 0, 77, 78, 1, 0, 0, 0, 78, 80, 1, 0, 0, 0, 79, 81, 7, 2, 0, 0, 80, 79, 1, 0, 0, 0, 80, 81, 1, 0, 0, 0, 81, 11, 1, 0, 0, 0, 82, 85, 3, 20, 10, 0, 83, 85, 3, 24, 12, 0, 84, 82, 1, 0, 0, 0, 84, 83, 1, 0, 0, 0, 85, 86, 1, 0, 0, 0, 86, 88, 3, 14, 7, 0, 87, 89, 3, 8, 4, 0, 88, 87, 1, 0, 0, 0, 88, 89, 1, 0, 0, 0, 89, 13, 1, 0, 0, 0, 90, 93, 3, 16, 8, 0, 91, 94, 3, 20, 10, 0, 92, 94, 3, 24, 12, 0, 93, 91, 1, 0, 0, 0, 93, 92, 1, 0, 0, 0, 94, 96, 1, 0, 0, 0, 95, 90, 1, 0, 0, 0, 96, 97, 1, 0, 0, 0, 97, 95, 1, 0, 0, 0, 97, 98, 1, 0, 0, 0, 98, 15, 1, 0, 0, 0, 99, 100, 7, 3, 0, 0, 100, 17, 1, 0, 0, 0, 101, 103, 3, 20, 10, 0, 102, 104, 3, 8, 4, 0, 103, 102, 1, 0, 0, 0, 103, 104, 1, 0, 0, 0, 104, 19, 1, 0, 0, 0, 105, 107, 3, 26, 13, 0, 106, 108, 3, 22, 11, 0, 107, 106, 1, 0, 0, 0, 107, 108, 1, 0, 0, 0, 108, 21, 1, 0, 0, 0, 109, 110, 5, 10, 0, 0, 110, 113, 3, 26, 13, 0, 111, 112, 5, 10, 0, 0, 112, 114, 3, 26, 13, 0, 113, 111, 1, 0, 0, 0, 113, 114, 1, 0, 0, 0, 114, 23, 1, 0, 0, 0, 115, 117, 5, 16, 0, 0, 116, 118, 3, 26, 13, 0, 117, 116, 1, 0, 0, 0, 117, 118, 1, 0, 0, 0, 118, 120, 1, 0, 0, 0, 119, 115, 1, 0, 0, 0, 119, 120, 1, 0, 0, 0, 120, 121, 1, 0, 0, 0, 121, 122, 5, 1, 0, 0, 122, 123, 3, 2, 1, 0, 123, 124, 5, 2, 0, 0, 124, 25, 1, 0, 0, 0, 125, 126, 7, 4, 0, 0, 126, 27, 1, 0, 0, 0, 18, 29, 33, 42, 46, 57, 66, 72, 77, 80, 84, 88, 93, 97, 103, 107, 113, 117, 119] \ No newline at end of file diff --git a/solver/src/main/java/org/ucfs/input/utils/dot/Dot.tokens b/solver/src/main/java/org/ucfs/input/utils/dot/Dot.tokens new file mode 100644 index 000000000..9c46a081b --- /dev/null +++ b/solver/src/main/java/org/ucfs/input/utils/dot/Dot.tokens @@ -0,0 +1,34 @@ +T__0=1 +T__1=2 +T__2=3 +T__3=4 +T__4=5 +T__5=6 +T__6=7 +T__7=8 +T__8=9 +T__9=10 +STRICT=11 +GRAPH=12 +DIGRAPH=13 +NODE=14 +EDGE=15 +SUBGRAPH=16 +NUMBER=17 +STRING=18 +ID=19 +HTML_STRING=20 +COMMENT=21 +LINE_COMMENT=22 +PREPROC=23 +WS=24 +'{'=1 +'}'=2 +';'=3 +'='=4 +'['=5 +']'=6 +','=7 +'->'=8 +'--'=9 +':'=10 diff --git a/solver/src/main/java/org/ucfs/input/utils/dot/DotBaseListener.java b/solver/src/main/java/org/ucfs/input/utils/dot/DotBaseListener.java new file mode 100644 index 000000000..e6449bf91 --- /dev/null +++ b/solver/src/main/java/org/ucfs/input/utils/dot/DotBaseListener.java @@ -0,0 +1,208 @@ +// Generated from Dot.g4 by ANTLR 4.13.2 +package org.ucfs.input.utils.dot; + +import org.antlr.v4.runtime.ParserRuleContext; +import org.antlr.v4.runtime.tree.ErrorNode; +import org.antlr.v4.runtime.tree.TerminalNode; + +/** + * This class provides an empty implementation of {@link DotListener}, + * which can be extended to create a listener which only needs to handle a subset + * of the available methods. + */ +@SuppressWarnings("CheckReturnValue") +public class DotBaseListener implements DotListener { + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterGraph(DotParser.GraphContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitGraph(DotParser.GraphContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterStmt_list(DotParser.Stmt_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitStmt_list(DotParser.Stmt_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterStmt(DotParser.StmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitStmt(DotParser.StmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAttr_stmt(DotParser.Attr_stmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAttr_stmt(DotParser.Attr_stmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAttr_list(DotParser.Attr_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAttr_list(DotParser.Attr_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAttr(DotParser.AttrContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAttr(DotParser.AttrContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterEdge_stmt(DotParser.Edge_stmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitEdge_stmt(DotParser.Edge_stmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterEdgeRHS(DotParser.EdgeRHSContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitEdgeRHS(DotParser.EdgeRHSContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterEdgeop(DotParser.EdgeopContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitEdgeop(DotParser.EdgeopContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterNode_stmt(DotParser.Node_stmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitNode_stmt(DotParser.Node_stmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterNode_id(DotParser.Node_idContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitNode_id(DotParser.Node_idContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterPort(DotParser.PortContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitPort(DotParser.PortContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSubgraph(DotParser.SubgraphContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSubgraph(DotParser.SubgraphContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterId_(DotParser.Id_Context ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitId_(DotParser.Id_Context ctx) { } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterEveryRule(ParserRuleContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitEveryRule(ParserRuleContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void visitTerminal(TerminalNode node) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void visitErrorNode(ErrorNode node) { } +} \ No newline at end of file diff --git a/solver/src/main/java/org/ucfs/input/utils/dot/DotBaseVisitor.java b/solver/src/main/java/org/ucfs/input/utils/dot/DotBaseVisitor.java new file mode 100644 index 000000000..ec7d74789 --- /dev/null +++ b/solver/src/main/java/org/ucfs/input/utils/dot/DotBaseVisitor.java @@ -0,0 +1,113 @@ +// Generated from Dot.g4 by ANTLR 4.13.2 +package org.ucfs.input.utils.dot; +import org.antlr.v4.runtime.tree.AbstractParseTreeVisitor; + +/** + * This class provides an empty implementation of {@link DotVisitor}, + * which can be extended to create a visitor which only needs to handle a subset + * of the available methods. + * + * @param The return type of the visit operation. Use {@link Void} for + * operations with no return type. + */ +@SuppressWarnings("CheckReturnValue") +public class DotBaseVisitor extends AbstractParseTreeVisitor implements DotVisitor { + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitGraph(DotParser.GraphContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitStmt_list(DotParser.Stmt_listContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitStmt(DotParser.StmtContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitAttr_stmt(DotParser.Attr_stmtContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitAttr_list(DotParser.Attr_listContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitAttr(DotParser.AttrContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitEdge_stmt(DotParser.Edge_stmtContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitEdgeRHS(DotParser.EdgeRHSContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitEdgeop(DotParser.EdgeopContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitNode_stmt(DotParser.Node_stmtContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitNode_id(DotParser.Node_idContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitPort(DotParser.PortContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitSubgraph(DotParser.SubgraphContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitId_(DotParser.Id_Context ctx) { return visitChildren(ctx); } +} \ No newline at end of file diff --git a/solver/src/main/java/org/ucfs/input/utils/dot/DotLexer.interp b/solver/src/main/java/org/ucfs/input/utils/dot/DotLexer.interp new file mode 100644 index 000000000..3cde96987 --- /dev/null +++ b/solver/src/main/java/org/ucfs/input/utils/dot/DotLexer.interp @@ -0,0 +1,92 @@ +token literal names: +null +'{' +'}' +';' +'=' +'[' +']' +',' +'->' +'--' +':' +null +null +null +null +null +null +null +null +null +null +null +null +null +null + +token symbolic names: +null +null +null +null +null +null +null +null +null +null +null +STRICT +GRAPH +DIGRAPH +NODE +EDGE +SUBGRAPH +NUMBER +STRING +ID +HTML_STRING +COMMENT +LINE_COMMENT +PREPROC +WS + +rule names: +T__0 +T__1 +T__2 +T__3 +T__4 +T__5 +T__6 +T__7 +T__8 +T__9 +STRICT +GRAPH +DIGRAPH +NODE +EDGE +SUBGRAPH +NUMBER +DIGIT +STRING +ID +LETTER +HTML_STRING +TAG +COMMENT +LINE_COMMENT +PREPROC +WS + +channel names: +DEFAULT_TOKEN_CHANNEL +HIDDEN + +mode names: +DEFAULT_MODE + +atn: +[4, 0, 24, 230, 6, -1, 2, 0, 7, 0, 2, 1, 7, 1, 2, 2, 7, 2, 2, 3, 7, 3, 2, 4, 7, 4, 2, 5, 7, 5, 2, 6, 7, 6, 2, 7, 7, 7, 2, 8, 7, 8, 2, 9, 7, 9, 2, 10, 7, 10, 2, 11, 7, 11, 2, 12, 7, 12, 2, 13, 7, 13, 2, 14, 7, 14, 2, 15, 7, 15, 2, 16, 7, 16, 2, 17, 7, 17, 2, 18, 7, 18, 2, 19, 7, 19, 2, 20, 7, 20, 2, 21, 7, 21, 2, 22, 7, 22, 2, 23, 7, 23, 2, 24, 7, 24, 2, 25, 7, 25, 2, 26, 7, 26, 1, 0, 1, 0, 1, 1, 1, 1, 1, 2, 1, 2, 1, 3, 1, 3, 1, 4, 1, 4, 1, 5, 1, 5, 1, 6, 1, 6, 1, 7, 1, 7, 1, 7, 1, 8, 1, 8, 1, 8, 1, 9, 1, 9, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 16, 3, 16, 119, 8, 16, 1, 16, 1, 16, 4, 16, 123, 8, 16, 11, 16, 12, 16, 124, 1, 16, 4, 16, 128, 8, 16, 11, 16, 12, 16, 129, 1, 16, 1, 16, 5, 16, 134, 8, 16, 10, 16, 12, 16, 137, 9, 16, 3, 16, 139, 8, 16, 3, 16, 141, 8, 16, 1, 17, 1, 17, 1, 18, 1, 18, 1, 18, 1, 18, 5, 18, 149, 8, 18, 10, 18, 12, 18, 152, 9, 18, 1, 18, 1, 18, 1, 19, 1, 19, 1, 19, 5, 19, 159, 8, 19, 10, 19, 12, 19, 162, 9, 19, 1, 20, 1, 20, 1, 21, 1, 21, 1, 21, 5, 21, 169, 8, 21, 10, 21, 12, 21, 172, 9, 21, 1, 21, 1, 21, 1, 22, 1, 22, 5, 22, 178, 8, 22, 10, 22, 12, 22, 181, 9, 22, 1, 22, 1, 22, 1, 23, 1, 23, 1, 23, 1, 23, 5, 23, 189, 8, 23, 10, 23, 12, 23, 192, 9, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 24, 1, 24, 1, 24, 1, 24, 5, 24, 203, 8, 24, 10, 24, 12, 24, 206, 9, 24, 1, 24, 3, 24, 209, 8, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 25, 1, 25, 5, 25, 217, 8, 25, 10, 25, 12, 25, 220, 9, 25, 1, 25, 1, 25, 1, 26, 4, 26, 225, 8, 26, 11, 26, 12, 26, 226, 1, 26, 1, 26, 4, 150, 179, 190, 204, 0, 27, 1, 1, 3, 2, 5, 3, 7, 4, 9, 5, 11, 6, 13, 7, 15, 8, 17, 9, 19, 10, 21, 11, 23, 12, 25, 13, 27, 14, 29, 15, 31, 16, 33, 17, 35, 0, 37, 18, 39, 19, 41, 0, 43, 20, 45, 0, 47, 21, 49, 22, 51, 23, 53, 24, 1, 0, 20, 2, 0, 83, 83, 115, 115, 2, 0, 84, 84, 116, 116, 2, 0, 82, 82, 114, 114, 2, 0, 73, 73, 105, 105, 2, 0, 67, 67, 99, 99, 2, 0, 71, 71, 103, 103, 2, 0, 65, 65, 97, 97, 2, 0, 80, 80, 112, 112, 2, 0, 72, 72, 104, 104, 2, 0, 68, 68, 100, 100, 2, 0, 78, 78, 110, 110, 2, 0, 79, 79, 111, 111, 2, 0, 69, 69, 101, 101, 2, 0, 85, 85, 117, 117, 2, 0, 66, 66, 98, 98, 1, 0, 48, 57, 4, 0, 65, 90, 95, 95, 97, 122, 128, 255, 2, 0, 60, 60, 62, 62, 2, 0, 10, 10, 13, 13, 3, 0, 9, 10, 13, 13, 32, 32, 244, 0, 1, 1, 0, 0, 0, 0, 3, 1, 0, 0, 0, 0, 5, 1, 0, 0, 0, 0, 7, 1, 0, 0, 0, 0, 9, 1, 0, 0, 0, 0, 11, 1, 0, 0, 0, 0, 13, 1, 0, 0, 0, 0, 15, 1, 0, 0, 0, 0, 17, 1, 0, 0, 0, 0, 19, 1, 0, 0, 0, 0, 21, 1, 0, 0, 0, 0, 23, 1, 0, 0, 0, 0, 25, 1, 0, 0, 0, 0, 27, 1, 0, 0, 0, 0, 29, 1, 0, 0, 0, 0, 31, 1, 0, 0, 0, 0, 33, 1, 0, 0, 0, 0, 37, 1, 0, 0, 0, 0, 39, 1, 0, 0, 0, 0, 43, 1, 0, 0, 0, 0, 47, 1, 0, 0, 0, 0, 49, 1, 0, 0, 0, 0, 51, 1, 0, 0, 0, 0, 53, 1, 0, 0, 0, 1, 55, 1, 0, 0, 0, 3, 57, 1, 0, 0, 0, 5, 59, 1, 0, 0, 0, 7, 61, 1, 0, 0, 0, 9, 63, 1, 0, 0, 0, 11, 65, 1, 0, 0, 0, 13, 67, 1, 0, 0, 0, 15, 69, 1, 0, 0, 0, 17, 72, 1, 0, 0, 0, 19, 75, 1, 0, 0, 0, 21, 77, 1, 0, 0, 0, 23, 84, 1, 0, 0, 0, 25, 90, 1, 0, 0, 0, 27, 98, 1, 0, 0, 0, 29, 103, 1, 0, 0, 0, 31, 108, 1, 0, 0, 0, 33, 118, 1, 0, 0, 0, 35, 142, 1, 0, 0, 0, 37, 144, 1, 0, 0, 0, 39, 155, 1, 0, 0, 0, 41, 163, 1, 0, 0, 0, 43, 165, 1, 0, 0, 0, 45, 175, 1, 0, 0, 0, 47, 184, 1, 0, 0, 0, 49, 198, 1, 0, 0, 0, 51, 214, 1, 0, 0, 0, 53, 224, 1, 0, 0, 0, 55, 56, 5, 123, 0, 0, 56, 2, 1, 0, 0, 0, 57, 58, 5, 125, 0, 0, 58, 4, 1, 0, 0, 0, 59, 60, 5, 59, 0, 0, 60, 6, 1, 0, 0, 0, 61, 62, 5, 61, 0, 0, 62, 8, 1, 0, 0, 0, 63, 64, 5, 91, 0, 0, 64, 10, 1, 0, 0, 0, 65, 66, 5, 93, 0, 0, 66, 12, 1, 0, 0, 0, 67, 68, 5, 44, 0, 0, 68, 14, 1, 0, 0, 0, 69, 70, 5, 45, 0, 0, 70, 71, 5, 62, 0, 0, 71, 16, 1, 0, 0, 0, 72, 73, 5, 45, 0, 0, 73, 74, 5, 45, 0, 0, 74, 18, 1, 0, 0, 0, 75, 76, 5, 58, 0, 0, 76, 20, 1, 0, 0, 0, 77, 78, 7, 0, 0, 0, 78, 79, 7, 1, 0, 0, 79, 80, 7, 2, 0, 0, 80, 81, 7, 3, 0, 0, 81, 82, 7, 4, 0, 0, 82, 83, 7, 1, 0, 0, 83, 22, 1, 0, 0, 0, 84, 85, 7, 5, 0, 0, 85, 86, 7, 2, 0, 0, 86, 87, 7, 6, 0, 0, 87, 88, 7, 7, 0, 0, 88, 89, 7, 8, 0, 0, 89, 24, 1, 0, 0, 0, 90, 91, 7, 9, 0, 0, 91, 92, 7, 3, 0, 0, 92, 93, 7, 5, 0, 0, 93, 94, 7, 2, 0, 0, 94, 95, 7, 6, 0, 0, 95, 96, 7, 7, 0, 0, 96, 97, 7, 8, 0, 0, 97, 26, 1, 0, 0, 0, 98, 99, 7, 10, 0, 0, 99, 100, 7, 11, 0, 0, 100, 101, 7, 9, 0, 0, 101, 102, 7, 12, 0, 0, 102, 28, 1, 0, 0, 0, 103, 104, 7, 12, 0, 0, 104, 105, 7, 9, 0, 0, 105, 106, 7, 5, 0, 0, 106, 107, 7, 12, 0, 0, 107, 30, 1, 0, 0, 0, 108, 109, 7, 0, 0, 0, 109, 110, 7, 13, 0, 0, 110, 111, 7, 14, 0, 0, 111, 112, 7, 5, 0, 0, 112, 113, 7, 2, 0, 0, 113, 114, 7, 6, 0, 0, 114, 115, 7, 7, 0, 0, 115, 116, 7, 8, 0, 0, 116, 32, 1, 0, 0, 0, 117, 119, 5, 45, 0, 0, 118, 117, 1, 0, 0, 0, 118, 119, 1, 0, 0, 0, 119, 140, 1, 0, 0, 0, 120, 122, 5, 46, 0, 0, 121, 123, 3, 35, 17, 0, 122, 121, 1, 0, 0, 0, 123, 124, 1, 0, 0, 0, 124, 122, 1, 0, 0, 0, 124, 125, 1, 0, 0, 0, 125, 141, 1, 0, 0, 0, 126, 128, 3, 35, 17, 0, 127, 126, 1, 0, 0, 0, 128, 129, 1, 0, 0, 0, 129, 127, 1, 0, 0, 0, 129, 130, 1, 0, 0, 0, 130, 138, 1, 0, 0, 0, 131, 135, 5, 46, 0, 0, 132, 134, 3, 35, 17, 0, 133, 132, 1, 0, 0, 0, 134, 137, 1, 0, 0, 0, 135, 133, 1, 0, 0, 0, 135, 136, 1, 0, 0, 0, 136, 139, 1, 0, 0, 0, 137, 135, 1, 0, 0, 0, 138, 131, 1, 0, 0, 0, 138, 139, 1, 0, 0, 0, 139, 141, 1, 0, 0, 0, 140, 120, 1, 0, 0, 0, 140, 127, 1, 0, 0, 0, 141, 34, 1, 0, 0, 0, 142, 143, 7, 15, 0, 0, 143, 36, 1, 0, 0, 0, 144, 150, 5, 34, 0, 0, 145, 146, 5, 92, 0, 0, 146, 149, 5, 34, 0, 0, 147, 149, 9, 0, 0, 0, 148, 145, 1, 0, 0, 0, 148, 147, 1, 0, 0, 0, 149, 152, 1, 0, 0, 0, 150, 151, 1, 0, 0, 0, 150, 148, 1, 0, 0, 0, 151, 153, 1, 0, 0, 0, 152, 150, 1, 0, 0, 0, 153, 154, 5, 34, 0, 0, 154, 38, 1, 0, 0, 0, 155, 160, 3, 41, 20, 0, 156, 159, 3, 41, 20, 0, 157, 159, 3, 35, 17, 0, 158, 156, 1, 0, 0, 0, 158, 157, 1, 0, 0, 0, 159, 162, 1, 0, 0, 0, 160, 158, 1, 0, 0, 0, 160, 161, 1, 0, 0, 0, 161, 40, 1, 0, 0, 0, 162, 160, 1, 0, 0, 0, 163, 164, 7, 16, 0, 0, 164, 42, 1, 0, 0, 0, 165, 170, 5, 60, 0, 0, 166, 169, 3, 45, 22, 0, 167, 169, 8, 17, 0, 0, 168, 166, 1, 0, 0, 0, 168, 167, 1, 0, 0, 0, 169, 172, 1, 0, 0, 0, 170, 168, 1, 0, 0, 0, 170, 171, 1, 0, 0, 0, 171, 173, 1, 0, 0, 0, 172, 170, 1, 0, 0, 0, 173, 174, 5, 62, 0, 0, 174, 44, 1, 0, 0, 0, 175, 179, 5, 60, 0, 0, 176, 178, 9, 0, 0, 0, 177, 176, 1, 0, 0, 0, 178, 181, 1, 0, 0, 0, 179, 180, 1, 0, 0, 0, 179, 177, 1, 0, 0, 0, 180, 182, 1, 0, 0, 0, 181, 179, 1, 0, 0, 0, 182, 183, 5, 62, 0, 0, 183, 46, 1, 0, 0, 0, 184, 185, 5, 47, 0, 0, 185, 186, 5, 42, 0, 0, 186, 190, 1, 0, 0, 0, 187, 189, 9, 0, 0, 0, 188, 187, 1, 0, 0, 0, 189, 192, 1, 0, 0, 0, 190, 191, 1, 0, 0, 0, 190, 188, 1, 0, 0, 0, 191, 193, 1, 0, 0, 0, 192, 190, 1, 0, 0, 0, 193, 194, 5, 42, 0, 0, 194, 195, 5, 47, 0, 0, 195, 196, 1, 0, 0, 0, 196, 197, 6, 23, 0, 0, 197, 48, 1, 0, 0, 0, 198, 199, 5, 47, 0, 0, 199, 200, 5, 47, 0, 0, 200, 204, 1, 0, 0, 0, 201, 203, 9, 0, 0, 0, 202, 201, 1, 0, 0, 0, 203, 206, 1, 0, 0, 0, 204, 205, 1, 0, 0, 0, 204, 202, 1, 0, 0, 0, 205, 208, 1, 0, 0, 0, 206, 204, 1, 0, 0, 0, 207, 209, 5, 13, 0, 0, 208, 207, 1, 0, 0, 0, 208, 209, 1, 0, 0, 0, 209, 210, 1, 0, 0, 0, 210, 211, 5, 10, 0, 0, 211, 212, 1, 0, 0, 0, 212, 213, 6, 24, 0, 0, 213, 50, 1, 0, 0, 0, 214, 218, 5, 35, 0, 0, 215, 217, 8, 18, 0, 0, 216, 215, 1, 0, 0, 0, 217, 220, 1, 0, 0, 0, 218, 216, 1, 0, 0, 0, 218, 219, 1, 0, 0, 0, 219, 221, 1, 0, 0, 0, 220, 218, 1, 0, 0, 0, 221, 222, 6, 25, 0, 0, 222, 52, 1, 0, 0, 0, 223, 225, 7, 19, 0, 0, 224, 223, 1, 0, 0, 0, 225, 226, 1, 0, 0, 0, 226, 224, 1, 0, 0, 0, 226, 227, 1, 0, 0, 0, 227, 228, 1, 0, 0, 0, 228, 229, 6, 26, 0, 0, 229, 54, 1, 0, 0, 0, 19, 0, 118, 124, 129, 135, 138, 140, 148, 150, 158, 160, 168, 170, 179, 190, 204, 208, 218, 226, 1, 6, 0, 0] \ No newline at end of file diff --git a/solver/src/main/java/org/ucfs/input/utils/dot/DotLexer.java b/solver/src/main/java/org/ucfs/input/utils/dot/DotLexer.java new file mode 100644 index 000000000..ba3b9808f --- /dev/null +++ b/solver/src/main/java/org/ucfs/input/utils/dot/DotLexer.java @@ -0,0 +1,276 @@ +// Generated from Dot.g4 by ANTLR 4.13.2 +package org.ucfs.input.utils.dot; +import org.antlr.v4.runtime.Lexer; +import org.antlr.v4.runtime.CharStream; +import org.antlr.v4.runtime.Token; +import org.antlr.v4.runtime.TokenStream; +import org.antlr.v4.runtime.*; +import org.antlr.v4.runtime.atn.*; +import org.antlr.v4.runtime.dfa.DFA; +import org.antlr.v4.runtime.misc.*; + +@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast", "CheckReturnValue", "this-escape"}) +public class DotLexer extends Lexer { + static { RuntimeMetaData.checkVersion("4.13.2", RuntimeMetaData.VERSION); } + + protected static final DFA[] _decisionToDFA; + protected static final PredictionContextCache _sharedContextCache = + new PredictionContextCache(); + public static final int + T__0=1, T__1=2, T__2=3, T__3=4, T__4=5, T__5=6, T__6=7, T__7=8, T__8=9, + T__9=10, STRICT=11, GRAPH=12, DIGRAPH=13, NODE=14, EDGE=15, SUBGRAPH=16, + NUMBER=17, STRING=18, ID=19, HTML_STRING=20, COMMENT=21, LINE_COMMENT=22, + PREPROC=23, WS=24; + public static String[] channelNames = { + "DEFAULT_TOKEN_CHANNEL", "HIDDEN" + }; + + public static String[] modeNames = { + "DEFAULT_MODE" + }; + + private static String[] makeRuleNames() { + return new String[] { + "T__0", "T__1", "T__2", "T__3", "T__4", "T__5", "T__6", "T__7", "T__8", + "T__9", "STRICT", "GRAPH", "DIGRAPH", "NODE", "EDGE", "SUBGRAPH", "NUMBER", + "DIGIT", "STRING", "ID", "LETTER", "HTML_STRING", "TAG", "COMMENT", "LINE_COMMENT", + "PREPROC", "WS" + }; + } + public static final String[] ruleNames = makeRuleNames(); + + private static String[] makeLiteralNames() { + return new String[] { + null, "'{'", "'}'", "';'", "'='", "'['", "']'", "','", "'->'", "'--'", + "':'" + }; + } + private static final String[] _LITERAL_NAMES = makeLiteralNames(); + private static String[] makeSymbolicNames() { + return new String[] { + null, null, null, null, null, null, null, null, null, null, null, "STRICT", + "GRAPH", "DIGRAPH", "NODE", "EDGE", "SUBGRAPH", "NUMBER", "STRING", "ID", + "HTML_STRING", "COMMENT", "LINE_COMMENT", "PREPROC", "WS" + }; + } + private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames(); + public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES); + + /** + * @deprecated Use {@link #VOCABULARY} instead. + */ + @Deprecated + public static final String[] tokenNames; + static { + tokenNames = new String[_SYMBOLIC_NAMES.length]; + for (int i = 0; i < tokenNames.length; i++) { + tokenNames[i] = VOCABULARY.getLiteralName(i); + if (tokenNames[i] == null) { + tokenNames[i] = VOCABULARY.getSymbolicName(i); + } + + if (tokenNames[i] == null) { + tokenNames[i] = ""; + } + } + } + + @Override + @Deprecated + public String[] getTokenNames() { + return tokenNames; + } + + @Override + + public Vocabulary getVocabulary() { + return VOCABULARY; + } + + + public DotLexer(CharStream input) { + super(input); + _interp = new LexerATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache); + } + + @Override + public String getGrammarFileName() { return "Dot.g4"; } + + @Override + public String[] getRuleNames() { return ruleNames; } + + @Override + public String getSerializedATN() { return _serializedATN; } + + @Override + public String[] getChannelNames() { return channelNames; } + + @Override + public String[] getModeNames() { return modeNames; } + + @Override + public ATN getATN() { return _ATN; } + + public static final String _serializedATN = + "\u0004\u0000\u0018\u00e6\u0006\uffff\uffff\u0002\u0000\u0007\u0000\u0002"+ + "\u0001\u0007\u0001\u0002\u0002\u0007\u0002\u0002\u0003\u0007\u0003\u0002"+ + "\u0004\u0007\u0004\u0002\u0005\u0007\u0005\u0002\u0006\u0007\u0006\u0002"+ + "\u0007\u0007\u0007\u0002\b\u0007\b\u0002\t\u0007\t\u0002\n\u0007\n\u0002"+ + "\u000b\u0007\u000b\u0002\f\u0007\f\u0002\r\u0007\r\u0002\u000e\u0007\u000e"+ + "\u0002\u000f\u0007\u000f\u0002\u0010\u0007\u0010\u0002\u0011\u0007\u0011"+ + "\u0002\u0012\u0007\u0012\u0002\u0013\u0007\u0013\u0002\u0014\u0007\u0014"+ + "\u0002\u0015\u0007\u0015\u0002\u0016\u0007\u0016\u0002\u0017\u0007\u0017"+ + "\u0002\u0018\u0007\u0018\u0002\u0019\u0007\u0019\u0002\u001a\u0007\u001a"+ + "\u0001\u0000\u0001\u0000\u0001\u0001\u0001\u0001\u0001\u0002\u0001\u0002"+ + "\u0001\u0003\u0001\u0003\u0001\u0004\u0001\u0004\u0001\u0005\u0001\u0005"+ + "\u0001\u0006\u0001\u0006\u0001\u0007\u0001\u0007\u0001\u0007\u0001\b\u0001"+ + "\b\u0001\b\u0001\t\u0001\t\u0001\n\u0001\n\u0001\n\u0001\n\u0001\n\u0001"+ + "\n\u0001\n\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b"+ + "\u0001\u000b\u0001\f\u0001\f\u0001\f\u0001\f\u0001\f\u0001\f\u0001\f\u0001"+ + "\f\u0001\r\u0001\r\u0001\r\u0001\r\u0001\r\u0001\u000e\u0001\u000e\u0001"+ + "\u000e\u0001\u000e\u0001\u000e\u0001\u000f\u0001\u000f\u0001\u000f\u0001"+ + "\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0001"+ + "\u0010\u0003\u0010w\b\u0010\u0001\u0010\u0001\u0010\u0004\u0010{\b\u0010"+ + "\u000b\u0010\f\u0010|\u0001\u0010\u0004\u0010\u0080\b\u0010\u000b\u0010"+ + "\f\u0010\u0081\u0001\u0010\u0001\u0010\u0005\u0010\u0086\b\u0010\n\u0010"+ + "\f\u0010\u0089\t\u0010\u0003\u0010\u008b\b\u0010\u0003\u0010\u008d\b\u0010"+ + "\u0001\u0011\u0001\u0011\u0001\u0012\u0001\u0012\u0001\u0012\u0001\u0012"+ + "\u0005\u0012\u0095\b\u0012\n\u0012\f\u0012\u0098\t\u0012\u0001\u0012\u0001"+ + "\u0012\u0001\u0013\u0001\u0013\u0001\u0013\u0005\u0013\u009f\b\u0013\n"+ + "\u0013\f\u0013\u00a2\t\u0013\u0001\u0014\u0001\u0014\u0001\u0015\u0001"+ + "\u0015\u0001\u0015\u0005\u0015\u00a9\b\u0015\n\u0015\f\u0015\u00ac\t\u0015"+ + "\u0001\u0015\u0001\u0015\u0001\u0016\u0001\u0016\u0005\u0016\u00b2\b\u0016"+ + "\n\u0016\f\u0016\u00b5\t\u0016\u0001\u0016\u0001\u0016\u0001\u0017\u0001"+ + "\u0017\u0001\u0017\u0001\u0017\u0005\u0017\u00bd\b\u0017\n\u0017\f\u0017"+ + "\u00c0\t\u0017\u0001\u0017\u0001\u0017\u0001\u0017\u0001\u0017\u0001\u0017"+ + "\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0005\u0018\u00cb\b\u0018"+ + "\n\u0018\f\u0018\u00ce\t\u0018\u0001\u0018\u0003\u0018\u00d1\b\u0018\u0001"+ + "\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0019\u0001\u0019\u0005"+ + "\u0019\u00d9\b\u0019\n\u0019\f\u0019\u00dc\t\u0019\u0001\u0019\u0001\u0019"+ + "\u0001\u001a\u0004\u001a\u00e1\b\u001a\u000b\u001a\f\u001a\u00e2\u0001"+ + "\u001a\u0001\u001a\u0004\u0096\u00b3\u00be\u00cc\u0000\u001b\u0001\u0001"+ + "\u0003\u0002\u0005\u0003\u0007\u0004\t\u0005\u000b\u0006\r\u0007\u000f"+ + "\b\u0011\t\u0013\n\u0015\u000b\u0017\f\u0019\r\u001b\u000e\u001d\u000f"+ + "\u001f\u0010!\u0011#\u0000%\u0012\'\u0013)\u0000+\u0014-\u0000/\u0015"+ + "1\u00163\u00175\u0018\u0001\u0000\u0014\u0002\u0000SSss\u0002\u0000TT"+ + "tt\u0002\u0000RRrr\u0002\u0000IIii\u0002\u0000CCcc\u0002\u0000GGgg\u0002"+ + "\u0000AAaa\u0002\u0000PPpp\u0002\u0000HHhh\u0002\u0000DDdd\u0002\u0000"+ + "NNnn\u0002\u0000OOoo\u0002\u0000EEee\u0002\u0000UUuu\u0002\u0000BBbb\u0001"+ + "\u000009\u0004\u0000AZ__az\u0080\u00ff\u0002\u0000<<>>\u0002\u0000\n\n"+ + "\r\r\u0003\u0000\t\n\r\r \u00f4\u0000\u0001\u0001\u0000\u0000\u0000\u0000"+ + "\u0003\u0001\u0000\u0000\u0000\u0000\u0005\u0001\u0000\u0000\u0000\u0000"+ + "\u0007\u0001\u0000\u0000\u0000\u0000\t\u0001\u0000\u0000\u0000\u0000\u000b"+ + "\u0001\u0000\u0000\u0000\u0000\r\u0001\u0000\u0000\u0000\u0000\u000f\u0001"+ + "\u0000\u0000\u0000\u0000\u0011\u0001\u0000\u0000\u0000\u0000\u0013\u0001"+ + "\u0000\u0000\u0000\u0000\u0015\u0001\u0000\u0000\u0000\u0000\u0017\u0001"+ + "\u0000\u0000\u0000\u0000\u0019\u0001\u0000\u0000\u0000\u0000\u001b\u0001"+ + "\u0000\u0000\u0000\u0000\u001d\u0001\u0000\u0000\u0000\u0000\u001f\u0001"+ + "\u0000\u0000\u0000\u0000!\u0001\u0000\u0000\u0000\u0000%\u0001\u0000\u0000"+ + "\u0000\u0000\'\u0001\u0000\u0000\u0000\u0000+\u0001\u0000\u0000\u0000"+ + "\u0000/\u0001\u0000\u0000\u0000\u00001\u0001\u0000\u0000\u0000\u00003"+ + "\u0001\u0000\u0000\u0000\u00005\u0001\u0000\u0000\u0000\u00017\u0001\u0000"+ + "\u0000\u0000\u00039\u0001\u0000\u0000\u0000\u0005;\u0001\u0000\u0000\u0000"+ + "\u0007=\u0001\u0000\u0000\u0000\t?\u0001\u0000\u0000\u0000\u000bA\u0001"+ + "\u0000\u0000\u0000\rC\u0001\u0000\u0000\u0000\u000fE\u0001\u0000\u0000"+ + "\u0000\u0011H\u0001\u0000\u0000\u0000\u0013K\u0001\u0000\u0000\u0000\u0015"+ + "M\u0001\u0000\u0000\u0000\u0017T\u0001\u0000\u0000\u0000\u0019Z\u0001"+ + "\u0000\u0000\u0000\u001bb\u0001\u0000\u0000\u0000\u001dg\u0001\u0000\u0000"+ + "\u0000\u001fl\u0001\u0000\u0000\u0000!v\u0001\u0000\u0000\u0000#\u008e"+ + "\u0001\u0000\u0000\u0000%\u0090\u0001\u0000\u0000\u0000\'\u009b\u0001"+ + "\u0000\u0000\u0000)\u00a3\u0001\u0000\u0000\u0000+\u00a5\u0001\u0000\u0000"+ + "\u0000-\u00af\u0001\u0000\u0000\u0000/\u00b8\u0001\u0000\u0000\u00001"+ + "\u00c6\u0001\u0000\u0000\u00003\u00d6\u0001\u0000\u0000\u00005\u00e0\u0001"+ + "\u0000\u0000\u000078\u0005{\u0000\u00008\u0002\u0001\u0000\u0000\u0000"+ + "9:\u0005}\u0000\u0000:\u0004\u0001\u0000\u0000\u0000;<\u0005;\u0000\u0000"+ + "<\u0006\u0001\u0000\u0000\u0000=>\u0005=\u0000\u0000>\b\u0001\u0000\u0000"+ + "\u0000?@\u0005[\u0000\u0000@\n\u0001\u0000\u0000\u0000AB\u0005]\u0000"+ + "\u0000B\f\u0001\u0000\u0000\u0000CD\u0005,\u0000\u0000D\u000e\u0001\u0000"+ + "\u0000\u0000EF\u0005-\u0000\u0000FG\u0005>\u0000\u0000G\u0010\u0001\u0000"+ + "\u0000\u0000HI\u0005-\u0000\u0000IJ\u0005-\u0000\u0000J\u0012\u0001\u0000"+ + "\u0000\u0000KL\u0005:\u0000\u0000L\u0014\u0001\u0000\u0000\u0000MN\u0007"+ + "\u0000\u0000\u0000NO\u0007\u0001\u0000\u0000OP\u0007\u0002\u0000\u0000"+ + "PQ\u0007\u0003\u0000\u0000QR\u0007\u0004\u0000\u0000RS\u0007\u0001\u0000"+ + "\u0000S\u0016\u0001\u0000\u0000\u0000TU\u0007\u0005\u0000\u0000UV\u0007"+ + "\u0002\u0000\u0000VW\u0007\u0006\u0000\u0000WX\u0007\u0007\u0000\u0000"+ + "XY\u0007\b\u0000\u0000Y\u0018\u0001\u0000\u0000\u0000Z[\u0007\t\u0000"+ + "\u0000[\\\u0007\u0003\u0000\u0000\\]\u0007\u0005\u0000\u0000]^\u0007\u0002"+ + "\u0000\u0000^_\u0007\u0006\u0000\u0000_`\u0007\u0007\u0000\u0000`a\u0007"+ + "\b\u0000\u0000a\u001a\u0001\u0000\u0000\u0000bc\u0007\n\u0000\u0000cd"+ + "\u0007\u000b\u0000\u0000de\u0007\t\u0000\u0000ef\u0007\f\u0000\u0000f"+ + "\u001c\u0001\u0000\u0000\u0000gh\u0007\f\u0000\u0000hi\u0007\t\u0000\u0000"+ + "ij\u0007\u0005\u0000\u0000jk\u0007\f\u0000\u0000k\u001e\u0001\u0000\u0000"+ + "\u0000lm\u0007\u0000\u0000\u0000mn\u0007\r\u0000\u0000no\u0007\u000e\u0000"+ + "\u0000op\u0007\u0005\u0000\u0000pq\u0007\u0002\u0000\u0000qr\u0007\u0006"+ + "\u0000\u0000rs\u0007\u0007\u0000\u0000st\u0007\b\u0000\u0000t \u0001\u0000"+ + "\u0000\u0000uw\u0005-\u0000\u0000vu\u0001\u0000\u0000\u0000vw\u0001\u0000"+ + "\u0000\u0000w\u008c\u0001\u0000\u0000\u0000xz\u0005.\u0000\u0000y{\u0003"+ + "#\u0011\u0000zy\u0001\u0000\u0000\u0000{|\u0001\u0000\u0000\u0000|z\u0001"+ + "\u0000\u0000\u0000|}\u0001\u0000\u0000\u0000}\u008d\u0001\u0000\u0000"+ + "\u0000~\u0080\u0003#\u0011\u0000\u007f~\u0001\u0000\u0000\u0000\u0080"+ + "\u0081\u0001\u0000\u0000\u0000\u0081\u007f\u0001\u0000\u0000\u0000\u0081"+ + "\u0082\u0001\u0000\u0000\u0000\u0082\u008a\u0001\u0000\u0000\u0000\u0083"+ + "\u0087\u0005.\u0000\u0000\u0084\u0086\u0003#\u0011\u0000\u0085\u0084\u0001"+ + "\u0000\u0000\u0000\u0086\u0089\u0001\u0000\u0000\u0000\u0087\u0085\u0001"+ + "\u0000\u0000\u0000\u0087\u0088\u0001\u0000\u0000\u0000\u0088\u008b\u0001"+ + "\u0000\u0000\u0000\u0089\u0087\u0001\u0000\u0000\u0000\u008a\u0083\u0001"+ + "\u0000\u0000\u0000\u008a\u008b\u0001\u0000\u0000\u0000\u008b\u008d\u0001"+ + "\u0000\u0000\u0000\u008cx\u0001\u0000\u0000\u0000\u008c\u007f\u0001\u0000"+ + "\u0000\u0000\u008d\"\u0001\u0000\u0000\u0000\u008e\u008f\u0007\u000f\u0000"+ + "\u0000\u008f$\u0001\u0000\u0000\u0000\u0090\u0096\u0005\"\u0000\u0000"+ + "\u0091\u0092\u0005\\\u0000\u0000\u0092\u0095\u0005\"\u0000\u0000\u0093"+ + "\u0095\t\u0000\u0000\u0000\u0094\u0091\u0001\u0000\u0000\u0000\u0094\u0093"+ + "\u0001\u0000\u0000\u0000\u0095\u0098\u0001\u0000\u0000\u0000\u0096\u0097"+ + "\u0001\u0000\u0000\u0000\u0096\u0094\u0001\u0000\u0000\u0000\u0097\u0099"+ + "\u0001\u0000\u0000\u0000\u0098\u0096\u0001\u0000\u0000\u0000\u0099\u009a"+ + "\u0005\"\u0000\u0000\u009a&\u0001\u0000\u0000\u0000\u009b\u00a0\u0003"+ + ")\u0014\u0000\u009c\u009f\u0003)\u0014\u0000\u009d\u009f\u0003#\u0011"+ + "\u0000\u009e\u009c\u0001\u0000\u0000\u0000\u009e\u009d\u0001\u0000\u0000"+ + "\u0000\u009f\u00a2\u0001\u0000\u0000\u0000\u00a0\u009e\u0001\u0000\u0000"+ + "\u0000\u00a0\u00a1\u0001\u0000\u0000\u0000\u00a1(\u0001\u0000\u0000\u0000"+ + "\u00a2\u00a0\u0001\u0000\u0000\u0000\u00a3\u00a4\u0007\u0010\u0000\u0000"+ + "\u00a4*\u0001\u0000\u0000\u0000\u00a5\u00aa\u0005<\u0000\u0000\u00a6\u00a9"+ + "\u0003-\u0016\u0000\u00a7\u00a9\b\u0011\u0000\u0000\u00a8\u00a6\u0001"+ + "\u0000\u0000\u0000\u00a8\u00a7\u0001\u0000\u0000\u0000\u00a9\u00ac\u0001"+ + "\u0000\u0000\u0000\u00aa\u00a8\u0001\u0000\u0000\u0000\u00aa\u00ab\u0001"+ + "\u0000\u0000\u0000\u00ab\u00ad\u0001\u0000\u0000\u0000\u00ac\u00aa\u0001"+ + "\u0000\u0000\u0000\u00ad\u00ae\u0005>\u0000\u0000\u00ae,\u0001\u0000\u0000"+ + "\u0000\u00af\u00b3\u0005<\u0000\u0000\u00b0\u00b2\t\u0000\u0000\u0000"+ + "\u00b1\u00b0\u0001\u0000\u0000\u0000\u00b2\u00b5\u0001\u0000\u0000\u0000"+ + "\u00b3\u00b4\u0001\u0000\u0000\u0000\u00b3\u00b1\u0001\u0000\u0000\u0000"+ + "\u00b4\u00b6\u0001\u0000\u0000\u0000\u00b5\u00b3\u0001\u0000\u0000\u0000"+ + "\u00b6\u00b7\u0005>\u0000\u0000\u00b7.\u0001\u0000\u0000\u0000\u00b8\u00b9"+ + "\u0005/\u0000\u0000\u00b9\u00ba\u0005*\u0000\u0000\u00ba\u00be\u0001\u0000"+ + "\u0000\u0000\u00bb\u00bd\t\u0000\u0000\u0000\u00bc\u00bb\u0001\u0000\u0000"+ + "\u0000\u00bd\u00c0\u0001\u0000\u0000\u0000\u00be\u00bf\u0001\u0000\u0000"+ + "\u0000\u00be\u00bc\u0001\u0000\u0000\u0000\u00bf\u00c1\u0001\u0000\u0000"+ + "\u0000\u00c0\u00be\u0001\u0000\u0000\u0000\u00c1\u00c2\u0005*\u0000\u0000"+ + "\u00c2\u00c3\u0005/\u0000\u0000\u00c3\u00c4\u0001\u0000\u0000\u0000\u00c4"+ + "\u00c5\u0006\u0017\u0000\u0000\u00c50\u0001\u0000\u0000\u0000\u00c6\u00c7"+ + "\u0005/\u0000\u0000\u00c7\u00c8\u0005/\u0000\u0000\u00c8\u00cc\u0001\u0000"+ + "\u0000\u0000\u00c9\u00cb\t\u0000\u0000\u0000\u00ca\u00c9\u0001\u0000\u0000"+ + "\u0000\u00cb\u00ce\u0001\u0000\u0000\u0000\u00cc\u00cd\u0001\u0000\u0000"+ + "\u0000\u00cc\u00ca\u0001\u0000\u0000\u0000\u00cd\u00d0\u0001\u0000\u0000"+ + "\u0000\u00ce\u00cc\u0001\u0000\u0000\u0000\u00cf\u00d1\u0005\r\u0000\u0000"+ + "\u00d0\u00cf\u0001\u0000\u0000\u0000\u00d0\u00d1\u0001\u0000\u0000\u0000"+ + "\u00d1\u00d2\u0001\u0000\u0000\u0000\u00d2\u00d3\u0005\n\u0000\u0000\u00d3"+ + "\u00d4\u0001\u0000\u0000\u0000\u00d4\u00d5\u0006\u0018\u0000\u0000\u00d5"+ + "2\u0001\u0000\u0000\u0000\u00d6\u00da\u0005#\u0000\u0000\u00d7\u00d9\b"+ + "\u0012\u0000\u0000\u00d8\u00d7\u0001\u0000\u0000\u0000\u00d9\u00dc\u0001"+ + "\u0000\u0000\u0000\u00da\u00d8\u0001\u0000\u0000\u0000\u00da\u00db\u0001"+ + "\u0000\u0000\u0000\u00db\u00dd\u0001\u0000\u0000\u0000\u00dc\u00da\u0001"+ + "\u0000\u0000\u0000\u00dd\u00de\u0006\u0019\u0000\u0000\u00de4\u0001\u0000"+ + "\u0000\u0000\u00df\u00e1\u0007\u0013\u0000\u0000\u00e0\u00df\u0001\u0000"+ + "\u0000\u0000\u00e1\u00e2\u0001\u0000\u0000\u0000\u00e2\u00e0\u0001\u0000"+ + "\u0000\u0000\u00e2\u00e3\u0001\u0000\u0000\u0000\u00e3\u00e4\u0001\u0000"+ + "\u0000\u0000\u00e4\u00e5\u0006\u001a\u0000\u0000\u00e56\u0001\u0000\u0000"+ + "\u0000\u0013\u0000v|\u0081\u0087\u008a\u008c\u0094\u0096\u009e\u00a0\u00a8"+ + "\u00aa\u00b3\u00be\u00cc\u00d0\u00da\u00e2\u0001\u0006\u0000\u0000"; + public static final ATN _ATN = + new ATNDeserializer().deserialize(_serializedATN.toCharArray()); + static { + _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()]; + for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) { + _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i); + } + } +} \ No newline at end of file diff --git a/solver/src/main/java/org/ucfs/input/utils/dot/DotLexer.tokens b/solver/src/main/java/org/ucfs/input/utils/dot/DotLexer.tokens new file mode 100644 index 000000000..9c46a081b --- /dev/null +++ b/solver/src/main/java/org/ucfs/input/utils/dot/DotLexer.tokens @@ -0,0 +1,34 @@ +T__0=1 +T__1=2 +T__2=3 +T__3=4 +T__4=5 +T__5=6 +T__6=7 +T__7=8 +T__8=9 +T__9=10 +STRICT=11 +GRAPH=12 +DIGRAPH=13 +NODE=14 +EDGE=15 +SUBGRAPH=16 +NUMBER=17 +STRING=18 +ID=19 +HTML_STRING=20 +COMMENT=21 +LINE_COMMENT=22 +PREPROC=23 +WS=24 +'{'=1 +'}'=2 +';'=3 +'='=4 +'['=5 +']'=6 +','=7 +'->'=8 +'--'=9 +':'=10 diff --git a/solver/src/main/java/org/ucfs/input/utils/dot/DotListener.java b/solver/src/main/java/org/ucfs/input/utils/dot/DotListener.java new file mode 100644 index 000000000..51ad2f205 --- /dev/null +++ b/solver/src/main/java/org/ucfs/input/utils/dot/DotListener.java @@ -0,0 +1,150 @@ +// Generated from Dot.g4 by ANTLR 4.13.2 +package org.ucfs.input.utils.dot; +import org.antlr.v4.runtime.tree.ParseTreeListener; + +/** + * This interface defines a complete listener for a parse tree produced by + * {@link DotParser}. + */ +public interface DotListener extends ParseTreeListener { + /** + * Enter a parse tree produced by {@link DotParser#graph}. + * @param ctx the parse tree + */ + void enterGraph(DotParser.GraphContext ctx); + /** + * Exit a parse tree produced by {@link DotParser#graph}. + * @param ctx the parse tree + */ + void exitGraph(DotParser.GraphContext ctx); + /** + * Enter a parse tree produced by {@link DotParser#stmt_list}. + * @param ctx the parse tree + */ + void enterStmt_list(DotParser.Stmt_listContext ctx); + /** + * Exit a parse tree produced by {@link DotParser#stmt_list}. + * @param ctx the parse tree + */ + void exitStmt_list(DotParser.Stmt_listContext ctx); + /** + * Enter a parse tree produced by {@link DotParser#stmt}. + * @param ctx the parse tree + */ + void enterStmt(DotParser.StmtContext ctx); + /** + * Exit a parse tree produced by {@link DotParser#stmt}. + * @param ctx the parse tree + */ + void exitStmt(DotParser.StmtContext ctx); + /** + * Enter a parse tree produced by {@link DotParser#attr_stmt}. + * @param ctx the parse tree + */ + void enterAttr_stmt(DotParser.Attr_stmtContext ctx); + /** + * Exit a parse tree produced by {@link DotParser#attr_stmt}. + * @param ctx the parse tree + */ + void exitAttr_stmt(DotParser.Attr_stmtContext ctx); + /** + * Enter a parse tree produced by {@link DotParser#attr_list}. + * @param ctx the parse tree + */ + void enterAttr_list(DotParser.Attr_listContext ctx); + /** + * Exit a parse tree produced by {@link DotParser#attr_list}. + * @param ctx the parse tree + */ + void exitAttr_list(DotParser.Attr_listContext ctx); + /** + * Enter a parse tree produced by {@link DotParser#attr}. + * @param ctx the parse tree + */ + void enterAttr(DotParser.AttrContext ctx); + /** + * Exit a parse tree produced by {@link DotParser#attr}. + * @param ctx the parse tree + */ + void exitAttr(DotParser.AttrContext ctx); + /** + * Enter a parse tree produced by {@link DotParser#edge_stmt}. + * @param ctx the parse tree + */ + void enterEdge_stmt(DotParser.Edge_stmtContext ctx); + /** + * Exit a parse tree produced by {@link DotParser#edge_stmt}. + * @param ctx the parse tree + */ + void exitEdge_stmt(DotParser.Edge_stmtContext ctx); + /** + * Enter a parse tree produced by {@link DotParser#edgeRHS}. + * @param ctx the parse tree + */ + void enterEdgeRHS(DotParser.EdgeRHSContext ctx); + /** + * Exit a parse tree produced by {@link DotParser#edgeRHS}. + * @param ctx the parse tree + */ + void exitEdgeRHS(DotParser.EdgeRHSContext ctx); + /** + * Enter a parse tree produced by {@link DotParser#edgeop}. + * @param ctx the parse tree + */ + void enterEdgeop(DotParser.EdgeopContext ctx); + /** + * Exit a parse tree produced by {@link DotParser#edgeop}. + * @param ctx the parse tree + */ + void exitEdgeop(DotParser.EdgeopContext ctx); + /** + * Enter a parse tree produced by {@link DotParser#node_stmt}. + * @param ctx the parse tree + */ + void enterNode_stmt(DotParser.Node_stmtContext ctx); + /** + * Exit a parse tree produced by {@link DotParser#node_stmt}. + * @param ctx the parse tree + */ + void exitNode_stmt(DotParser.Node_stmtContext ctx); + /** + * Enter a parse tree produced by {@link DotParser#node_id}. + * @param ctx the parse tree + */ + void enterNode_id(DotParser.Node_idContext ctx); + /** + * Exit a parse tree produced by {@link DotParser#node_id}. + * @param ctx the parse tree + */ + void exitNode_id(DotParser.Node_idContext ctx); + /** + * Enter a parse tree produced by {@link DotParser#port}. + * @param ctx the parse tree + */ + void enterPort(DotParser.PortContext ctx); + /** + * Exit a parse tree produced by {@link DotParser#port}. + * @param ctx the parse tree + */ + void exitPort(DotParser.PortContext ctx); + /** + * Enter a parse tree produced by {@link DotParser#subgraph}. + * @param ctx the parse tree + */ + void enterSubgraph(DotParser.SubgraphContext ctx); + /** + * Exit a parse tree produced by {@link DotParser#subgraph}. + * @param ctx the parse tree + */ + void exitSubgraph(DotParser.SubgraphContext ctx); + /** + * Enter a parse tree produced by {@link DotParser#id_}. + * @param ctx the parse tree + */ + void enterId_(DotParser.Id_Context ctx); + /** + * Exit a parse tree produced by {@link DotParser#id_}. + * @param ctx the parse tree + */ + void exitId_(DotParser.Id_Context ctx); +} \ No newline at end of file diff --git a/solver/src/main/java/org/ucfs/input/utils/dot/DotParser.java b/solver/src/main/java/org/ucfs/input/utils/dot/DotParser.java new file mode 100644 index 000000000..0f28170e7 --- /dev/null +++ b/solver/src/main/java/org/ucfs/input/utils/dot/DotParser.java @@ -0,0 +1,1202 @@ +// Generated from Dot.g4 by ANTLR 4.13.2 +package org.ucfs.input.utils.dot; +import org.antlr.v4.runtime.atn.*; +import org.antlr.v4.runtime.dfa.DFA; +import org.antlr.v4.runtime.*; +import org.antlr.v4.runtime.misc.*; +import org.antlr.v4.runtime.tree.*; +import java.util.List; +import java.util.Iterator; +import java.util.ArrayList; + +@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast", "CheckReturnValue", "this-escape"}) +public class DotParser extends Parser { + static { RuntimeMetaData.checkVersion("4.13.2", RuntimeMetaData.VERSION); } + + protected static final DFA[] _decisionToDFA; + protected static final PredictionContextCache _sharedContextCache = + new PredictionContextCache(); + public static final int + T__0=1, T__1=2, T__2=3, T__3=4, T__4=5, T__5=6, T__6=7, T__7=8, T__8=9, + T__9=10, STRICT=11, GRAPH=12, DIGRAPH=13, NODE=14, EDGE=15, SUBGRAPH=16, + NUMBER=17, STRING=18, ID=19, HTML_STRING=20, COMMENT=21, LINE_COMMENT=22, + PREPROC=23, WS=24; + public static final int + RULE_graph = 0, RULE_stmt_list = 1, RULE_stmt = 2, RULE_attr_stmt = 3, + RULE_attr_list = 4, RULE_attr = 5, RULE_edge_stmt = 6, RULE_edgeRHS = 7, + RULE_edgeop = 8, RULE_node_stmt = 9, RULE_node_id = 10, RULE_port = 11, + RULE_subgraph = 12, RULE_id_ = 13; + private static String[] makeRuleNames() { + return new String[] { + "graph", "stmt_list", "stmt", "attr_stmt", "attr_list", "attr", "edge_stmt", + "edgeRHS", "edgeop", "node_stmt", "node_id", "port", "subgraph", "id_" + }; + } + public static final String[] ruleNames = makeRuleNames(); + + private static String[] makeLiteralNames() { + return new String[] { + null, "'{'", "'}'", "';'", "'='", "'['", "']'", "','", "'->'", "'--'", + "':'" + }; + } + private static final String[] _LITERAL_NAMES = makeLiteralNames(); + private static String[] makeSymbolicNames() { + return new String[] { + null, null, null, null, null, null, null, null, null, null, null, "STRICT", + "GRAPH", "DIGRAPH", "NODE", "EDGE", "SUBGRAPH", "NUMBER", "STRING", "ID", + "HTML_STRING", "COMMENT", "LINE_COMMENT", "PREPROC", "WS" + }; + } + private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames(); + public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES); + + /** + * @deprecated Use {@link #VOCABULARY} instead. + */ + @Deprecated + public static final String[] tokenNames; + static { + tokenNames = new String[_SYMBOLIC_NAMES.length]; + for (int i = 0; i < tokenNames.length; i++) { + tokenNames[i] = VOCABULARY.getLiteralName(i); + if (tokenNames[i] == null) { + tokenNames[i] = VOCABULARY.getSymbolicName(i); + } + + if (tokenNames[i] == null) { + tokenNames[i] = ""; + } + } + } + + @Override + @Deprecated + public String[] getTokenNames() { + return tokenNames; + } + + @Override + + public Vocabulary getVocabulary() { + return VOCABULARY; + } + + @Override + public String getGrammarFileName() { return "Dot.g4"; } + + @Override + public String[] getRuleNames() { return ruleNames; } + + @Override + public String getSerializedATN() { return _serializedATN; } + + @Override + public ATN getATN() { return _ATN; } + + public DotParser(TokenStream input) { + super(input); + _interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache); + } + + @SuppressWarnings("CheckReturnValue") + public static class GraphContext extends ParserRuleContext { + public Stmt_listContext stmt_list() { + return getRuleContext(Stmt_listContext.class,0); + } + public TerminalNode EOF() { return getToken(DotParser.EOF, 0); } + public TerminalNode GRAPH() { return getToken(DotParser.GRAPH, 0); } + public TerminalNode DIGRAPH() { return getToken(DotParser.DIGRAPH, 0); } + public TerminalNode STRICT() { return getToken(DotParser.STRICT, 0); } + public Id_Context id_() { + return getRuleContext(Id_Context.class,0); + } + public GraphContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_graph; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof DotListener ) ((DotListener)listener).enterGraph(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof DotListener ) ((DotListener)listener).exitGraph(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof DotVisitor ) return ((DotVisitor)visitor).visitGraph(this); + else return visitor.visitChildren(this); + } + } + + public final GraphContext graph() throws RecognitionException { + GraphContext _localctx = new GraphContext(_ctx, getState()); + enterRule(_localctx, 0, RULE_graph); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(29); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==STRICT) { + { + setState(28); + match(STRICT); + } + } + + setState(31); + _la = _input.LA(1); + if ( !(_la==GRAPH || _la==DIGRAPH) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(33); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 1966080L) != 0)) { + { + setState(32); + id_(); + } + } + + setState(35); + match(T__0); + setState(36); + stmt_list(); + setState(37); + match(T__1); + setState(38); + match(EOF); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Stmt_listContext extends ParserRuleContext { + public List stmt() { + return getRuleContexts(StmtContext.class); + } + public StmtContext stmt(int i) { + return getRuleContext(StmtContext.class,i); + } + public Stmt_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_stmt_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof DotListener ) ((DotListener)listener).enterStmt_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof DotListener ) ((DotListener)listener).exitStmt_list(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof DotVisitor ) return ((DotVisitor)visitor).visitStmt_list(this); + else return visitor.visitChildren(this); + } + } + + public final Stmt_listContext stmt_list() throws RecognitionException { + Stmt_listContext _localctx = new Stmt_listContext(_ctx, getState()); + enterRule(_localctx, 2, RULE_stmt_list); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(46); + _errHandler.sync(this); + _la = _input.LA(1); + while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 2084866L) != 0)) { + { + { + setState(40); + stmt(); + setState(42); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==T__2) { + { + setState(41); + match(T__2); + } + } + + } + } + setState(48); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class StmtContext extends ParserRuleContext { + public Node_stmtContext node_stmt() { + return getRuleContext(Node_stmtContext.class,0); + } + public Edge_stmtContext edge_stmt() { + return getRuleContext(Edge_stmtContext.class,0); + } + public Attr_stmtContext attr_stmt() { + return getRuleContext(Attr_stmtContext.class,0); + } + public List id_() { + return getRuleContexts(Id_Context.class); + } + public Id_Context id_(int i) { + return getRuleContext(Id_Context.class,i); + } + public SubgraphContext subgraph() { + return getRuleContext(SubgraphContext.class,0); + } + public StmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_stmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof DotListener ) ((DotListener)listener).enterStmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof DotListener ) ((DotListener)listener).exitStmt(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof DotVisitor ) return ((DotVisitor)visitor).visitStmt(this); + else return visitor.visitChildren(this); + } + } + + public final StmtContext stmt() throws RecognitionException { + StmtContext _localctx = new StmtContext(_ctx, getState()); + enterRule(_localctx, 4, RULE_stmt); + try { + setState(57); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,4,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(49); + node_stmt(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(50); + edge_stmt(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(51); + attr_stmt(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(52); + id_(); + setState(53); + match(T__3); + setState(54); + id_(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(56); + subgraph(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Attr_stmtContext extends ParserRuleContext { + public Attr_listContext attr_list() { + return getRuleContext(Attr_listContext.class,0); + } + public TerminalNode GRAPH() { return getToken(DotParser.GRAPH, 0); } + public TerminalNode NODE() { return getToken(DotParser.NODE, 0); } + public TerminalNode EDGE() { return getToken(DotParser.EDGE, 0); } + public Attr_stmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_attr_stmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof DotListener ) ((DotListener)listener).enterAttr_stmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof DotListener ) ((DotListener)listener).exitAttr_stmt(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof DotVisitor ) return ((DotVisitor)visitor).visitAttr_stmt(this); + else return visitor.visitChildren(this); + } + } + + public final Attr_stmtContext attr_stmt() throws RecognitionException { + Attr_stmtContext _localctx = new Attr_stmtContext(_ctx, getState()); + enterRule(_localctx, 6, RULE_attr_stmt); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(59); + _la = _input.LA(1); + if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 53248L) != 0)) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(60); + attr_list(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Attr_listContext extends ParserRuleContext { + public List attr() { + return getRuleContexts(AttrContext.class); + } + public AttrContext attr(int i) { + return getRuleContext(AttrContext.class,i); + } + public Attr_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_attr_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof DotListener ) ((DotListener)listener).enterAttr_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof DotListener ) ((DotListener)listener).exitAttr_list(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof DotVisitor ) return ((DotVisitor)visitor).visitAttr_list(this); + else return visitor.visitChildren(this); + } + } + + public final Attr_listContext attr_list() throws RecognitionException { + Attr_listContext _localctx = new Attr_listContext(_ctx, getState()); + enterRule(_localctx, 8, RULE_attr_list); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(70); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(62); + match(T__4); + setState(66); + _errHandler.sync(this); + _la = _input.LA(1); + while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 1966080L) != 0)) { + { + { + setState(63); + attr(); + } + } + setState(68); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(69); + match(T__5); + } + } + setState(72); + _errHandler.sync(this); + _la = _input.LA(1); + } while ( _la==T__4 ); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AttrContext extends ParserRuleContext { + public Id_Context label_name; + public Id_Context label_value; + public List id_() { + return getRuleContexts(Id_Context.class); + } + public Id_Context id_(int i) { + return getRuleContext(Id_Context.class,i); + } + public AttrContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_attr; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof DotListener ) ((DotListener)listener).enterAttr(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof DotListener ) ((DotListener)listener).exitAttr(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof DotVisitor ) return ((DotVisitor)visitor).visitAttr(this); + else return visitor.visitChildren(this); + } + } + + public final AttrContext attr() throws RecognitionException { + AttrContext _localctx = new AttrContext(_ctx, getState()); + enterRule(_localctx, 10, RULE_attr); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(74); + ((AttrContext)_localctx).label_name = id_(); + setState(77); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==T__3) { + { + setState(75); + match(T__3); + setState(76); + ((AttrContext)_localctx).label_value = id_(); + } + } + + setState(80); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==T__2 || _la==T__6) { + { + setState(79); + _la = _input.LA(1); + if ( !(_la==T__2 || _la==T__6) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Edge_stmtContext extends ParserRuleContext { + public EdgeRHSContext edgeRHS() { + return getRuleContext(EdgeRHSContext.class,0); + } + public Node_idContext node_id() { + return getRuleContext(Node_idContext.class,0); + } + public SubgraphContext subgraph() { + return getRuleContext(SubgraphContext.class,0); + } + public Attr_listContext attr_list() { + return getRuleContext(Attr_listContext.class,0); + } + public Edge_stmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_edge_stmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof DotListener ) ((DotListener)listener).enterEdge_stmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof DotListener ) ((DotListener)listener).exitEdge_stmt(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof DotVisitor ) return ((DotVisitor)visitor).visitEdge_stmt(this); + else return visitor.visitChildren(this); + } + } + + public final Edge_stmtContext edge_stmt() throws RecognitionException { + Edge_stmtContext _localctx = new Edge_stmtContext(_ctx, getState()); + enterRule(_localctx, 12, RULE_edge_stmt); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(84); + _errHandler.sync(this); + switch (_input.LA(1)) { + case NUMBER: + case STRING: + case ID: + case HTML_STRING: + { + setState(82); + node_id(); + } + break; + case T__0: + case SUBGRAPH: + { + setState(83); + subgraph(); + } + break; + default: + throw new NoViableAltException(this); + } + setState(86); + edgeRHS(); + setState(88); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==T__4) { + { + setState(87); + attr_list(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class EdgeRHSContext extends ParserRuleContext { + public List edgeop() { + return getRuleContexts(EdgeopContext.class); + } + public EdgeopContext edgeop(int i) { + return getRuleContext(EdgeopContext.class,i); + } + public List node_id() { + return getRuleContexts(Node_idContext.class); + } + public Node_idContext node_id(int i) { + return getRuleContext(Node_idContext.class,i); + } + public List subgraph() { + return getRuleContexts(SubgraphContext.class); + } + public SubgraphContext subgraph(int i) { + return getRuleContext(SubgraphContext.class,i); + } + public EdgeRHSContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_edgeRHS; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof DotListener ) ((DotListener)listener).enterEdgeRHS(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof DotListener ) ((DotListener)listener).exitEdgeRHS(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof DotVisitor ) return ((DotVisitor)visitor).visitEdgeRHS(this); + else return visitor.visitChildren(this); + } + } + + public final EdgeRHSContext edgeRHS() throws RecognitionException { + EdgeRHSContext _localctx = new EdgeRHSContext(_ctx, getState()); + enterRule(_localctx, 14, RULE_edgeRHS); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(95); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(90); + edgeop(); + setState(93); + _errHandler.sync(this); + switch (_input.LA(1)) { + case NUMBER: + case STRING: + case ID: + case HTML_STRING: + { + setState(91); + node_id(); + } + break; + case T__0: + case SUBGRAPH: + { + setState(92); + subgraph(); + } + break; + default: + throw new NoViableAltException(this); + } + } + } + setState(97); + _errHandler.sync(this); + _la = _input.LA(1); + } while ( _la==T__7 || _la==T__8 ); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class EdgeopContext extends ParserRuleContext { + public EdgeopContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_edgeop; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof DotListener ) ((DotListener)listener).enterEdgeop(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof DotListener ) ((DotListener)listener).exitEdgeop(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof DotVisitor ) return ((DotVisitor)visitor).visitEdgeop(this); + else return visitor.visitChildren(this); + } + } + + public final EdgeopContext edgeop() throws RecognitionException { + EdgeopContext _localctx = new EdgeopContext(_ctx, getState()); + enterRule(_localctx, 16, RULE_edgeop); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(99); + _la = _input.LA(1); + if ( !(_la==T__7 || _la==T__8) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Node_stmtContext extends ParserRuleContext { + public Node_idContext node_id() { + return getRuleContext(Node_idContext.class,0); + } + public Attr_listContext attr_list() { + return getRuleContext(Attr_listContext.class,0); + } + public Node_stmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_node_stmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof DotListener ) ((DotListener)listener).enterNode_stmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof DotListener ) ((DotListener)listener).exitNode_stmt(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof DotVisitor ) return ((DotVisitor)visitor).visitNode_stmt(this); + else return visitor.visitChildren(this); + } + } + + public final Node_stmtContext node_stmt() throws RecognitionException { + Node_stmtContext _localctx = new Node_stmtContext(_ctx, getState()); + enterRule(_localctx, 18, RULE_node_stmt); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(101); + node_id(); + setState(103); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==T__4) { + { + setState(102); + attr_list(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Node_idContext extends ParserRuleContext { + public Id_Context id_() { + return getRuleContext(Id_Context.class,0); + } + public PortContext port() { + return getRuleContext(PortContext.class,0); + } + public Node_idContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_node_id; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof DotListener ) ((DotListener)listener).enterNode_id(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof DotListener ) ((DotListener)listener).exitNode_id(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof DotVisitor ) return ((DotVisitor)visitor).visitNode_id(this); + else return visitor.visitChildren(this); + } + } + + public final Node_idContext node_id() throws RecognitionException { + Node_idContext _localctx = new Node_idContext(_ctx, getState()); + enterRule(_localctx, 20, RULE_node_id); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(105); + id_(); + setState(107); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==T__9) { + { + setState(106); + port(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class PortContext extends ParserRuleContext { + public List id_() { + return getRuleContexts(Id_Context.class); + } + public Id_Context id_(int i) { + return getRuleContext(Id_Context.class,i); + } + public PortContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_port; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof DotListener ) ((DotListener)listener).enterPort(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof DotListener ) ((DotListener)listener).exitPort(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof DotVisitor ) return ((DotVisitor)visitor).visitPort(this); + else return visitor.visitChildren(this); + } + } + + public final PortContext port() throws RecognitionException { + PortContext _localctx = new PortContext(_ctx, getState()); + enterRule(_localctx, 22, RULE_port); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(109); + match(T__9); + setState(110); + id_(); + setState(113); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==T__9) { + { + setState(111); + match(T__9); + setState(112); + id_(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class SubgraphContext extends ParserRuleContext { + public Stmt_listContext stmt_list() { + return getRuleContext(Stmt_listContext.class,0); + } + public TerminalNode SUBGRAPH() { return getToken(DotParser.SUBGRAPH, 0); } + public Id_Context id_() { + return getRuleContext(Id_Context.class,0); + } + public SubgraphContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_subgraph; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof DotListener ) ((DotListener)listener).enterSubgraph(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof DotListener ) ((DotListener)listener).exitSubgraph(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof DotVisitor ) return ((DotVisitor)visitor).visitSubgraph(this); + else return visitor.visitChildren(this); + } + } + + public final SubgraphContext subgraph() throws RecognitionException { + SubgraphContext _localctx = new SubgraphContext(_ctx, getState()); + enterRule(_localctx, 24, RULE_subgraph); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(119); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==SUBGRAPH) { + { + setState(115); + match(SUBGRAPH); + setState(117); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 1966080L) != 0)) { + { + setState(116); + id_(); + } + } + + } + } + + setState(121); + match(T__0); + setState(122); + stmt_list(); + setState(123); + match(T__1); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Id_Context extends ParserRuleContext { + public TerminalNode ID() { return getToken(DotParser.ID, 0); } + public TerminalNode STRING() { return getToken(DotParser.STRING, 0); } + public TerminalNode HTML_STRING() { return getToken(DotParser.HTML_STRING, 0); } + public TerminalNode NUMBER() { return getToken(DotParser.NUMBER, 0); } + public Id_Context(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_id_; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof DotListener ) ((DotListener)listener).enterId_(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof DotListener ) ((DotListener)listener).exitId_(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof DotVisitor ) return ((DotVisitor)visitor).visitId_(this); + else return visitor.visitChildren(this); + } + } + + public final Id_Context id_() throws RecognitionException { + Id_Context _localctx = new Id_Context(_ctx, getState()); + enterRule(_localctx, 26, RULE_id_); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(125); + _la = _input.LA(1); + if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 1966080L) != 0)) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static final String _serializedATN = + "\u0004\u0001\u0018\u0080\u0002\u0000\u0007\u0000\u0002\u0001\u0007\u0001"+ + "\u0002\u0002\u0007\u0002\u0002\u0003\u0007\u0003\u0002\u0004\u0007\u0004"+ + "\u0002\u0005\u0007\u0005\u0002\u0006\u0007\u0006\u0002\u0007\u0007\u0007"+ + "\u0002\b\u0007\b\u0002\t\u0007\t\u0002\n\u0007\n\u0002\u000b\u0007\u000b"+ + "\u0002\f\u0007\f\u0002\r\u0007\r\u0001\u0000\u0003\u0000\u001e\b\u0000"+ + "\u0001\u0000\u0001\u0000\u0003\u0000\"\b\u0000\u0001\u0000\u0001\u0000"+ + "\u0001\u0000\u0001\u0000\u0001\u0000\u0001\u0001\u0001\u0001\u0003\u0001"+ + "+\b\u0001\u0005\u0001-\b\u0001\n\u0001\f\u00010\t\u0001\u0001\u0002\u0001"+ + "\u0002\u0001\u0002\u0001\u0002\u0001\u0002\u0001\u0002\u0001\u0002\u0001"+ + "\u0002\u0003\u0002:\b\u0002\u0001\u0003\u0001\u0003\u0001\u0003\u0001"+ + "\u0004\u0001\u0004\u0005\u0004A\b\u0004\n\u0004\f\u0004D\t\u0004\u0001"+ + "\u0004\u0004\u0004G\b\u0004\u000b\u0004\f\u0004H\u0001\u0005\u0001\u0005"+ + "\u0001\u0005\u0003\u0005N\b\u0005\u0001\u0005\u0003\u0005Q\b\u0005\u0001"+ + "\u0006\u0001\u0006\u0003\u0006U\b\u0006\u0001\u0006\u0001\u0006\u0003"+ + "\u0006Y\b\u0006\u0001\u0007\u0001\u0007\u0001\u0007\u0003\u0007^\b\u0007"+ + "\u0004\u0007`\b\u0007\u000b\u0007\f\u0007a\u0001\b\u0001\b\u0001\t\u0001"+ + "\t\u0003\th\b\t\u0001\n\u0001\n\u0003\nl\b\n\u0001\u000b\u0001\u000b\u0001"+ + "\u000b\u0001\u000b\u0003\u000br\b\u000b\u0001\f\u0001\f\u0003\fv\b\f\u0003"+ + "\fx\b\f\u0001\f\u0001\f\u0001\f\u0001\f\u0001\r\u0001\r\u0001\r\u0000"+ + "\u0000\u000e\u0000\u0002\u0004\u0006\b\n\f\u000e\u0010\u0012\u0014\u0016"+ + "\u0018\u001a\u0000\u0005\u0001\u0000\f\r\u0002\u0000\f\f\u000e\u000f\u0002"+ + "\u0000\u0003\u0003\u0007\u0007\u0001\u0000\b\t\u0001\u0000\u0011\u0014"+ + "\u0086\u0000\u001d\u0001\u0000\u0000\u0000\u0002.\u0001\u0000\u0000\u0000"+ + "\u00049\u0001\u0000\u0000\u0000\u0006;\u0001\u0000\u0000\u0000\bF\u0001"+ + "\u0000\u0000\u0000\nJ\u0001\u0000\u0000\u0000\fT\u0001\u0000\u0000\u0000"+ + "\u000e_\u0001\u0000\u0000\u0000\u0010c\u0001\u0000\u0000\u0000\u0012e"+ + "\u0001\u0000\u0000\u0000\u0014i\u0001\u0000\u0000\u0000\u0016m\u0001\u0000"+ + "\u0000\u0000\u0018w\u0001\u0000\u0000\u0000\u001a}\u0001\u0000\u0000\u0000"+ + "\u001c\u001e\u0005\u000b\u0000\u0000\u001d\u001c\u0001\u0000\u0000\u0000"+ + "\u001d\u001e\u0001\u0000\u0000\u0000\u001e\u001f\u0001\u0000\u0000\u0000"+ + "\u001f!\u0007\u0000\u0000\u0000 \"\u0003\u001a\r\u0000! \u0001\u0000\u0000"+ + "\u0000!\"\u0001\u0000\u0000\u0000\"#\u0001\u0000\u0000\u0000#$\u0005\u0001"+ + "\u0000\u0000$%\u0003\u0002\u0001\u0000%&\u0005\u0002\u0000\u0000&\'\u0005"+ + "\u0000\u0000\u0001\'\u0001\u0001\u0000\u0000\u0000(*\u0003\u0004\u0002"+ + "\u0000)+\u0005\u0003\u0000\u0000*)\u0001\u0000\u0000\u0000*+\u0001\u0000"+ + "\u0000\u0000+-\u0001\u0000\u0000\u0000,(\u0001\u0000\u0000\u0000-0\u0001"+ + "\u0000\u0000\u0000.,\u0001\u0000\u0000\u0000./\u0001\u0000\u0000\u0000"+ + "/\u0003\u0001\u0000\u0000\u00000.\u0001\u0000\u0000\u00001:\u0003\u0012"+ + "\t\u00002:\u0003\f\u0006\u00003:\u0003\u0006\u0003\u000045\u0003\u001a"+ + "\r\u000056\u0005\u0004\u0000\u000067\u0003\u001a\r\u00007:\u0001\u0000"+ + "\u0000\u00008:\u0003\u0018\f\u000091\u0001\u0000\u0000\u000092\u0001\u0000"+ + "\u0000\u000093\u0001\u0000\u0000\u000094\u0001\u0000\u0000\u000098\u0001"+ + "\u0000\u0000\u0000:\u0005\u0001\u0000\u0000\u0000;<\u0007\u0001\u0000"+ + "\u0000<=\u0003\b\u0004\u0000=\u0007\u0001\u0000\u0000\u0000>B\u0005\u0005"+ + "\u0000\u0000?A\u0003\n\u0005\u0000@?\u0001\u0000\u0000\u0000AD\u0001\u0000"+ + "\u0000\u0000B@\u0001\u0000\u0000\u0000BC\u0001\u0000\u0000\u0000CE\u0001"+ + "\u0000\u0000\u0000DB\u0001\u0000\u0000\u0000EG\u0005\u0006\u0000\u0000"+ + "F>\u0001\u0000\u0000\u0000GH\u0001\u0000\u0000\u0000HF\u0001\u0000\u0000"+ + "\u0000HI\u0001\u0000\u0000\u0000I\t\u0001\u0000\u0000\u0000JM\u0003\u001a"+ + "\r\u0000KL\u0005\u0004\u0000\u0000LN\u0003\u001a\r\u0000MK\u0001\u0000"+ + "\u0000\u0000MN\u0001\u0000\u0000\u0000NP\u0001\u0000\u0000\u0000OQ\u0007"+ + "\u0002\u0000\u0000PO\u0001\u0000\u0000\u0000PQ\u0001\u0000\u0000\u0000"+ + "Q\u000b\u0001\u0000\u0000\u0000RU\u0003\u0014\n\u0000SU\u0003\u0018\f"+ + "\u0000TR\u0001\u0000\u0000\u0000TS\u0001\u0000\u0000\u0000UV\u0001\u0000"+ + "\u0000\u0000VX\u0003\u000e\u0007\u0000WY\u0003\b\u0004\u0000XW\u0001\u0000"+ + "\u0000\u0000XY\u0001\u0000\u0000\u0000Y\r\u0001\u0000\u0000\u0000Z]\u0003"+ + "\u0010\b\u0000[^\u0003\u0014\n\u0000\\^\u0003\u0018\f\u0000][\u0001\u0000"+ + "\u0000\u0000]\\\u0001\u0000\u0000\u0000^`\u0001\u0000\u0000\u0000_Z\u0001"+ + "\u0000\u0000\u0000`a\u0001\u0000\u0000\u0000a_\u0001\u0000\u0000\u0000"+ + "ab\u0001\u0000\u0000\u0000b\u000f\u0001\u0000\u0000\u0000cd\u0007\u0003"+ + "\u0000\u0000d\u0011\u0001\u0000\u0000\u0000eg\u0003\u0014\n\u0000fh\u0003"+ + "\b\u0004\u0000gf\u0001\u0000\u0000\u0000gh\u0001\u0000\u0000\u0000h\u0013"+ + "\u0001\u0000\u0000\u0000ik\u0003\u001a\r\u0000jl\u0003\u0016\u000b\u0000"+ + "kj\u0001\u0000\u0000\u0000kl\u0001\u0000\u0000\u0000l\u0015\u0001\u0000"+ + "\u0000\u0000mn\u0005\n\u0000\u0000nq\u0003\u001a\r\u0000op\u0005\n\u0000"+ + "\u0000pr\u0003\u001a\r\u0000qo\u0001\u0000\u0000\u0000qr\u0001\u0000\u0000"+ + "\u0000r\u0017\u0001\u0000\u0000\u0000su\u0005\u0010\u0000\u0000tv\u0003"+ + "\u001a\r\u0000ut\u0001\u0000\u0000\u0000uv\u0001\u0000\u0000\u0000vx\u0001"+ + "\u0000\u0000\u0000ws\u0001\u0000\u0000\u0000wx\u0001\u0000\u0000\u0000"+ + "xy\u0001\u0000\u0000\u0000yz\u0005\u0001\u0000\u0000z{\u0003\u0002\u0001"+ + "\u0000{|\u0005\u0002\u0000\u0000|\u0019\u0001\u0000\u0000\u0000}~\u0007"+ + "\u0004\u0000\u0000~\u001b\u0001\u0000\u0000\u0000\u0012\u001d!*.9BHMP"+ + "TX]agkquw"; + public static final ATN _ATN = + new ATNDeserializer().deserialize(_serializedATN.toCharArray()); + static { + _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()]; + for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) { + _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i); + } + } +} \ No newline at end of file diff --git a/solver/src/main/java/org/ucfs/input/utils/dot/DotVisitor.java b/solver/src/main/java/org/ucfs/input/utils/dot/DotVisitor.java new file mode 100644 index 000000000..ce4178d74 --- /dev/null +++ b/solver/src/main/java/org/ucfs/input/utils/dot/DotVisitor.java @@ -0,0 +1,97 @@ +// Generated from Dot.g4 by ANTLR 4.13.2 +package org.ucfs.input.utils.dot; +import org.antlr.v4.runtime.tree.ParseTreeVisitor; + +/** + * This interface defines a complete generic visitor for a parse tree produced + * by {@link DotParser}. + * + * @param The return type of the visit operation. Use {@link Void} for + * operations with no return type. + */ +public interface DotVisitor extends ParseTreeVisitor { + /** + * Visit a parse tree produced by {@link DotParser#graph}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitGraph(DotParser.GraphContext ctx); + /** + * Visit a parse tree produced by {@link DotParser#stmt_list}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitStmt_list(DotParser.Stmt_listContext ctx); + /** + * Visit a parse tree produced by {@link DotParser#stmt}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitStmt(DotParser.StmtContext ctx); + /** + * Visit a parse tree produced by {@link DotParser#attr_stmt}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitAttr_stmt(DotParser.Attr_stmtContext ctx); + /** + * Visit a parse tree produced by {@link DotParser#attr_list}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitAttr_list(DotParser.Attr_listContext ctx); + /** + * Visit a parse tree produced by {@link DotParser#attr}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitAttr(DotParser.AttrContext ctx); + /** + * Visit a parse tree produced by {@link DotParser#edge_stmt}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitEdge_stmt(DotParser.Edge_stmtContext ctx); + /** + * Visit a parse tree produced by {@link DotParser#edgeRHS}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitEdgeRHS(DotParser.EdgeRHSContext ctx); + /** + * Visit a parse tree produced by {@link DotParser#edgeop}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitEdgeop(DotParser.EdgeopContext ctx); + /** + * Visit a parse tree produced by {@link DotParser#node_stmt}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitNode_stmt(DotParser.Node_stmtContext ctx); + /** + * Visit a parse tree produced by {@link DotParser#node_id}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitNode_id(DotParser.Node_idContext ctx); + /** + * Visit a parse tree produced by {@link DotParser#port}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitPort(DotParser.PortContext ctx); + /** + * Visit a parse tree produced by {@link DotParser#subgraph}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitSubgraph(DotParser.SubgraphContext ctx); + /** + * Visit a parse tree produced by {@link DotParser#id_}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitId_(DotParser.Id_Context ctx); +} \ No newline at end of file diff --git a/solver/src/main/kotlin/org/ucfs/Utils.kt b/solver/src/main/kotlin/org/ucfs/Utils.kt new file mode 100644 index 000000000..9eac9cb87 --- /dev/null +++ b/solver/src/main/kotlin/org/ucfs/Utils.kt @@ -0,0 +1,47 @@ +package org.ucfs + +import java.util.* + +fun incrementalDfs( + startElementL: ElementType, + next: (ElementType) -> Iterable +): HashSet { + val used = HashSet() + val queue = LinkedList() + queue.add(startElementL) + while (queue.isNotEmpty()) { + val element = queue.remove() + used.add(element) + for (nextElement in next(element)) { + if (!used.contains(nextElement)) { + queue.add(nextElement) + } + } + } + return used +} + +fun incrementalDfs( + startElementL: ElementType, + next: (ElementType) -> Iterable, + collection: CollectionType, + addToCollection: (ElementType, CollectionType) -> Unit +): CollectionType { + val used = HashSet() + val queue = LinkedList() + queue.add(startElementL) + while (queue.isNotEmpty()) { + val element = queue.remove() + used.add(element) + addToCollection(element, collection) + for (nextElement in next(element)) { + if (!used.contains(nextElement)) { + queue.add(nextElement) + } + } + } + return collection +} + + + diff --git a/solver/src/main/kotlin/org/ucfs/descriptors/Descriptor.kt b/solver/src/main/kotlin/org/ucfs/descriptors/Descriptor.kt new file mode 100644 index 000000000..235c2fa9e --- /dev/null +++ b/solver/src/main/kotlin/org/ucfs/descriptors/Descriptor.kt @@ -0,0 +1,42 @@ +package org.ucfs.descriptors + +import org.ucfs.gss.GssNode +import org.ucfs.rsm.RsmState +import org.ucfs.sppf.node.RangeSppfNode + +/** + * Descriptor represents current parsing stage + * @param InputNodeType - type of vertex in input graph + */ +data class Descriptor( + /** + * Pointer to vertex in input graph + */ + val inputPosition: InputNodeType, + /** + * Pointer to node in top layer of graph structured stack + */ + val gssNode: GssNode, + /** + * State in RSM, corresponds to slot in CF grammar + */ + val rsmState: RsmState, + /** + * Pointer to already parsed portion of input, represented as derivation tree, which shall be connected afterwards + * to derivation trees, stored on edges of GSS, it corresponds to return from recursive function + */ + val sppfNode: RangeSppfNode, + + +) { + // debug only property + val id = lastId++ + override fun toString(): String { + return "${id}\t;" + + "${inputPosition}\t;" + + "${rsmState.id}\t;" + + "(${gssNode.inputPosition}, ${gssNode.rsm.id})\t;" + } +} + +var lastId = 0 diff --git a/solver/src/main/kotlin/org/ucfs/descriptors/DescriptorsStorage.kt b/solver/src/main/kotlin/org/ucfs/descriptors/DescriptorsStorage.kt new file mode 100644 index 000000000..452373f48 --- /dev/null +++ b/solver/src/main/kotlin/org/ucfs/descriptors/DescriptorsStorage.kt @@ -0,0 +1,41 @@ +package org.ucfs.descriptors + +import java.util.LinkedList + +/** + * Collection of default descriptors + * @param VertexType - type of vertex in input graph + */ +open class DescriptorsStorage { + /** + * Collection of already handled descriptors, accessible via descriptor's hashcode + */ + private val handledDescriptors = HashSet>() + + private val descriptorsToHandle = LinkedList>() + + private fun isEmpty() = descriptorsToHandle.isEmpty() + + + fun addToHandled(descriptor: Descriptor) { + handledDescriptors.add(descriptor) + } + + fun add(descriptor: Descriptor) { + if (!handledDescriptors.contains(descriptor)) { + descriptorsToHandle.addLast(descriptor) + } + } + + /** + * Gets next descriptor to handle + * @return default descriptor if there is available one, null otherwise + */ + fun nextToHandle(): Descriptor? { + if (!isEmpty()) { + return descriptorsToHandle.removeLast() + } + return null + } +} + diff --git a/solver/src/main/kotlin/org/ucfs/grammar/combinator/Grammar.kt b/solver/src/main/kotlin/org/ucfs/grammar/combinator/Grammar.kt new file mode 100644 index 000000000..227491583 --- /dev/null +++ b/solver/src/main/kotlin/org/ucfs/grammar/combinator/Grammar.kt @@ -0,0 +1,45 @@ +package org.ucfs.grammar.combinator + +import org.ucfs.grammar.combinator.regexp.Nt +import org.ucfs.grammar.combinator.regexp.Regexp +import org.ucfs.incrementalDfs +import org.ucfs.rsm.RsmState +import org.ucfs.rsm.symbol.ITerminal +import org.ucfs.rsm.symbol.Nonterminal + + +open class Grammar { + val nonTerms = ArrayList() + + private lateinit var startNt: Nt + private lateinit var fictitiousStartNt: Nt + + private var _rsm: RsmState? = null + val rsm: RsmState + get() { + if (_rsm == null) { + _rsm = buildRsm() + } + return _rsm!! + } + + fun Nt.asStart(): Nt { + if (this@Grammar::startNt.isInitialized) { + throw Exception("Nonterminal ${nonterm.name} is already initialized") + } + startNt = this + return this + } + + + /** + * Builds a Rsm for the grammar + */ + private fun buildRsm(): RsmState { + nonTerms.forEach { it.buildRsmBox() } + //if nonterminal not initialized -- it will be checked in buildRsmBox() + fictitiousStartNt = Nt(startNt, "fictiveStart") + fictitiousStartNt.buildRsmBox() + return fictitiousStartNt.nonterm.startState + } +} diff --git a/solver/src/main/kotlin/org/ucfs/grammar/combinator/extension/StringExtension.kt b/solver/src/main/kotlin/org/ucfs/grammar/combinator/extension/StringExtension.kt new file mode 100644 index 000000000..738cfc41a --- /dev/null +++ b/solver/src/main/kotlin/org/ucfs/grammar/combinator/extension/StringExtension.kt @@ -0,0 +1,28 @@ +package org.ucfs.grammar.combinator.extension + +import org.ucfs.grammar.combinator.regexp.* +import org.ucfs.rsm.symbol.Term + +object StringExtension { + fun makeAlternative(literals: Iterable): Regexp { + val terms = literals.map { Term(it) } + val initial: Regexp = terms[0] or terms[1] + + return terms.subList(2, terms.size) + .fold(initial) { acc: Regexp, i: Term -> Alternative.makeAlternative(acc, i) } + } + infix operator fun Regexp.times(other: String): Concat = Concat(head = this, Term(other)) + infix operator fun String.times(other: String): Concat = Concat(head = Term(this), Term(other)) + infix operator fun String.times(other: Regexp): Concat = Concat(head = Term(this), other) + + infix fun String.or(other: String): Regexp = Alternative.makeAlternative(left = Term(this), Term(other)) + infix fun String.or(other: Regexp): Regexp = Alternative.makeAlternative(left = Term(this), other) + infix fun Regexp.or(other: String): Regexp = Alternative.makeAlternative(left = this, Term(other)) + + + fun many(some: String): Regexp { + return many(Term(some)) + } + fun Option(exp: String) = Alternative.makeAlternative(Epsilon, Term(exp)) + +} \ No newline at end of file diff --git a/solver/src/main/kotlin/org/ucfs/grammar/combinator/regexp/Alternative.kt b/solver/src/main/kotlin/org/ucfs/grammar/combinator/regexp/Alternative.kt new file mode 100644 index 000000000..4ad84b6e7 --- /dev/null +++ b/solver/src/main/kotlin/org/ucfs/grammar/combinator/regexp/Alternative.kt @@ -0,0 +1,33 @@ +package org.ucfs.grammar.combinator.regexp + +import org.ucfs.rsm.symbol.Term + + +data class Alternative( + val left: Regexp, + val right: Regexp, +) : Regexp { + companion object { + fun makeAlternative(left: Regexp, right: Regexp): Regexp { + if (left is Empty) return right + if (right is Empty) return left + + if (left is Alternative && (right == left.left || right == left.right)) { + return left + } + if (right is Alternative && (left == right.left || left == right.right)) { + return right + } + return if (left == right) left else Alternative(left, right) + } + } + + override fun derive(symbol: DerivedSymbol): Regexp { + return makeAlternative(left.derive(symbol), right.derive(symbol)) + } + +} + +infix fun Regexp.or(other: Regexp): Regexp = Alternative.makeAlternative(left = this, other) + +fun Option(exp: Regexp) = Alternative.makeAlternative(Epsilon, exp) \ No newline at end of file diff --git a/solver/src/main/kotlin/org/ucfs/grammar/combinator/regexp/Concatenation.kt b/solver/src/main/kotlin/org/ucfs/grammar/combinator/regexp/Concatenation.kt new file mode 100644 index 000000000..02b42976c --- /dev/null +++ b/solver/src/main/kotlin/org/ucfs/grammar/combinator/regexp/Concatenation.kt @@ -0,0 +1,29 @@ +package org.ucfs.grammar.combinator.regexp + +data class Concat( + val head: Regexp, + val tail: Regexp, +) : Regexp { + + /* + D[s](h.t) = acceptEps(h).D[s](t) | D[s](h).t + */ + override fun derive(symbol: DerivedSymbol): Regexp { + val newHead = head.derive(symbol) + + if (!head.acceptEpsilon()) { + return when (newHead) { + Empty -> Empty + Epsilon -> tail + else -> Concat(newHead, tail) + } + } + return when (newHead) { + Empty -> tail.derive(symbol) + Epsilon -> Alternative.makeAlternative(tail, tail.derive(symbol)) + else -> Alternative.makeAlternative(Concat(newHead, tail), tail.derive(symbol)) + } + } +} + +infix operator fun Regexp.times(other: Regexp): Concat = Concat(head = this, other) \ No newline at end of file diff --git a/solver/src/main/kotlin/org/ucfs/grammar/combinator/regexp/DerivedSymbol.kt b/solver/src/main/kotlin/org/ucfs/grammar/combinator/regexp/DerivedSymbol.kt new file mode 100644 index 000000000..cfcbe0926 --- /dev/null +++ b/solver/src/main/kotlin/org/ucfs/grammar/combinator/regexp/DerivedSymbol.kt @@ -0,0 +1,8 @@ +package org.ucfs.grammar.combinator.regexp + +interface DerivedSymbol : Regexp { + + override fun derive(symbol: DerivedSymbol): Regexp { + return if (this == symbol) Epsilon else Empty + } +} \ No newline at end of file diff --git a/solver/src/main/kotlin/org/ucfs/grammar/combinator/regexp/Many.kt b/solver/src/main/kotlin/org/ucfs/grammar/combinator/regexp/Many.kt new file mode 100644 index 000000000..949bce2ac --- /dev/null +++ b/solver/src/main/kotlin/org/ucfs/grammar/combinator/regexp/Many.kt @@ -0,0 +1,23 @@ +package org.ucfs.grammar.combinator.regexp + +data class Many( + val exp: Regexp, +) : Regexp { + override fun derive(symbol: DerivedSymbol): Regexp { + val newReg = exp.derive(symbol) + + return when (newReg) { + Epsilon -> Many(exp) + Empty -> Empty + else -> Concat(newReg, Many(exp)) + } + } +} + +fun many(some: Regexp): Many { + return Many(some) +} +val Regexp.many: Many + get() = Many(this) + +fun some(exp: Regexp) = exp * Many(exp) \ No newline at end of file diff --git a/solver/src/main/kotlin/org/ucfs/grammar/combinator/regexp/Nt.kt b/solver/src/main/kotlin/org/ucfs/grammar/combinator/regexp/Nt.kt new file mode 100644 index 000000000..6feb8aafe --- /dev/null +++ b/solver/src/main/kotlin/org/ucfs/grammar/combinator/regexp/Nt.kt @@ -0,0 +1,50 @@ +package org.ucfs.grammar.combinator.regexp + +import org.ucfs.grammar.combinator.Grammar +import org.ucfs.rsm.RsmState +import org.ucfs.rsm.symbol.Nonterminal +import kotlin.reflect.KProperty + +open class Nt() : DerivedSymbol { + private lateinit var name : String + constructor(lhs: Regexp) : this() { + rsmDescription = lhs + } + constructor(lhs: Regexp, name: String) : this() { + rsmDescription = lhs + this.nonterm = Nonterminal(name) + } + + + lateinit var nonterm: Nonterminal + private set + + private lateinit var rsmDescription: Regexp + + fun isInitialized(): Boolean { + return ::rsmDescription.isInitialized + } + + fun buildRsmBox() { + nonterm.startState = RsmState(nonterm, isStart = true, rsmDescription.acceptEpsilon()) + nonterm.startState.buildRsmBox(rsmDescription) + } + + operator fun getValue(grammar: Grammar, property: KProperty<*>): Nt = this + + operator fun divAssign(lhs: Regexp) { + if (isInitialized()) { + throw Exception("Nonterminal '${nonterm.name}' is already initialized") + } + rsmDescription = lhs + } + + operator fun provideDelegate( + grammar: Grammar, property: KProperty<*> + ): Nt { + name = property.name + nonterm = Nonterminal(property.name) + grammar.nonTerms.add(this) + return this + } +} diff --git a/solver/src/main/kotlin/org/ucfs/grammar/combinator/regexp/Regexp.kt b/solver/src/main/kotlin/org/ucfs/grammar/combinator/regexp/Regexp.kt new file mode 100644 index 000000000..c4559ab09 --- /dev/null +++ b/solver/src/main/kotlin/org/ucfs/grammar/combinator/regexp/Regexp.kt @@ -0,0 +1,46 @@ +package org.ucfs.grammar.combinator.regexp + + +sealed interface Regexp { + /* + Based on Brzozowski derivative + */ + fun derive(symbol: DerivedSymbol): Regexp + + /* + Does the expression accept an epsilon + */ + fun acceptEpsilon(): Boolean { + return when (this) { + is Empty -> false + is Epsilon -> true + is DerivedSymbol -> false + is Concat -> head.acceptEpsilon() && tail.acceptEpsilon() + is Alternative -> left.acceptEpsilon() || right.acceptEpsilon() + is Many -> true + } + } + + fun getAlphabet(): Set { + return when (this) { + is Empty -> emptySet() + is Epsilon -> emptySet() + is DerivedSymbol -> setOf(this) + is Concat -> head.getAlphabet() + tail.getAlphabet() + is Alternative -> left.getAlphabet() + right.getAlphabet() + is Many -> exp.getAlphabet() + } + } +} + +data object Epsilon : Regexp { + override fun derive(symbol: DerivedSymbol): Regexp = Empty +} + +/* + Regular expression that does not accept any input string. + */ +data object Empty : Regexp { + override fun derive(symbol: DerivedSymbol): Regexp = this +} + diff --git a/solver/src/main/kotlin/org/ucfs/gss/GraphStructuredStack.kt b/solver/src/main/kotlin/org/ucfs/gss/GraphStructuredStack.kt new file mode 100644 index 000000000..db0a9abcf --- /dev/null +++ b/solver/src/main/kotlin/org/ucfs/gss/GraphStructuredStack.kt @@ -0,0 +1,52 @@ +package org.ucfs.gss + +import org.ucfs.descriptors.Descriptor +import org.ucfs.rsm.RsmState +import org.ucfs.sppf.node.RangeSppfNode + +class GraphStructuredStack { + val nodes = HashMap, GssNode>() + + fun getOrCreateNode(input: InputNode, rsm: RsmState): GssNode { + val node = GssNode(rsm, input) + return nodes.getOrPut(node, {node}) + } + + fun addEdge( + gssNode: GssNode, + rsmStateToReturn: RsmState, + inputToContinue: InputNode, + rsmStateToContinue: RsmState, + matcherRange: RangeSppfNode + ): GssResult { + val addedNode = getOrCreateNode(inputToContinue, rsmStateToContinue) + val edge = GssEdge(gssNode, rsmStateToReturn, matcherRange) + + + // There is no need to check GSS edges duplication. + // "Faster, Practical GLL Parsing", Ali Afroozeh and Anastasia Izmaylova + // p.13: "There is at most one call to the create function with the same arguments. + // Thus no check for duplicate GSS edges is needed." + val popped = addedNode.addEdge(edge) + return GssResult(addedNode, popped) + } + + + /** + * return outgoing edges + */ + fun pop( + descriptor: Descriptor, range: RangeSppfNode + ): ArrayList> { + val gssNode = descriptor.gssNode + gssNode.popped.add(range) + return gssNode.outgoingEdges + } + +} + +data class GssResult( + val gssNode: GssNode, val popped: ArrayList> +) + + diff --git a/solver/src/main/kotlin/org/ucfs/gss/GssEdge.kt b/solver/src/main/kotlin/org/ucfs/gss/GssEdge.kt new file mode 100644 index 000000000..018baff78 --- /dev/null +++ b/solver/src/main/kotlin/org/ucfs/gss/GssEdge.kt @@ -0,0 +1,8 @@ +package org.ucfs.gss + +import org.ucfs.rsm.RsmState +import org.ucfs.sppf.node.RangeSppfNode + +data class GssEdge (val gssNode: GssNode, val state: RsmState, val matchedRange: RangeSppfNode){ + +} \ No newline at end of file diff --git a/solver/src/main/kotlin/org/ucfs/gss/GssNode.kt b/solver/src/main/kotlin/org/ucfs/gss/GssNode.kt new file mode 100644 index 000000000..c0817b4a7 --- /dev/null +++ b/solver/src/main/kotlin/org/ucfs/gss/GssNode.kt @@ -0,0 +1,38 @@ +package org.ucfs.gss + +import org.ucfs.rsm.RsmState +import org.ucfs.sppf.node.RangeSppfNode +import java.util.* +import kotlin.collections.ArrayList + +/** + * Node in Graph Structured Stack + * @param InputNodeType - type of vertex in input graph + */ +var lastId = 0 + +data class GssNode( + /** + * RSM corresponding to grammar slot + */ + val rsm: RsmState, + /** + * Pointer to vertex in input graph + */ + val inputPosition: InputNodeType, + +) { + val id: Int = lastId++ + val popped = ArrayList>() + + val outgoingEdges = ArrayList>() + + /** + * Add edge and return popped + */ + fun addEdge(edge: GssEdge): ArrayList> { + outgoingEdges.add(edge) + return popped + } + +} diff --git a/solver/src/main/kotlin/org/ucfs/input/DotParser.kt b/solver/src/main/kotlin/org/ucfs/input/DotParser.kt new file mode 100644 index 000000000..818f61000 --- /dev/null +++ b/solver/src/main/kotlin/org/ucfs/input/DotParser.kt @@ -0,0 +1,33 @@ +package org.ucfs.input + +import org.antlr.v4.runtime.CharStreams +import org.antlr.v4.runtime.CommonTokenStream +import org.ucfs.input.utils.dot.DotLexer +import org.ucfs.input.utils.dot.DotParser +import org.ucfs.input.utils.dot.GraphFromDotVisitor +import java.io.File +import java.io.IOException + +class DotParser { + + fun parseDotFile(filePath: String): InputGraph { + val file = File(filePath) + + if (!file.exists()) { + throw IOException("File not found: $filePath") + } + return parseDot(file.readText()) + } + + + fun parseDot(dotView: String): InputGraph { + val realParser = DotParser( + CommonTokenStream( + DotLexer( + CharStreams.fromString(dotView) + ) + ) + ) + return GraphFromDotVisitor().visitGraph(realParser.graph()) + } +} diff --git a/solver/src/main/kotlin/org/ucfs/input/Edge.kt b/solver/src/main/kotlin/org/ucfs/input/Edge.kt new file mode 100644 index 000000000..3124e70ad --- /dev/null +++ b/solver/src/main/kotlin/org/ucfs/input/Edge.kt @@ -0,0 +1,6 @@ +package org.ucfs.input + +data class Edge( + val label: LabelType, + val targetVertex: VertexType, +) \ No newline at end of file diff --git a/solver/src/main/kotlin/org/ucfs/input/IInputGraph.kt b/solver/src/main/kotlin/org/ucfs/input/IInputGraph.kt new file mode 100644 index 000000000..4fe5788d7 --- /dev/null +++ b/solver/src/main/kotlin/org/ucfs/input/IInputGraph.kt @@ -0,0 +1,63 @@ +package org.ucfs.input + +/** + * Input graph interface + * @param VertexType - type of vertex in input graph + * @param LabelType - type of label on edges in input graph + */ +interface IInputGraph { + /** + * @return collection of all starting vertices + */ + fun getInputStartVertices(): MutableSet + + /** + * Adds passed vertex both to collection of starting vertices and collection of all vertices + * @param vertex - vertex to add + */ + fun addStartVertex(vertex: VertexType) + + /** + * Adds passed vertex to collection of all vertices, but not collection of starting vertices + * @param vertex - vertex to add + */ + fun addVertex(vertex: VertexType) + + + /** + * Returns all outgoing edges from given vertex + * @param from - vertex to retrieve outgoing edges from + * @return Collection of outgoing edges + */ + fun getEdges(from: VertexType): MutableList> + + /** + * Adds edge to graph + * @param from - tail of the edge + * @param label - value to store on the edge + * @param to - head of the edge + */ + fun addEdge(from: VertexType, label: LabelType, to: VertexType) + + /** + * Removes edge from graph + * @param from - tail of the edge + * @param label - value, stored on the edge + * @param to - head of the edge + */ + fun removeEdge(from: VertexType, label: LabelType, to: VertexType) + + /** + * @param vertex - vertex to check + * @return true if given vertex is starting, false otherwise + */ + fun isStart(vertex: VertexType): Boolean + + /** + * @param vertex - vertex to check + * @return true if given vertex is final, false otherwise + */ + fun isFinal(vertex: VertexType): Boolean + + fun removeVertex(vertex: VertexType) +} \ No newline at end of file diff --git a/solver/src/main/kotlin/org/ucfs/input/ILabel.kt b/solver/src/main/kotlin/org/ucfs/input/ILabel.kt new file mode 100644 index 000000000..b403377c2 --- /dev/null +++ b/solver/src/main/kotlin/org/ucfs/input/ILabel.kt @@ -0,0 +1,8 @@ +package org.ucfs.input + +import org.ucfs.rsm.symbol.ITerminal + +interface ILabel { + val terminal: ITerminal? + override fun equals(other: Any?): Boolean +} \ No newline at end of file diff --git a/solver/src/main/kotlin/org/ucfs/input/InputGraph.kt b/solver/src/main/kotlin/org/ucfs/input/InputGraph.kt new file mode 100644 index 000000000..a8a4e009a --- /dev/null +++ b/solver/src/main/kotlin/org/ucfs/input/InputGraph.kt @@ -0,0 +1,51 @@ +package org.ucfs.input + +open class InputGraph : IInputGraph { + + var name = "G" + + val vertices: MutableSet = HashSet() + + val edges: MutableMap>> = HashMap() + + val startVertices: MutableSet = HashSet() + + override fun getInputStartVertices(): MutableSet { + return startVertices + } + + override fun addStartVertex(vertex: VertexType) { + startVertices.add(vertex) + vertices.add(vertex) + } + + override fun addVertex(vertex: VertexType) { + vertices.add(vertex) + } + + override fun removeVertex(vertex: VertexType) { + startVertices.remove(vertex) + vertices.remove(vertex) + } + + override fun getEdges(from: VertexType): MutableList> { + return edges.getOrDefault(from, ArrayList()) + } + + override fun addEdge(from: VertexType, label: LabelType, to: VertexType) { + val edge = Edge(label, to) + + if (!edges.containsKey(from)) edges[from] = ArrayList() + + edges.getValue(from).add(edge) + } + + + override fun removeEdge(from: VertexType, label: LabelType, to: VertexType) { + val edge = Edge(label, to) + edges.getValue(from).remove(edge) + } + + override fun isStart(vertex: VertexType) = startVertices.contains(vertex) + override fun isFinal(vertex: VertexType) = getEdges(vertex).isEmpty() +} \ No newline at end of file diff --git a/solver/src/main/kotlin/org/ucfs/input/LinearInput.kt b/solver/src/main/kotlin/org/ucfs/input/LinearInput.kt new file mode 100644 index 000000000..6ddf1465d --- /dev/null +++ b/solver/src/main/kotlin/org/ucfs/input/LinearInput.kt @@ -0,0 +1,43 @@ +package org.ucfs.input + +import org.ucfs.rsm.symbol.Term + +open class LinearInput : InputGraph() { + + override fun toString(): String { + if(startVertices.isEmpty()){ + return "${this.javaClass}: empty" + } + var v: VertexType = startVertices.first() + val sb = StringBuilder() + while(v != null){ + val e = edges[v]?.first() ?: break + sb.append("\n") + sb.append(e.label) + v = e.targetVertex + } + return sb.toString() + } + + companion object { + /** + * Split CharSequence into stream of strings, separated by space symbol + */ + fun buildFromString(input: String): IInputGraph { + val inputGraph = LinearInput() + var curVertexId = 0 + + inputGraph.addStartVertex(curVertexId) + inputGraph.addVertex(curVertexId) + + for (x in input.trim().split(SPACE).filter { it.isNotEmpty() }) { + if (x.isNotEmpty()) { + inputGraph.addEdge(curVertexId, TerminalInputLabel(Term(x)), ++curVertexId) + inputGraph.addVertex(curVertexId) + } + } + return inputGraph + } + const val SPACE = " " + } +} \ No newline at end of file diff --git a/solver/src/main/kotlin/org/ucfs/input/RecoveryEdge.kt b/solver/src/main/kotlin/org/ucfs/input/RecoveryEdge.kt new file mode 100644 index 000000000..8f0d03fa9 --- /dev/null +++ b/solver/src/main/kotlin/org/ucfs/input/RecoveryEdge.kt @@ -0,0 +1,9 @@ +package org.ucfs.input + +import org.ucfs.rsm.symbol.ITerminal + +data class RecoveryEdge( + val label: ITerminal?, + val head: VertexType, + val weight: Int, +) \ No newline at end of file diff --git a/solver/src/main/kotlin/org/ucfs/input/TerminalInputLabel.kt b/solver/src/main/kotlin/org/ucfs/input/TerminalInputLabel.kt new file mode 100644 index 000000000..37c2256e7 --- /dev/null +++ b/solver/src/main/kotlin/org/ucfs/input/TerminalInputLabel.kt @@ -0,0 +1,22 @@ +package org.ucfs.input + +import org.ucfs.rsm.symbol.ITerminal + +class TerminalInputLabel( + override val terminal: ITerminal, +) : ILabel { + override fun equals(other: Any?): Boolean { + if (this === other) return true + if (other !is TerminalInputLabel) return false + if (this.terminal != other.terminal) return false + + return true + } + + val hashCode: Int = terminal.hashCode() + override fun hashCode() = hashCode + + override fun toString(): String { + return terminal.toString() + } +} diff --git a/solver/src/main/kotlin/org/ucfs/input/utils/DotWriter.kt b/solver/src/main/kotlin/org/ucfs/input/utils/DotWriter.kt new file mode 100644 index 000000000..ec8783ca0 --- /dev/null +++ b/solver/src/main/kotlin/org/ucfs/input/utils/DotWriter.kt @@ -0,0 +1,32 @@ +package org.ucfs.input.utils + + +import org.ucfs.input.InputGraph +import org.ucfs.input.TerminalInputLabel +import java.lang.StringBuilder + +class DotWriter { + + fun getDotView(graph: InputGraph, isDirected: Boolean = true): String { + val builder = StringBuilder() + val graphType = if (isDirected) "digraph" else "graph" + val connector = if (isDirected) "->" else "--" + + builder.append("$graphType ${graph.name} {\n") + + for (vertex in graph.startVertices) { + builder.append(" start $connector $vertex;\n") + } + + for ((from, edges) in graph.edges) { + for (edge in edges) { + val to = edge.targetVertex + val label = edge.label.terminal.toString() + builder.append(" $from $connector $to [label = $label];\n") + } + } + + builder.append("}") + return builder.toString() + } +} diff --git a/solver/src/main/kotlin/org/ucfs/input/utils/dot/GraphFromDotVisitor.kt b/solver/src/main/kotlin/org/ucfs/input/utils/dot/GraphFromDotVisitor.kt new file mode 100644 index 000000000..bc668bab7 --- /dev/null +++ b/solver/src/main/kotlin/org/ucfs/input/utils/dot/GraphFromDotVisitor.kt @@ -0,0 +1,61 @@ +package org.ucfs.input.utils.dot + +import org.ucfs.input.InputGraph +import org.ucfs.input.TerminalInputLabel +import org.ucfs.rsm.symbol.Term + +class GraphFromDotVisitor : DotBaseVisitor>() { + lateinit var graph: InputGraph + + override fun visitGraph(ctx: DotParser.GraphContext?): InputGraph { + graph = InputGraph() + super.visitGraph(ctx) + ctx?.id_()?.let { graph.name = it.text } + return graph + } + + + private fun getNodeId(vertexView: String): Int { + return vertexView.toInt() + } + + private fun parseSimpleEdge(edgeView: String): TerminalInputLabel { + val viewWithoutQuotes = edgeView.substring(1, edgeView.length - 1) + return TerminalInputLabel(Term(viewWithoutQuotes)) + } + + override fun visitEdge_stmt(ctx: DotParser.Edge_stmtContext?): InputGraph { + val tos = ctx?.edgeRHS()?.node_id() + //we don't handle subgraph here + ?: return super.visitEdge_stmt(ctx) + if (tos.size > 1) { + throw Exception("we can't handle transitives in dot yet!") + } + val to = getNodeId(tos[0].text) + if (ctx.node_id()?.text == "start") { + graph.addVertex(to) + graph.addStartVertex(to) + } else { + val from = getNodeId(ctx.node_id().text) + val attrs = ctx.attr_list().attr() ?: throw Exception("we can't handle edges without labels yet!") + + val labelNode = attrs.find { it.label_name.text == "label" } + ?: throw Exception("we can't handle edges without labels yet!") + graph.addVertex(from) + graph.addVertex(to) + graph.addEdge(from, parseSimpleEdge(labelNode.label_value.text), to) + } + super.visitEdge_stmt(ctx) + return graph + } + + override fun visitNode_stmt(ctx: DotParser.Node_stmtContext?): InputGraph { + if (ctx?.node_id()?.text == "start") { + return super.visitNode_stmt(ctx) + + } + //add node info + super.visitNode_stmt(ctx) + return graph + } +} \ No newline at end of file diff --git a/solver/src/main/kotlin/org/ucfs/intersection/IIntersectionEngine.kt b/solver/src/main/kotlin/org/ucfs/intersection/IIntersectionEngine.kt new file mode 100644 index 000000000..7747d850f --- /dev/null +++ b/solver/src/main/kotlin/org/ucfs/intersection/IIntersectionEngine.kt @@ -0,0 +1,12 @@ +package org.ucfs.intersection + +import org.ucfs.descriptors.Descriptor +import org.ucfs.input.ILabel +import org.ucfs.parser.IGll + +interface IIntersectionEngine { + fun handleEdges( + gll: IGll, + descriptor: Descriptor, + ) +} \ No newline at end of file diff --git a/solver/src/main/kotlin/org/ucfs/intersection/IntersectionEngine.kt b/solver/src/main/kotlin/org/ucfs/intersection/IntersectionEngine.kt new file mode 100644 index 000000000..ce9338808 --- /dev/null +++ b/solver/src/main/kotlin/org/ucfs/intersection/IntersectionEngine.kt @@ -0,0 +1,42 @@ +package org.ucfs.intersection + +import org.ucfs.descriptors.Descriptor +import org.ucfs.input.ILabel +import org.ucfs.parser.IGll +import org.ucfs.rsm.symbol.ITerminal +import org.ucfs.rsm.symbol.Nonterminal + +object IntersectionEngine : IIntersectionEngine { + + + /** + * Process outgoing edges from input position in given descriptor, according to processing logic, represented as + * separate functions for both outgoing terminal and nonterminal edges from rsmState in descriptor + * @param gll - Gll parser instance + * @param descriptor - descriptor, represents current parsing stage + */ + override fun handleEdges( + gll: IGll, + descriptor: Descriptor, + ) { + + for (inputEdge in gll.ctx.input.getEdges(descriptor.inputPosition)) { + val inputTerminal = inputEdge.label.terminal + val rsmEdge = descriptor.rsmState.terminalEdgesStorage.find { + it.symbol == inputTerminal + } + if (rsmEdge != null) { + gll.handleTerminalEdge( + descriptor, inputEdge, rsmEdge.destinationState, rsmEdge.symbol as ITerminal + ) + } + } + + for (nonterminalEdge in descriptor.rsmState.nonterminalEdgesStorage) { + gll.handleNonterminalEdge( + descriptor, nonterminalEdge.destinationState, nonterminalEdge.symbol as Nonterminal + ) + } + } +} + diff --git a/solver/src/main/kotlin/org/ucfs/parser/Gll.kt b/solver/src/main/kotlin/org/ucfs/parser/Gll.kt new file mode 100644 index 000000000..5495d2b2a --- /dev/null +++ b/solver/src/main/kotlin/org/ucfs/parser/Gll.kt @@ -0,0 +1,112 @@ +package org.ucfs.parser + +import org.ucfs.descriptors.Descriptor +import org.ucfs.gss.GssEdge +import org.ucfs.input.IInputGraph +import org.ucfs.input.ILabel +import org.ucfs.intersection.IIntersectionEngine +import org.ucfs.intersection.IntersectionEngine +import org.ucfs.parser.context.Context +import org.ucfs.rsm.RsmState +import org.ucfs.sppf.node.* + +/** + * Gll Factory + * @param VertexType - type of vertex in input graph + * @param LabelType - type of label on edges in input graph + */ +class Gll private constructor( + override var ctx: Context, private val engine: IIntersectionEngine +) : IGll { + + companion object { + /** + * Creates instance of incremental Gll + * @param startState - starting state of accepting nonterminal in RSM + * @param inputGraph - input graph + * @return default instance of gll parser + */ + fun gll( + startState: RsmState, inputGraph: IInputGraph + ): Gll { + val finalState = startState.outgoingEdges[0].destinationState + return Gll(Context(startState, finalState, inputGraph), IntersectionEngine) + } + } + + private fun getEpsilonRange(descriptor: Descriptor): RangeSppfNode { + val input = InputRange( + descriptor.inputPosition, + descriptor.inputPosition, + ) + val rsm = RsmRange( + descriptor.rsmState, + descriptor.rsmState, + ) + return ctx.sppfStorage.addEpsilonNode(input, rsm, descriptor.gssNode.rsm) + } + + private fun handlePoppedGssEdge( + poppedGssEdge: GssEdge, descriptor: Descriptor, childSppf: RangeSppfNode + ) { + val leftRange = poppedGssEdge.matchedRange + val startRsmState = if (poppedGssEdge.matchedRange.type is EmptyType) poppedGssEdge.gssNode.rsm + else poppedGssEdge.matchedRange.rsmRange!!.to + val rightRange = ctx.sppfStorage.addNonterminalNode( + InputRange( + descriptor.gssNode.inputPosition, descriptor.inputPosition + ), RsmRange( + startRsmState, + poppedGssEdge.state, + ), descriptor.gssNode.rsm, childSppf + ) + val newRange = ctx.sppfStorage.addIntermediateNode(leftRange, rightRange) + val newDescriptor = Descriptor( + descriptor.inputPosition, poppedGssEdge.gssNode, poppedGssEdge.state, newRange + ) + ctx.descriptors.add(newDescriptor) + } + + private fun isParseResult(matchedRange: RangeSppfNode): Boolean { + return matchedRange.inputRange!!.from in ctx.input.getInputStartVertices() + && matchedRange.rsmRange!!.from == ctx.fictiveStartState + && matchedRange.rsmRange.to == ctx.fictiveFinalState + } + + /** + * Processes descriptor + * @param descriptor - descriptor to process + */ + override fun handleDescriptor(descriptor: Descriptor) { + ctx.descriptors.addToHandled(descriptor) + if (descriptor.rsmState.isFinal) { + handleTerminalRsmState(descriptor) + } + engine.handleEdges(this, descriptor) + } + + private fun handleTerminalRsmState(descriptor: Descriptor) { + val matchedRange = if (descriptor.sppfNode.type is EmptyType) { + val node = getEpsilonRange(descriptor) + //TODO fix + // dirty hack: in fact it's equivavelnt descriptors + // but only initial was added in handled set + ctx.descriptors.addToHandled( + Descriptor( + descriptor.inputPosition, + descriptor.gssNode, descriptor.rsmState, node + ) + ) + node + } else { + descriptor.sppfNode + } + for (poppedEdge in ctx.gss.pop(descriptor, matchedRange)) { + handlePoppedGssEdge(poppedEdge, descriptor, matchedRange) + } + if (isParseResult(matchedRange)) { + ctx.parseResults.add(matchedRange) + } + } +} + diff --git a/solver/src/main/kotlin/org/ucfs/parser/IGll.kt b/solver/src/main/kotlin/org/ucfs/parser/IGll.kt new file mode 100644 index 000000000..16d55cc84 --- /dev/null +++ b/solver/src/main/kotlin/org/ucfs/parser/IGll.kt @@ -0,0 +1,116 @@ +package org.ucfs.parser + +import org.ucfs.descriptors.Descriptor +import org.ucfs.input.Edge +import org.ucfs.input.IInputGraph +import org.ucfs.input.ILabel +import org.ucfs.parser.context.Context +import org.ucfs.rsm.RsmState +import org.ucfs.rsm.symbol.ITerminal +import org.ucfs.rsm.symbol.Nonterminal +import org.ucfs.sppf.node.* + +/** + * Interface for Gll parser + * @param InputNodeType - type of vertex in input graph + * @param LabelType - type of label on edges in input graph + */ +interface IGll { + /** + * Parser configuration + */ + var ctx: Context + + /** + * Main parsing loop. Iterates over available descriptors and processes them + * @return Pair of derivation tree root and collection of reachability pairs + */ + fun parse(): Set> { + ctx.parseResults = HashSet() + initDescriptors(ctx.input) + + var curDescriptor = ctx.descriptors.nextToHandle() + + while (curDescriptor != null) { + handleDescriptor(curDescriptor) + curDescriptor = ctx.descriptors.nextToHandle() + } + + return ctx.parseResults + } + + /** + * Processes descriptor + * @param descriptor - descriptor to process + */ + fun handleDescriptor(descriptor: Descriptor) + + /** + * Creates descriptors for all starting vertices in input graph + * @param input - input graph + */ + fun initDescriptors(input: IInputGraph) { + for (startVertex in input.getInputStartVertices()) { + + val gssNode = ctx.gss.getOrCreateNode(startVertex, ctx.fictiveStartState) + val startDescriptor = Descriptor( + startVertex, gssNode, ctx.fictiveStartState, getEmptyRange() + ) + ctx.descriptors.add(startDescriptor) + } + } + + fun handleNonterminalEdge( + descriptor: Descriptor, destinationRsmState: RsmState, edgeNonterminal: Nonterminal + ) { + val rsmStartState = edgeNonterminal.startState + val (newGssNode, positionToPops) = ctx.gss.addEdge( + descriptor.gssNode, destinationRsmState, descriptor.inputPosition, rsmStartState, descriptor.sppfNode + ) + + var newDescriptor = Descriptor( + descriptor.inputPosition, newGssNode, rsmStartState, getEmptyRange() + ) + ctx.descriptors.add(newDescriptor) + + for (rangeToPop in positionToPops) { + val leftSubRange = descriptor.sppfNode + val rightSubRange = ctx.sppfStorage.addNonterminalNode( + rangeToPop.inputRange!!, RsmRange( + descriptor.rsmState, destinationRsmState + ), rsmStartState + ) + + val newSppfNode = ctx.sppfStorage.addIntermediateNode(leftSubRange, rightSubRange) + + //TODO why these parameters??? + newDescriptor = Descriptor( + rangeToPop.inputRange.to, descriptor.gssNode, destinationRsmState, newSppfNode + ) + ctx.descriptors.add(newDescriptor) + } + } + + + fun handleTerminalEdge( + descriptor: Descriptor, + inputEdge: Edge, + destinationRsmState: RsmState, + terminal: ITerminal + ) { + val terminalSppfNode = ctx.sppfStorage.addNode( + InputRange( + descriptor.inputPosition, + inputEdge.targetVertex, + ), RsmRange( + descriptor.rsmState, + destinationRsmState, + ), terminal + ) + val intermediateOrTerminalSppf = ctx.sppfStorage.addIntermediateNode(descriptor.sppfNode, terminalSppfNode) + val descriptorForTerminal = Descriptor( + inputEdge.targetVertex, descriptor.gssNode, destinationRsmState, intermediateOrTerminalSppf + ) + ctx.descriptors.add(descriptorForTerminal) + } +} diff --git a/solver/src/main/kotlin/org/ucfs/parser/ParsingException.kt b/solver/src/main/kotlin/org/ucfs/parser/ParsingException.kt new file mode 100644 index 000000000..476e13aad --- /dev/null +++ b/solver/src/main/kotlin/org/ucfs/parser/ParsingException.kt @@ -0,0 +1,3 @@ +package org.ucfs.parser + +class ParsingException(msg: String = "Parsing exception") : Exception(msg) \ No newline at end of file diff --git a/solver/src/main/kotlin/org/ucfs/parser/context/Context.kt b/solver/src/main/kotlin/org/ucfs/parser/context/Context.kt new file mode 100644 index 000000000..97a4b209d --- /dev/null +++ b/solver/src/main/kotlin/org/ucfs/parser/context/Context.kt @@ -0,0 +1,42 @@ +package org.ucfs.parser.context + +import org.ucfs.descriptors.DescriptorsStorage +import org.ucfs.gss.GraphStructuredStack +import org.ucfs.input.IInputGraph +import org.ucfs.input.ILabel +import org.ucfs.rsm.RsmState +import org.ucfs.sppf.SppfStorage +import org.ucfs.sppf.node.RangeSppfNode + + +/** + * @param InputNodeType - type of vertex in input graph + * @param LabelType - type of label on edges in input graph + */ +class Context( + /** + * Starting state of accepting Nonterminal in RSM + */ + val fictiveStartState: RsmState, + val fictiveFinalState: RsmState, + val input: IInputGraph + + +) { + + /** + * Collection of descriptors + */ + val descriptors: DescriptorsStorage = DescriptorsStorage() + + /** + * Derivation trees storage + */ + val sppfStorage: SppfStorage = SppfStorage() + + val gss: GraphStructuredStack = GraphStructuredStack() + + + + var parseResults = HashSet>() +} \ No newline at end of file diff --git a/solver/src/main/kotlin/org/ucfs/rsm/RsmException.kt b/solver/src/main/kotlin/org/ucfs/rsm/RsmException.kt new file mode 100644 index 000000000..90f5daeb3 --- /dev/null +++ b/solver/src/main/kotlin/org/ucfs/rsm/RsmException.kt @@ -0,0 +1,3 @@ +package org.ucfs.rsm + +class RsmException(msg: String = "") : Exception("Rsm exception: $msg") \ No newline at end of file diff --git a/solver/src/main/kotlin/org/ucfs/rsm/RsmRead.kt b/solver/src/main/kotlin/org/ucfs/rsm/RsmRead.kt new file mode 100644 index 000000000..ce6e45ee7 --- /dev/null +++ b/solver/src/main/kotlin/org/ucfs/rsm/RsmRead.kt @@ -0,0 +1,217 @@ +package org.ucfs.rsm + +import org.ucfs.rsm.symbol.Nonterminal +import org.ucfs.rsm.symbol.Term +import java.nio.file.Path + +fun readRsmFromDot(filePath: String): RsmState = readRsmFromDot(Path.of(filePath)) + +fun readRsmFromTxt(filePath: String): RsmState = readRsmFromTxt(Path.of(filePath)) + +fun readRsmFromTxt(filePath: Path): RsmState { + val idToState: HashMap = HashMap() + var startRsmState: RsmState? = null + + fun makeRsmState( + id: Int, + nonterminal: Nonterminal, + isStart: Boolean = false, + isFinal: Boolean = false + ): RsmState { + val y = RsmState(nonterminal, isStart, isFinal) + + if (!idToState.containsKey(id)) idToState[id] = y + + return idToState[id]!! + } + + val nameToNonterminal: HashMap = HashMap() + + fun makeNonterminal(name: String): Nonterminal { + return nameToNonterminal.getOrPut(name) { Nonterminal(name) } + } + + 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 = filePath.toFile().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 = idToState[tailId.toInt()]!! + val headRsmState = idToState[headId.toInt()]!! + + tailRsmState.addEdge(Term(terminalValue),headRsmState) + } else if (rsmNonterminalEdgeRegex.matches(line)) { + val (tailId, headId, nonterminalValue) = + rsmNonterminalEdgeRegex.matchEntire(line)!!.destructured + + val tailRSMState = idToState[tailId.toInt()]!! + val headRSMState = idToState[headId.toInt()]!! + + tailRSMState.addEdge(makeNonterminal(nonterminalValue), headRSMState) + } + } + + return startRsmState!! +} + +//TODO: Resolve problems with regular expression for rsm state +// and decide how to determine start state for RSM +fun readRsmFromDot(pathToTXT: Path): RsmState { + val idToState: HashMap = HashMap() + val nonterminals: HashSet = HashSet() + var startRsmState: RsmState? = null + val nameToNonterminal: HashMap = HashMap() + + fun makeRsmState( + id: String, + nonterminal: Nonterminal, + isStart: Boolean, + isFinal: Boolean, + ): RsmState { + return idToState.getOrPut(id) { RsmState(nonterminal, isStart, isFinal) } + } + + fun makeNonterminal(name: String): Nonterminal { + return nameToNonterminal.getOrPut(name) { Nonterminal(name) } + } + + val startStateRegex = + """^(?.*) \[label = \"(?.*),.*\", shape = (?.*), color = green\]$""" + .trimMargin() + .replace("\n", "") + .toRegex() + + val rsmStateRegex = + """^(?.*) \[label = \"?(.*),.*\", shape = (?.*), color = black|red\]$""" + .trimMargin() + .replace("\n", "") + .toRegex() + + val rsmEdgeRegex = + """^(?.*) -> (?.*) \[label = \"(?.*)\"\]$""" + .trimMargin() + .replace("\n", "") + .toRegex() + + val reader = pathToTXT.toFile().inputStream().bufferedReader() + + while (true) { + val line = reader.readLine() ?: break + + if (startStateRegex.matches(line)) { + val (id, nonterminalName, shape) = + startStateRegex.matchEntire(line)!!.destructured + + val tmpNonterminal = makeNonterminal(nonterminalName) + + tmpNonterminal.startState = + makeRsmState( + id = id, + nonterminal = tmpNonterminal, + isStart = true, + isFinal = shape == "doublecircle", + ) + } else if (rsmStateRegex.matches(line)) { + val (id, nonterminalName, shape) = + rsmStateRegex.matchEntire(line)!!.destructured + + val tmpNonterminal = makeNonterminal(nonterminalName) + + makeRsmState( + id = id, + nonterminal = tmpNonterminal, + isStart = false, + isFinal = shape == "doublecircle", + ) + } else if (rsmEdgeRegex.matches(line)) { + val (tailId, headId, edgeLabel) = rsmEdgeRegex.matchEntire(line)!!.destructured + val tailRsmState = idToState[tailId]!! + val headRsmState = idToState[headId]!! + + if (nameToNonterminal.containsKey(edgeLabel)) { + tailRsmState.addEdge(makeNonterminal(edgeLabel), headRsmState) + } else { + tailRsmState.addEdge(Term(edgeLabel),headRsmState) + } + } + } + + return startRsmState!! +} diff --git a/solver/src/main/kotlin/org/ucfs/rsm/RsmState.kt b/solver/src/main/kotlin/org/ucfs/rsm/RsmState.kt new file mode 100644 index 000000000..dfd042d19 --- /dev/null +++ b/solver/src/main/kotlin/org/ucfs/rsm/RsmState.kt @@ -0,0 +1,90 @@ +package org.ucfs.rsm + +import org.ucfs.grammar.combinator.regexp.Empty +import org.ucfs.grammar.combinator.regexp.Nt +import org.ucfs.grammar.combinator.regexp.Regexp +import org.ucfs.rsm.symbol.ITerminal +import org.ucfs.rsm.symbol.Nonterminal +import org.ucfs.rsm.symbol.Symbol +import java.util.* +import kotlin.collections.ArrayList + +data class RsmEdge(val symbol: Symbol, val destinationState: RsmState) +//data class TerminalRsmEdge(val terminal: Term, val destinationState: RsmState) +//data class NonterminalRsmEdge(val nonterminal: Nonterminal, val destinationState: RsmState) + +data class RsmState( + val nonterminal: Nonterminal, + val isStart: Boolean = false, + val isFinal: Boolean = false, + var numId: Int = nonterminal.getNextRsmStateId() +) { + val id: String = "${nonterminal.name}_${(numId)}" + + val outgoingEdges + get() = terminalEdgesStorage.plus(nonterminalEdgesStorage) + + val terminalEdgesStorage = ArrayList() + + val nonterminalEdgesStorage = ArrayList() + + + /** + * Adds edge from current rsmState to given destinationState via given symbol, terminal or nonterminal + * @param symbol - symbol to store on edge + * @param destinationState + */ + fun addEdge(symbol: Symbol, destinationState: RsmState) { + when (symbol) { + is ITerminal -> terminalEdgesStorage.add(RsmEdge(symbol, destinationState)) + is Nonterminal -> nonterminalEdgesStorage.add(RsmEdge(symbol, destinationState)) + else -> throw RsmException("Unsupported type of symbol") + } + } + + protected fun getNewState(regex: Regexp): RsmState { + return RsmState(this.nonterminal, isStart = false, regex.acceptEpsilon()) + } + + /** + * Builds RSM from current state + * @param rsmDescription - right hand side of the rule in GrammarDsl in the form of regular expression + */ + fun buildRsmBox(rsmDescription: Regexp) { + val regexpToProcess = Stack() + val regexpToRsmState = HashMap() + regexpToRsmState[rsmDescription] = this + + val alphabet = rsmDescription.getAlphabet() + + regexpToProcess.add(rsmDescription) + + while (!regexpToProcess.empty()) { + val regexp = regexpToProcess.pop() + val state = regexpToRsmState[regexp] + + for (symbol in alphabet) { + val newState = regexp.derive(symbol) + if (newState !is Empty) { + if (!regexpToRsmState.containsKey(newState)) { + regexpToProcess.add(newState) + } + val destinationState = regexpToRsmState.getOrPut(newState) { getNewState(newState) } + + when (symbol) { + is ITerminal -> { + state?.addEdge(symbol, destinationState) + } + + is Nt -> { + if (!symbol.isInitialized()) { + throw IllegalArgumentException("Not initialized Nt used in description of \"${symbol.nonterm.name}\"") + } + state?.addEdge(symbol.nonterm, destinationState) + } + } + } + } + } + } +} \ No newline at end of file diff --git a/solver/src/main/kotlin/org/ucfs/rsm/RsmWrite.kt b/solver/src/main/kotlin/org/ucfs/rsm/RsmWrite.kt new file mode 100644 index 000000000..ec275bfbc --- /dev/null +++ b/solver/src/main/kotlin/org/ucfs/rsm/RsmWrite.kt @@ -0,0 +1,132 @@ +package org.ucfs.rsm + +import org.ucfs.rsm.symbol.Nonterminal +import org.ucfs.rsm.symbol.Symbol +import org.ucfs.rsm.symbol.Term +import java.io.File +import java.nio.file.Files +import java.nio.file.Path +import java.nio.file.Paths + +private fun getAllStates(startState: RsmState): HashSet { + val states: HashSet = HashSet() + val queue = ArrayDeque(listOf(startState)) + while (!queue.isEmpty()) { + val state = queue.removeFirst() + if (!states.contains(state)) { + states.add(state) + + for ((symbol, destState) in state.outgoingEdges) { + if (symbol is Nonterminal) { + queue.addLast(symbol.startState) + } + queue.addLast(destState) + queue.addLast(destState.nonterminal.startState) + } + } + } + return states +} + +fun getView(symbol: Symbol): String { + return when (symbol) { + is Nonterminal -> symbol.name ?: "unnamed nonterminal ${symbol.hashCode()}" + is Term<*> -> symbol.value.toString() + else -> symbol.toString() + } +} + +fun writeRsmToTxt(startState: RsmState, pathToTXT: String) { + val states = getAllStates(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", "") + ) + } + + fun getSymbolView(symbol: Symbol): Triple { + return when (symbol) { + is Term<*> -> Triple("Terminal", symbol.value.toString(), "terminal") + is Nonterminal -> Triple("Nonterminal", symbol.name ?: "NON_TERM", "nonterminal") + else -> throw Exception("Unsupported implementation of Symbol instance: ${symbol.javaClass}") + } + } + + for (state in states) { + for ((symbol, destState) in state.outgoingEdges) { + val (typeView, symbolView, typeLabel) = getSymbolView(symbol) + out.println( + """${typeView}Edge( + |tail=${state.id}, + |head=${destState.id}, + |$typeLabel=$typeView("$symbolView") + |)""".trimMargin().replace("\n", "") + ) + } + } + } +} + +fun writeRsmToDot(startState: RsmState, filePath: String) { + val states = getAllStates((startState.outgoingEdges.get(0).symbol as Nonterminal).startState) + val boxes: HashMap> = HashMap() + + for (state in states) { + if (!boxes.containsKey(state.nonterminal)) { + boxes[state.nonterminal] = HashSet() + } + boxes.getValue(state.nonterminal).add(state) + } + + Files.createDirectories(Paths.get("gen")) + val file = File(Path.of("gen", filePath).toUri()) + + file.printWriter().use { out -> + out.println("digraph g {") + + states.forEach { state -> + val shape = if (state.isFinal) "doublecircle" else "circle" + val color = + if (state == startState) "purple" else if (state.isStart) "green" else if (state.isFinal) "red" else "black" + val id = state.id + val name = state.nonterminal.name + out.println("$id [label = \"$name,$id\", shape = $shape, color = $color]") + } + + states.forEach { state -> + state.outgoingEdges.forEach { (symbol, destState) -> + out.println("${state.id} -> ${destState.id} [label = \"${getView(symbol)}\"]") + } + } + + boxes.forEach { box -> + out.println("subgraph cluster_${box.key.name} {") + + box.value.forEach { state -> + out.println(state.id) + } + out.println("label = \"${box.key.name}\"") + out.println("}") + } + out.println("}") + } +} diff --git a/solver/src/main/kotlin/org/ucfs/rsm/symbol/ITerminal.kt b/solver/src/main/kotlin/org/ucfs/rsm/symbol/ITerminal.kt new file mode 100644 index 000000000..cf6201f9a --- /dev/null +++ b/solver/src/main/kotlin/org/ucfs/rsm/symbol/ITerminal.kt @@ -0,0 +1,12 @@ +package org.ucfs.rsm.symbol + +import org.ucfs.grammar.combinator.regexp.DerivedSymbol + +interface ITerminal : Symbol, DerivedSymbol{ + /** + * In generated parser `getTerminals` should return terminal in deterministic order + * Can't use Comparable interface here because we can't implement if for Enums + */ + fun getComparator(): Comparator + +} diff --git a/solver/src/main/kotlin/org/ucfs/rsm/symbol/Nonterminal.kt b/solver/src/main/kotlin/org/ucfs/rsm/symbol/Nonterminal.kt new file mode 100644 index 000000000..cdf4af191 --- /dev/null +++ b/solver/src/main/kotlin/org/ucfs/rsm/symbol/Nonterminal.kt @@ -0,0 +1,35 @@ +package org.ucfs.rsm.symbol + +import org.ucfs.rsm.RsmState +import java.util.* + +data class Nonterminal(val name: String?) : Symbol { + lateinit var startState: RsmState + private var rsmStateLastId = 0 + override fun toString() = "Nonterminal(${name ?: this.hashCode()})" + + fun getNextRsmStateId(): Int { + val id = rsmStateLastId + rsmStateLastId++ + return id + } + + /** + * Get all states from RSM for current nonterminal + */ + fun getStates(): Iterable { + val used = HashSet() + val queue = LinkedList() + queue.add(startState) + while (queue.isNotEmpty()) { + val state = queue.remove() + used.add(state) + for ((_, destinationState) in state.outgoingEdges) { + if (!used.contains(destinationState)) { + queue.add(destinationState) + } + } + } + return used + } +} diff --git a/solver/src/main/kotlin/org/ucfs/rsm/symbol/Symbol.kt b/solver/src/main/kotlin/org/ucfs/rsm/symbol/Symbol.kt new file mode 100644 index 000000000..c168eb441 --- /dev/null +++ b/solver/src/main/kotlin/org/ucfs/rsm/symbol/Symbol.kt @@ -0,0 +1,3 @@ +package org.ucfs.rsm.symbol + +interface Symbol \ No newline at end of file diff --git a/solver/src/main/kotlin/org/ucfs/rsm/symbol/Term.kt b/solver/src/main/kotlin/org/ucfs/rsm/symbol/Term.kt new file mode 100644 index 000000000..a72eb6ad0 --- /dev/null +++ b/solver/src/main/kotlin/org/ucfs/rsm/symbol/Term.kt @@ -0,0 +1,22 @@ +package org.ucfs.rsm.symbol + +import org.ucfs.grammar.combinator.regexp.DerivedSymbol +import org.ucfs.parser.ParsingException + +data class Term(val value: TerminalType) : ITerminal, DerivedSymbol { + override fun toString() = value.toString() + override fun getComparator(): Comparator { + //TODO improve comparable interfaces + //TODO replace this logic in 'generator' subproject + return object : Comparator { + override fun compare(a: ITerminal, b: ITerminal): Int { + if (a !is Term<*> || b !is Term<*>) { + throw ParsingException( + "used comparator for $javaClass, " + "but got elements of ${a.javaClass}$ and ${b.javaClass}\$" + ) + } + return a.value.toString().compareTo(b.value.toString()) + } + } + } +} \ No newline at end of file diff --git a/solver/src/main/kotlin/org/ucfs/sppf/SppfStorage.kt b/solver/src/main/kotlin/org/ucfs/sppf/SppfStorage.kt new file mode 100644 index 000000000..253b654ce --- /dev/null +++ b/solver/src/main/kotlin/org/ucfs/sppf/SppfStorage.kt @@ -0,0 +1,90 @@ +package org.ucfs.sppf + +import org.ucfs.rsm.RsmState +import org.ucfs.rsm.symbol.ITerminal +import org.ucfs.sppf.node.* + +/** + * @param InputEdgeType - type of vertex in input graph + */ +open class SppfStorage { + + /** + * Collection of created sppfNodes with access and search in O(1) time + */ + private val createdSppfNodes: HashMap, RangeSppfNode> = HashMap() + + private fun addNode(node: RangeSppfNode): RangeSppfNode { + return createdSppfNodes.getOrPut(node, { node }) + } + + /** + * Add nonterminal node after pop + */ + fun addNonterminalNode( + input: InputRange, + rsm: RsmRange, + startState: RsmState, + childSppf: RangeSppfNode? = null + ): RangeSppfNode { + return if (childSppf == null) addNode(input, rsm, NonterminalType(startState)) + else addNode(input, rsm, NonterminalType(startState), listOf(childSppf)) + } + + fun addEpsilonNode( + input: InputRange, + rsmRange: RsmRange, + rsmState: RsmState + ): RangeSppfNode { + return addNode( + input, rsmRange, EpsilonNonterminalType(rsmState) + ) + } + + /** + * Add temrminal node + */ + fun addNode( + input: InputRange, rsm: RsmRange, terminal: ITerminal + ): RangeSppfNode { + return addNode(input, rsm, TerminalType(terminal)) + } + + fun addIntermediateNode( + leftSubtree: RangeSppfNode, + rightSubtree: RangeSppfNode + ): RangeSppfNode { + if (leftSubtree.type is EmptyType) { + return rightSubtree + } + return addNode( + InputRange( + leftSubtree.inputRange!!.from, rightSubtree.inputRange!!.to + ), RsmRange( + leftSubtree.rsmRange!!.from, rightSubtree.rsmRange!!.to + ), IntermediateType( + leftSubtree.rsmRange.to, leftSubtree.inputRange.to + ), listOf(leftSubtree, rightSubtree) + ) + } + + private fun addNode( + input: InputRange, + rsm: RsmRange, + rangeType: RangeType, + children: List> = listOf() + ): RangeSppfNode { + val rangeNode = addNode(RangeSppfNode(input, rsm, Range)) + val valueRsm = if (rangeType is TerminalType<*>) null else rsm + val valueNode = addNode(RangeSppfNode(input, valueRsm, rangeType)) + if (!rangeNode.children.contains(valueNode)) { + rangeNode.children.add(valueNode) + } + for (child in children) { + if (!valueNode.children.contains(child)) { + valueNode.children.add(child) + } + } + return rangeNode + } +} \ No newline at end of file diff --git a/solver/src/main/kotlin/org/ucfs/sppf/buildStringFromSppf.kt b/solver/src/main/kotlin/org/ucfs/sppf/buildStringFromSppf.kt new file mode 100644 index 000000000..243923193 --- /dev/null +++ b/solver/src/main/kotlin/org/ucfs/sppf/buildStringFromSppf.kt @@ -0,0 +1,53 @@ +package org.ucfs.sppf + +import org.ucfs.sppf.node.* + +/** + * Collects leaves of the derivation tree in order from left to right. + * @return Ordered collection of terminals + */ +fun buildTokenStreamFromSppf(sppfNode: RangeSppfNode): MutableList { + val visited: HashSet> = HashSet() + val stack: ArrayDeque> = ArrayDeque(listOf(sppfNode)) + val result: MutableList = ArrayList() + var curNode: RangeSppfNode + + while (stack.isNotEmpty()) { + curNode = stack.removeLast() + visited.add(curNode) + + val type = curNode.type + when (type) { + is TerminalType<*> -> { + result.add(type.terminal.toString()) + } + + is IntermediateType<*> -> { + for(child in curNode.children) { + stack.add(child) + } + } + + is NonterminalType -> { + if (curNode.children.isNotEmpty()) { + curNode.children.findLast { + !visited.contains( + it + ) + }?.let { stack.add(it) } + curNode.children.forEach { visited.add(it) } + } + } + } + + } + return result +} + +/** + * Collects leaves of the derivation tree in order from left to right and joins them into one string + * @return String value of recognized subrange + */ +fun buildStringFromSppf(sppfNode: RangeSppfNode): String { + return buildTokenStreamFromSppf(sppfNode).joinToString(separator = "") +} \ No newline at end of file diff --git a/solver/src/main/kotlin/org/ucfs/sppf/node/RangeSppfNode.kt b/solver/src/main/kotlin/org/ucfs/sppf/node/RangeSppfNode.kt new file mode 100644 index 000000000..1ea12899c --- /dev/null +++ b/solver/src/main/kotlin/org/ucfs/sppf/node/RangeSppfNode.kt @@ -0,0 +1,70 @@ +package org.ucfs.sppf.node + +import org.ucfs.input.ILabel +import org.ucfs.parser.context.Context +import org.ucfs.rsm.RsmState +import org.ucfs.rsm.symbol.ITerminal + +/** + * + * A Range node which corresponds to a matched range. It + * represents all possible ways to get a specific range and can + * have arbitrary many children. A child node can be of any + * type, besides a Range node. Nodes of this type can be reused. + *

+ * Contains two range: in RSM and in Input graph + *

+ * May be used as extended packed sppfNode. + * @param VertexType - type of vertex in input graph + */ + +data class RangeSppfNode( + val inputRange: InputRange?, + val rsmRange: RsmRange?, + val type: RangeType, +) { + val children = ArrayList>() +} + +fun getEmptyRange( isStart: Boolean = false): RangeSppfNode { + val type = EmptyType() + if(isStart) { + type.isStart = isStart + } + return RangeSppfNode(null, null, type) +} + +data class InputRange( + val from: VertexType, + val to: VertexType, +) { + override fun toString(): String = "input:[$from;$to]" +} + +data class RsmRange( + val from: RsmState, + val to: RsmState, +) { + override fun toString(): String = "rsm:[${from.id};${to.id}]" +} + +interface RangeType + +object Range : RangeType +data class TerminalType(val terminal: T) : RangeType +data class NonterminalType(val startState: RsmState) : RangeType +data class EpsilonNonterminalType(val startState: RsmState) : RangeType +data class IntermediateType(val grammarSlot: RsmState, val inputPosition: VertexType) : RangeType +class EmptyType : RangeType { + var isStart = false + + @Override + override fun equals(other: Any?): Boolean { + return other is EmptyType + } + + @Override + override fun hashCode(): Int { + return 12 + } +} diff --git a/solver/src/main/kotlin/org/ucfs/sppf/writeSppfToDot.kt b/solver/src/main/kotlin/org/ucfs/sppf/writeSppfToDot.kt new file mode 100644 index 000000000..d9391295e --- /dev/null +++ b/solver/src/main/kotlin/org/ucfs/sppf/writeSppfToDot.kt @@ -0,0 +1,142 @@ +package org.ucfs.sppf + +import org.ucfs.sppf.node.* +import java.nio.file.Files +import java.nio.file.Path + +val printWithId = false +fun writeSppfToDot(sppfNode: RangeSppfNode, filePath: String, label: String = "") { + val genPath = Path.of("gen", "sppf") + Files.createDirectories(genPath) + val file = genPath.resolve(filePath).toFile() + + file.printWriter().use { out -> + out.println(getSppfDot(sppfNode, label)) + } +} + +fun getSppfDot(sppfNodes: Set>, label: String = ""): String { + val sb = StringBuilder() + sb.appendLine("digraph g {") + sb.appendLine("labelloc=\"t\"") + sb.appendLine("label=\"$label\"") + var idx = 0 + val results = sppfNodes.sortedWith(compareBy { it.toString() }).map { sppf -> getSppfDot(sppf.children[0], idx++.toString()) } + for (sppf in results.sorted()) { + sb.appendLine(sppf) + } + sb.appendLine("}") + return sb.toString() +} + +fun getSppfDot(sppfNode: RangeSppfNode, label: String): String { + val prefix = "_${label}_" + val queue: ArrayDeque> = ArrayDeque(listOf(sppfNode)) + val visited: HashSet = HashSet() + var node: RangeSppfNode + val sb = StringBuilder() + sb.appendLine("subgraph cluster_$label{") + sb.appendLine("labelloc=\"t\"") + val nodeViews = HashMap, String>() + var id = 0 + while (queue.isNotEmpty()) { + node = queue.removeFirst() + if (!visited.add(node.hashCode())) continue + + nodeViews[node] = getNodeView(node, id.toString()) + id++ + node.children.forEach { + queue.addLast(it) + } + } + val sortedViews = nodeViews.values.sorted() + val nodeIds = HashMap, Int>() + val nodeById = HashMap>() + for ((nodeInstance, view) in nodeViews) { + val id = sortedViews.indexOf(view) + nodeIds[nodeInstance] = id + nodeById[id] = nodeInstance + } + + for (i in sortedViews.indices) { + sb.appendLine("$prefix$i ${sortedViews[i]}") + } + + for (i in nodeById.keys) { + val sortedNode = nodeById[i] + for (child in sortedNode!!.children) { + sb.appendLine("$prefix${nodeIds[sortedNode]}->$prefix${nodeIds[child]}") + } + // TODO change format to force DOT to save children order + } + + sb.appendLine("}") + return sb.toString() +} + + +enum class NodeShape(val view: String) { + Terminal("rectangle"), Nonterminal("invtrapezium"), Intermediate("plain"), Empty("ellipse"), Range("ellipse"), Epsilon( + "invhouse" + ) +} + +fun fillNodeTemplate( + id: String? = null, nodeInfo: String, inputRange: InputRange<*>?, shape: NodeShape, rsmRange: RsmRange? = null +): String { + val inputRangeView = if (inputRange != null) "input: [${inputRange.from}, ${inputRange.to}]" else null + val rsmRangeView = if (rsmRange != null) "rsm: [${rsmRange.from.id}, ${rsmRange.to.id}]" else null + val view = listOfNotNull(nodeInfo, inputRangeView, rsmRangeView).joinToString(", ") + return "[label = \"${id?: ""} ${shape.name} $view\", shape = ${shape.view}]" +} + +fun getNodeView(node: RangeSppfNode, id: String? = null): String { + val type = node.type + return when (type) { + is TerminalType<*> -> { + fillNodeTemplate( + id, "'${type.terminal}'", node.inputRange, NodeShape.Terminal + ) + } + + is NonterminalType -> { + fillNodeTemplate( + id, "${type.startState.nonterminal.name}", node.inputRange, NodeShape.Nonterminal + ) + } + + is IntermediateType<*> -> { + fillNodeTemplate( + id, "input: ${type.inputPosition}, rsm: ${type.grammarSlot.id}", node.inputRange, NodeShape.Intermediate + ) + } + + is EmptyType -> { + fillNodeTemplate( + id, "", null, NodeShape.Empty + ) + } + + is EpsilonNonterminalType -> { + fillNodeTemplate( + id, "RSM: ${type.startState.id}", node.inputRange, NodeShape.Epsilon + ) + } + + is RangeType -> { + fillNodeTemplate( + id, "", node.inputRange, NodeShape.Range, node.rsmRange + ) + } + + else -> throw IllegalStateException("Can't write node type $type to DOT") + + } + + +} + +private fun getView(range: RsmRange?): String { + if (range == null) return "" + return "rsm: [(${range.from.nonterminal.name}:${range.from.numId}), " + "(${range.to.nonterminal.name}:${range.to.numId})]" +} diff --git a/solver/src/test/kotlin/TestDotParser.kt b/solver/src/test/kotlin/TestDotParser.kt new file mode 100644 index 000000000..d8b74ffe0 --- /dev/null +++ b/solver/src/test/kotlin/TestDotParser.kt @@ -0,0 +1,25 @@ +import org.junit.jupiter.api.Test +import org.ucfs.input.DotParser +import org.ucfs.input.InputGraph +import org.ucfs.input.TerminalInputLabel +import org.ucfs.input.utils.DotWriter +import java.io.File +import java.nio.file.Path +import kotlin.test.assertEquals + +class TestDotParser { + @Test + fun testParser(){ + val testCasesFolder = File(Path.of("src", "test", "resources", "dotParserTest").toUri()) + if (!testCasesFolder.exists()) { + println("Can't find test case for dotParserTest") + } + for (file in testCasesFolder.listFiles()) { + val originalDot = file.readText() + val graph: InputGraph = DotParser().parseDot(originalDot) + assertEquals(originalDot, DotWriter().getDotView(graph)) + } + } + + +} \ No newline at end of file diff --git a/solver/src/test/kotlin/rsm/RsmTest.kt b/solver/src/test/kotlin/rsm/RsmTest.kt new file mode 100644 index 000000000..c70c11257 --- /dev/null +++ b/solver/src/test/kotlin/rsm/RsmTest.kt @@ -0,0 +1,84 @@ +package rsm + +import org.junit.jupiter.api.Test +import org.ucfs.rsm.RsmEdge +import org.ucfs.rsm.RsmState +import org.ucfs.rsm.symbol.ITerminal +import org.ucfs.rsm.symbol.Nonterminal +import org.ucfs.rsm.symbol.Term +import kotlin.test.assertFalse +import kotlin.test.assertTrue + +interface RsmTest { + /** + * Compare two RSM, two state are equal if they have same name + * + */ + fun equalsByNtName(expected: RsmState, actual: RsmState): Boolean { +// if (actual.nonterminal.name == null) { +// throw IllegalArgumentException("For comparing by name non terminal must have unique not null name") +// } +// if (expected.nonterminal.name != actual.nonterminal.name +// || expected.isStart != actual.isStart || expected.isFinal != actual.isFinal +// ) { +// return false +// } +// if (actual.outgoingEdges.size != expected.outgoingEdges.size) { +// return false +// } +// for ((expectedSymbol, originDestStates) in expected.outgoingEdges) { +// val actualDestStates: RsmEdge = when (expectedSymbol) { +// is ITerminal -> { +// actual.outgoingEdges[Term(expectedSymbol)] +// } +// is Nonterminal -> { +// actual.outgoingEdges.entries.firstOrNull { (actualSymbol, _) -> +// actualSymbol is Nonterminal && actualSymbol.name == expectedSymbol.name +// }?.value +// } +// +// else -> throw Exception("Unsupported instance of Symbol: ${expectedSymbol.javaClass}") +// } ?: return false +// if (!equalsAsSetByName(originDestStates, actualDestStates)) { +// return false +// } +// } +// return true + TODO() + } + + private fun equalsAsSetByName(expected: HashSet, actual: HashSet): Boolean { + if (expected.size != actual.size) { + return false + } + for (expectedState in expected) { + val actualState = + actual.firstOrNull { actualState -> actualState.nonterminal.name == expectedState.nonterminal.name } + if (actualState == null || !equalsByNtName(expectedState, actualState)) { + return false + } + } + return true + } + + fun getAStarRsm(stateName: String): RsmState { + val s = Nonterminal(stateName) + val a = Term("a") + val st0 = RsmState(s, isStart = true) + s.startState = st0 + val st1 = RsmState(s, isFinal = true) + val st2 = RsmState(s) + val st3 = RsmState(s, isFinal = true) + st0.addEdge(a, st1) + st1.addEdge(s, st3) + st0.addEdge(s, st2) + st2.addEdge(s, st3) + return s.startState + } + + @Test + fun testEquals() { + assertTrue { equalsByNtName(getAStarRsm("S"), getAStarRsm("S")) } + assertFalse { equalsByNtName(getAStarRsm("S"), getAStarRsm("K")) } + } +} \ No newline at end of file diff --git a/solver/src/test/kotlin/rsm/api/TerminalsEqualsTest.kt b/solver/src/test/kotlin/rsm/api/TerminalsEqualsTest.kt new file mode 100644 index 000000000..6b85d6c91 --- /dev/null +++ b/solver/src/test/kotlin/rsm/api/TerminalsEqualsTest.kt @@ -0,0 +1,36 @@ +package rsm.api + +import org.junit.jupiter.api.Disabled +import org.junit.jupiter.api.Test +import org.ucfs.grammar.combinator.Grammar +import org.ucfs.grammar.combinator.regexp.Nt +import org.ucfs.grammar.combinator.regexp.or +import org.ucfs.grammar.combinator.regexp.times +import org.ucfs.rsm.symbol.Term +import rsm.RsmTest +import kotlin.test.assertTrue + +@Disabled +class TerminalsEqualsTest : RsmTest { + class AStarTerms : Grammar() { + val S by Nt().asStart() + + init { + S /= Term("a") or Term("a") * S or S * S + } + } + + class AStar : Grammar() { + val S by Nt().asStart() + val A = Term("a") + + init { + S /= A or A * S or S * S + } + } + + @Test + fun testRsm() { + assertTrue { equalsByNtName(AStar().rsm, AStarTerms().rsm) } + } +} \ No newline at end of file diff --git a/solver/src/test/kotlin/rsm/builder/AStarTest.kt b/solver/src/test/kotlin/rsm/builder/AStarTest.kt new file mode 100644 index 000000000..fb57ee4c2 --- /dev/null +++ b/solver/src/test/kotlin/rsm/builder/AStarTest.kt @@ -0,0 +1,30 @@ +package rsm.builder + +import org.junit.jupiter.api.Disabled +import org.junit.jupiter.api.Test +import org.ucfs.grammar.combinator.Grammar +import org.ucfs.grammar.combinator.regexp.Nt +import org.ucfs.grammar.combinator.regexp.or +import org.ucfs.grammar.combinator.regexp.times +import org.ucfs.rsm.symbol.Term +import rsm.RsmTest +import kotlin.test.assertNotNull +import kotlin.test.assertTrue + +@Disabled +class AStarTest : RsmTest { + class AStar : Grammar() { + val S by Nt().asStart() + + init { + S /= Term("a") or Term("a") * S or S * S + } + } + + @Test + fun testRsm() { + val grammar = AStar() + assertNotNull(grammar.S.nonterm) + assertTrue { equalsByNtName(getAStarRsm("S"), grammar.rsm) } + } +} \ No newline at end of file diff --git a/solver/src/test/resources/dotParserTest/simpleLoop.dot b/solver/src/test/resources/dotParserTest/simpleLoop.dot new file mode 100644 index 000000000..c24d6260a --- /dev/null +++ b/solver/src/test/resources/dotParserTest/simpleLoop.dot @@ -0,0 +1,5 @@ +digraph Input { + start -> 0; + 0 -> 0 [label = "("]; + 0 -> 0 [label = ")"]; +} \ No newline at end of file diff --git a/test-shared/build.gradle.kts b/test-shared/build.gradle.kts new file mode 100644 index 000000000..eb18330e2 --- /dev/null +++ b/test-shared/build.gradle.kts @@ -0,0 +1,39 @@ +plugins { + kotlin("jvm") version "1.9.20" +} + +group = "org.pl" +version = "unspecified" + +repositories { + mavenCentral() +} + +dependencies { + implementation(project(":solver")) + implementation(project(":generator")) + implementation("org.junit.jupiter:junit-jupiter:5.8.1") + implementation("org.jetbrains.kotlin:kotlin-test") + + testImplementation("com.github.tschuchortdev:kotlin-compile-testing:1.5.0") +} + +tasks.test { + useJUnitPlatform() + val heapSize = (System.getProperty("testMaxHeapSize") ?: "100m") // ограничение памяти для JVM тестов + val special_case = System.getProperty("special_case") ?: "nothing" + val count_for_case = System.getProperty("count_for_case") ?: "50" + val write_case_time = System.getProperty("write_case_time") ?: "1" + maxHeapSize = heapSize + + jvmArgs( + // "-XX:+PrintGCDetails", + // "-Xlog:gc*:file=gc.log:time,uptime,level,tags", + "-Dspecial_case=$special_case", + "-Dcount_for_case=$count_for_case", + "-Dwrite_case_time=$write_case_time" + ) +} +kotlin { + jvmToolchain(11) +} \ No newline at end of file diff --git a/test-shared/src/main/kotlin/org/ucfs/IDynamicGllTest.kt b/test-shared/src/main/kotlin/org/ucfs/IDynamicGllTest.kt new file mode 100644 index 000000000..be2bbcd91 --- /dev/null +++ b/test-shared/src/main/kotlin/org/ucfs/IDynamicGllTest.kt @@ -0,0 +1,68 @@ +package org.ucfs + +import org.junit.jupiter.api.DynamicContainer +import org.junit.jupiter.api.DynamicNode +import org.junit.jupiter.api.TestFactory +import java.io.File + + +interface IDynamicGllTest { + val mainFileName: String + + companion object { + const val GRAMMARS_FOLDER = "grammars" + const val ONE_LINE_INPUTS = "oneLineInputs.txt" + const val ONE_LINE_ERRORS_INPUTS = "oneLineErrorInputs.txt" + const val GRAMMAR_FOLDER = "src/test/resources/grammars" + const val INPUTS = "correctInputs" + const val INCORRECT_INPUTS = "incorrectInputs" + fun getTestName(input: String): String { + return when (input.length) { + 0 -> "empty" + in 1..10 -> input + else -> "${input.take(10)}..." + } + } + + fun getFile(name: String, grammarFile: File): File? { + return grammarFile.listFiles()?.firstOrNull { it.name == name } + } + + fun getLines(fileName: String, folder: File): List { + val file = getFile(fileName, folder) ?: return listOf() + return file.readLines() + } + + fun getFiles(fileName: String, folder: File): Array? { + val file = getFile(fileName, folder) ?: return arrayOf() + return file.listFiles() + } + + fun readFile(file: File): String { + return file.inputStream().reader().readText() + } + } + + @TestFactory + fun testAll(): Collection { + val folders = + File(GRAMMAR_FOLDER).listFiles() ?: throw Exception("Resource folder $GRAMMAR_FOLDER not found") + return folders + .filter { + it.isDirectory && it.listFiles()?.any { file -> file.name == mainFileName } == true + } + .map { concreteGrammarFolder -> handleFolder(concreteGrammarFolder) } + } + + + fun handleFolder(concreteGrammarFolder: File): DynamicContainer { + val grammarName = concreteGrammarFolder.name + return DynamicContainer.dynamicContainer( + grammarName, getTestCases(concreteGrammarFolder) + ) + + } + + fun getTestCases(concreteGrammarFolder: File): Iterable + +} diff --git a/test-shared/src/test/kotlin/grammars_example/GrammarsExample.kt b/test-shared/src/test/kotlin/grammars_example/GrammarsExample.kt new file mode 100644 index 000000000..e4cb4d141 --- /dev/null +++ b/test-shared/src/test/kotlin/grammars_example/GrammarsExample.kt @@ -0,0 +1,79 @@ +package grammars_example + +import org.ucfs.grammar.combinator.Grammar +import org.ucfs.grammar.combinator.extension.StringExtension.or +import org.ucfs.grammar.combinator.extension.StringExtension.times +import org.ucfs.grammar.combinator.regexp.* +import org.ucfs.grammar.combinator.regexp.Epsilon +import org.ucfs.rsm.symbol.Term + +class SimplifiedDyck : Grammar() { + val S by Nt().asStart() + + init { + S /= Option("(" * S * ")") + // S = ( S ) ? + } +} + +class StrangeDyck : Grammar() { + val S by Nt().asStart() + + init { + S /= "(" * S * ")" or "a" + // S = eps | ( S ) + } +} + +class LoopDyck : Grammar() { + val S by Nt().asStart() + + init { + S /= Many("(" * S * ")") + // S = [ ( S ) ]* + } +} + +class ABGrammar : Grammar() { + val A by Nt(Term("a")) // A -> a + val C by Nt(Term("a")) + val B by Nt(C) // C -> B + val S by Nt(A or B).asStart() +} + +class SALang : Grammar() { + val A by Nt("a" * "b") + val S by Nt((A or ("a" * "b")) * "c").asStart() +} + +class Epsilon : Grammar() { + val S by Nt(Epsilon).asStart() +} + +/** + * Can parse only one symbol 'a' + */ +class AmbiguousAStar1 : Grammar() { + val S by Nt().asStart() + + init { + S /= "a" or S + } +} + +class AmbiguousAStar2 : Grammar() { + val S by Nt().asStart() + + init { + S /= "a" or S * S + } +} + + +class AmbiguousAStar3 : Grammar() { + val S by Nt().asStart() + + init { + S /= "a" or S * S + } +} \ No newline at end of file diff --git a/test-shared/src/test/kotlin/parser/generated/GllGeneratedTest.kt b/test-shared/src/test/kotlin/parser/generated/GllGeneratedTest.kt new file mode 100644 index 000000000..e69de29bb diff --git a/test-shared/src/test/kotlin/parser/generated/IOfflineGllTest.kt b/test-shared/src/test/kotlin/parser/generated/IOfflineGllTest.kt new file mode 100644 index 000000000..e69de29bb diff --git a/test-shared/src/test/kotlin/parser/generated/RuntimeCompiler.kt b/test-shared/src/test/kotlin/parser/generated/RuntimeCompiler.kt new file mode 100644 index 000000000..e69de29bb diff --git a/test-shared/src/test/kotlin/parser/generated/ScanerlessGllGeneratedTest.kt b/test-shared/src/test/kotlin/parser/generated/ScanerlessGllGeneratedTest.kt new file mode 100644 index 000000000..e69de29bb diff --git a/test-shared/src/test/kotlin/solver/benchmarks/AbstractBenchmarkTest.kt b/test-shared/src/test/kotlin/solver/benchmarks/AbstractBenchmarkTest.kt new file mode 100644 index 000000000..f2eb00f29 --- /dev/null +++ b/test-shared/src/test/kotlin/solver/benchmarks/AbstractBenchmarkTest.kt @@ -0,0 +1,171 @@ +package solver.benchmarks + +import org.jetbrains.kotlin.incremental.createDirectory +import org.junit.jupiter.api.Test +import org.ucfs.grammar.combinator.Grammar +import org.ucfs.input.DotParser +import org.ucfs.parser.Gll +import org.ucfs.rsm.writeRsmToDot +import org.ucfs.sppf.getSppfDot +import java.io.File +import java.nio.file.Path +import java.time.LocalDateTime +import java.time.format.DateTimeFormatter +import kotlin.io.path.Path +import kotlin.io.path.readText +import kotlin.test.assertFalse +import java.util.concurrent.atomic.AtomicBoolean + +object MemoryMonitor { + private val running = AtomicBoolean(false) + private var peakMemory: Long = 0 + private var monitorThread: Thread? = null + + fun start(intervalMs: Long = 1) { + if (running.get()) return + running.set(true) + + monitorThread = Thread { + val runtime = Runtime.getRuntime() + while (running.get()) { + val used = runtime.totalMemory() - runtime.freeMemory() + synchronized(this) { + if (used > peakMemory) peakMemory = used + } + } + }.apply { + isDaemon = true + start() + } + } + + fun stop(): Long { + running.set(false) + monitorThread?.join() + return synchronized(this) { peakMemory / (1024 * 1024) } // MB + } +} + + + +abstract class AbstractBenchmarkTest { + val rootPath: Path = Path.of("src", "test", "resources") + + fun getDataFolder(): Path { + return rootPath.resolve("benchmarks") + } + + fun getResultsFolder(): Path { + return rootPath.resolve("benchmarksResult") + } + val regenerate = false + + @Test + abstract fun checkTreeCorrectnessForGrammar() + + + fun runTests(grammar :Grammar) { + val grammarName = grammar.javaClass.simpleName + writeRsmToDot(grammar.rsm, "${grammarName}Rsm") + val path: Path = getDataFolder() + val result_folder: File = File(getResultsFolder().resolve(grammarName).toUri()) + val testCasesFolder = File(path.resolve(grammarName).toUri()) + println(result_folder.toString()) + println(testCasesFolder.toString()) + + if (!testCasesFolder.exists()) { + println("Can't find test case for $grammarName") + } + testCasesFolder.createDirectory() + result_folder.createDirectory() + val special_case = System.getProperty("special_case") + + + for (folder in testCasesFolder.listFiles()) { + if((!special_case.isNullOrEmpty() && special_case != "nothing") && folder.name != special_case) { + + + continue; + } + if (folder.isDirectory) { + println(special_case) + println(folder.name) + println(File(Path(result_folder.path).resolve(folder.name).toUri() )) + val bechmark_result_folder = File(Path(result_folder.path).resolve(folder.name).toUri() ) + bechmark_result_folder.createDirectory() + testCreatedTreeForCorrectness(folder, grammar, bechmark_result_folder) + } + } + assertFalse { regenerate } + } + + fun testCreatedTreeForCorrectness(testCasesFolder: File, grammar: Grammar, result_folder: File) { + val inputFile = testCasesFolder.toPath().resolve("input.dot") + val input = inputFile.readText() + val time = LocalDateTime.now() + val formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss") + val formattedDateTime = time.format(formatter) + var logsFile: File? = null + var resultsLog: File? = null + if(System.getProperty("write_case_time") == "1") { + logsFile = File(result_folder.toPath().toString(), formattedDateTime + "work_times" + ".logs") + resultsLog = File(result_folder.toPath().toString(), formattedDateTime + "results" + ".logs") + } + var x = 0 + var logs = "" + val timeMeasurements = mutableListOf() + + println("Starting performance test...") + println("Work time: $testCasesFolder") + val used = (Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory()) / (1024 * 1024) + println("Used memory: " + used + " MB") + val max_test_count = System.getProperty("count_for_case").toInt() + MemoryMonitor.start() + while (x < max_test_count) { + val start = System.nanoTime() + val actualResult = createTree(input, grammar) + val workTime = System.nanoTime() - start + timeMeasurements.add(workTime) + logs += "\n$x;$workTime" + + x++ + } + val peak = MemoryMonitor.stop() + val averageTime = timeMeasurements.average() + val minTime = timeMeasurements.minOrNull() ?: 0 + val maxTime = timeMeasurements.maxOrNull() ?: 0 + val totalTime = timeMeasurements.sum() + + println("\n=== PERFORMANCE RESULTS ===") + println("Total iterations: ${timeMeasurements.size}") + println("Average time: ${"%.3f".format(averageTime / 1_000_000)} ms") + println("Min time: ${minTime / 1_000_000} ms") + println("Max time: ${maxTime / 1_000_000} ms") + println("Total time: ${totalTime / 1_000_000_000.0} seconds") + println("===========================") + + println("Peak memory usage: $peak MB") + if(System.getProperty("write_case_time") == "1") { + logsFile?.writeText(logs) + } + logs = "\n=== PERFORMANCE RESULTS === \n Total iterations: ${timeMeasurements.size} \n Average time: ${"%.3f".format(averageTime / 1_000_000)} ms" + + "\n Min time: ${minTime / 1_000_000} ms" + + "\nMax time: ${maxTime / 1_000_000} ms" + + "\nTotal time: ${totalTime / 1_000_000_000.0} seconds"+ + "\nPeak memory usage: $peak MB" + + if(System.getProperty("write_case_time") == "1") { + resultsLog?.writeText(logs) + } + + } + + + fun createTree(input: String, grammar: Grammar): String { + val inputGraph = DotParser().parseDot(input) + val gll = Gll.gll(grammar.rsm, inputGraph) + val sppf = gll.parse() + return getSppfDot(sppf) + } + +} \ No newline at end of file diff --git a/test-shared/src/test/kotlin/solver/benchmarks/BipartitleGrammarTest/BipartitleGrammar.kt b/test-shared/src/test/kotlin/solver/benchmarks/BipartitleGrammarTest/BipartitleGrammar.kt new file mode 100644 index 000000000..90a5bb195 --- /dev/null +++ b/test-shared/src/test/kotlin/solver/benchmarks/BipartitleGrammarTest/BipartitleGrammar.kt @@ -0,0 +1,15 @@ +package solver.benchmarks.BipartitleGrammarTest + + +import org.ucfs.grammar.combinator.Grammar +import org.ucfs.grammar.combinator.regexp.* +import org.ucfs.rsm.symbol.Term + +class BipartitleGrammar : Grammar() { + val A by Nt() + val B by Nt((Term("b") * A) or (Term("b"))) + val S by Nt(A).asStart() + init { + A /= (Term("a") * B) or (Term("a")) + } +} diff --git a/test-shared/src/test/kotlin/solver/benchmarks/BipartitleGrammarTest/BipartitleGrammarTreeBenchmarkTest.kt b/test-shared/src/test/kotlin/solver/benchmarks/BipartitleGrammarTest/BipartitleGrammarTreeBenchmarkTest.kt new file mode 100644 index 000000000..7dfa67bff --- /dev/null +++ b/test-shared/src/test/kotlin/solver/benchmarks/BipartitleGrammarTest/BipartitleGrammarTreeBenchmarkTest.kt @@ -0,0 +1,11 @@ +package solver.benchmarks.BipartitleGrammarTest + +import org.junit.jupiter.api.Test +import solver.benchmarks.AbstractBenchmarkTest + +class BipartitleGrammarTreeBenchmarkTest : AbstractBenchmarkTest() { + @Test + override fun checkTreeCorrectnessForGrammar() { + runTests(BipartitleGrammar()) + } +} \ No newline at end of file diff --git a/test-shared/src/test/kotlin/solver/benchmarks/CAliasTest/CAliasBenchmarkTest.kt b/test-shared/src/test/kotlin/solver/benchmarks/CAliasTest/CAliasBenchmarkTest.kt new file mode 100644 index 000000000..11eca7b89 --- /dev/null +++ b/test-shared/src/test/kotlin/solver/benchmarks/CAliasTest/CAliasBenchmarkTest.kt @@ -0,0 +1,11 @@ +package solver.benchmarks.CAliasTest + +import org.junit.jupiter.api.Test +import solver.benchmarks.AbstractBenchmarkTest + +class CAliasBenchmarkTest : AbstractBenchmarkTest() { + @Test + override fun checkTreeCorrectnessForGrammar() { + runTests(CAliasGrammar()) + } +} \ No newline at end of file diff --git a/test-shared/src/test/kotlin/solver/benchmarks/CAliasTest/CAliasGrammar.kt b/test-shared/src/test/kotlin/solver/benchmarks/CAliasTest/CAliasGrammar.kt new file mode 100644 index 000000000..3e54a4ad2 --- /dev/null +++ b/test-shared/src/test/kotlin/solver/benchmarks/CAliasTest/CAliasGrammar.kt @@ -0,0 +1,19 @@ +package solver.benchmarks.CAliasTest + + +import org.ucfs.grammar.combinator.Grammar +import org.ucfs.grammar.combinator.regexp.* +import org.ucfs.rsm.symbol.Term + +class CAliasGrammar : Grammar() { + val V_1 by Nt() + val V_2 by Nt() + val V_3 by Nt() + val V by Nt(V_1*V_2*V_3) + val S by Nt(Term("d_r") * V * Term("d")).asStart() + init { + V_2 /= S or Epsilon + V_3 /= (Term("a") * V_2 * V_3) or Epsilon + V_1 /= ( V_2 * Term("a_r") * V_1) or Epsilon + } +} diff --git a/test-shared/src/test/kotlin/solver/benchmarks/LoopDyckGrammarTest/LoopDyckGrammar.kt b/test-shared/src/test/kotlin/solver/benchmarks/LoopDyckGrammarTest/LoopDyckGrammar.kt new file mode 100644 index 000000000..ffd2b360e --- /dev/null +++ b/test-shared/src/test/kotlin/solver/benchmarks/LoopDyckGrammarTest/LoopDyckGrammar.kt @@ -0,0 +1,15 @@ +package solver.benchmarks.LoopDyckGrammarTest + + +import org.ucfs.grammar.combinator.Grammar +import org.ucfs.grammar.combinator.extension.StringExtension.times +import org.ucfs.grammar.combinator.regexp.* + +class LoopDyckGrammar : Grammar() { + val S by Nt().asStart() + + init { + S /= Many("(" * S * ")") + // S = [ ( S ) ]* + } +} diff --git a/test-shared/src/test/kotlin/solver/benchmarks/LoopDyckGrammarTest/LoopDyckGrammarTreeBenchmarkTest.kt b/test-shared/src/test/kotlin/solver/benchmarks/LoopDyckGrammarTest/LoopDyckGrammarTreeBenchmarkTest.kt new file mode 100644 index 000000000..e1b10a3d9 --- /dev/null +++ b/test-shared/src/test/kotlin/solver/benchmarks/LoopDyckGrammarTest/LoopDyckGrammarTreeBenchmarkTest.kt @@ -0,0 +1,11 @@ +package solver.benchmarks.LoopDyckGrammarTest + +import org.junit.jupiter.api.Test +import solver.benchmarks.AbstractBenchmarkTest + +class LoopDyckGrammarTreeBenchmarkTest : AbstractBenchmarkTest() { + @Test + override fun checkTreeCorrectnessForGrammar() { + runTests(LoopDyckGrammar()) + } +} \ No newline at end of file diff --git a/test-shared/src/test/kotlin/solver/benchmarks/StrangeDyckGrammarTest/StrangeDyckGrammar.kt b/test-shared/src/test/kotlin/solver/benchmarks/StrangeDyckGrammarTest/StrangeDyckGrammar.kt new file mode 100644 index 000000000..4d64fcb50 --- /dev/null +++ b/test-shared/src/test/kotlin/solver/benchmarks/StrangeDyckGrammarTest/StrangeDyckGrammar.kt @@ -0,0 +1,16 @@ +package solver.benchmarks.StrangeDyckGrammarTest + + +import org.ucfs.grammar.combinator.Grammar +import org.ucfs.grammar.combinator.extension.StringExtension.or +import org.ucfs.grammar.combinator.extension.StringExtension.times +import org.ucfs.grammar.combinator.regexp.* + +class StrangeDyckGrammar : Grammar() { + val S by Nt().asStart() + + init { + S /= "(" * S * ")" or "a" + // S = eps | ( S ) + } +} diff --git a/test-shared/src/test/kotlin/solver/benchmarks/StrangeDyckGrammarTest/StrangeDyckGrammarTreeBenchmarkTest.kt b/test-shared/src/test/kotlin/solver/benchmarks/StrangeDyckGrammarTest/StrangeDyckGrammarTreeBenchmarkTest.kt new file mode 100644 index 000000000..d0817fa92 --- /dev/null +++ b/test-shared/src/test/kotlin/solver/benchmarks/StrangeDyckGrammarTest/StrangeDyckGrammarTreeBenchmarkTest.kt @@ -0,0 +1,11 @@ +package solver.benchmarks.StrangeDyckGrammarTest + +import org.junit.jupiter.api.Test +import solver.benchmarks.AbstractBenchmarkTest + +class StrangeDyckGrammarTreeBenchmarkTest : AbstractBenchmarkTest() { + @Test + override fun checkTreeCorrectnessForGrammar() { + runTests(StrangeDyckGrammar()) + } +} \ No newline at end of file diff --git a/test-shared/src/test/kotlin/solver/correctnessTests/ABGrammarTest/ABGrammar.kt b/test-shared/src/test/kotlin/solver/correctnessTests/ABGrammarTest/ABGrammar.kt new file mode 100644 index 000000000..fb8a66320 --- /dev/null +++ b/test-shared/src/test/kotlin/solver/correctnessTests/ABGrammarTest/ABGrammar.kt @@ -0,0 +1,13 @@ +package solver.correctnessTests.ABGrammarTest + + +import org.ucfs.grammar.combinator.Grammar +import org.ucfs.grammar.combinator.regexp.* +import org.ucfs.rsm.symbol.Term + +class ABGrammar : Grammar() { + val A by Nt(Term("a")) // A -> a + val C by Nt(Term("a")) + val B by Nt(C) // C -> B + val S by Nt(A or B).asStart() +} diff --git a/test-shared/src/test/kotlin/solver/correctnessTests/ABGrammarTest/ABGrammarTreeCorrectnessTest.kt b/test-shared/src/test/kotlin/solver/correctnessTests/ABGrammarTest/ABGrammarTreeCorrectnessTest.kt new file mode 100644 index 000000000..795b85332 --- /dev/null +++ b/test-shared/src/test/kotlin/solver/correctnessTests/ABGrammarTest/ABGrammarTreeCorrectnessTest.kt @@ -0,0 +1,11 @@ +package solver.correctnessTests.ABGrammarTest + +import org.junit.jupiter.api.Test +import solver.correctnessTests.AbstractCorrectnessTest + +class ABGrammarTreeCorrectnessTest : AbstractCorrectnessTest() { + @Test + override fun checkTreeCorrectnessForGrammar() { + runTests(ABGrammar()) + } +} \ No newline at end of file diff --git a/test-shared/src/test/kotlin/solver/correctnessTests/AbstractCorrectnessTest.kt b/test-shared/src/test/kotlin/solver/correctnessTests/AbstractCorrectnessTest.kt new file mode 100644 index 000000000..3847956f6 --- /dev/null +++ b/test-shared/src/test/kotlin/solver/correctnessTests/AbstractCorrectnessTest.kt @@ -0,0 +1,78 @@ +package solver.correctnessTests + +import org.jetbrains.kotlin.incremental.createDirectory +import org.junit.jupiter.api.Test +import org.ucfs.grammar.combinator.Grammar +import org.ucfs.input.DotParser +import org.ucfs.parser.Gll +import org.ucfs.rsm.writeRsmToDot +import org.ucfs.sppf.getSppfDot +import java.io.File +import java.nio.file.Path +import kotlin.io.path.readText +import kotlin.io.path.writeText +import kotlin.test.assertEquals +import kotlin.test.assertFalse +import kotlin.test.assertNotNull + +abstract class AbstractCorrectnessTest { + val rootPath: Path = Path.of("src", "test", "resources", "correctness") + + fun getRootDataFolder(): Path { + return rootPath.resolve("tree") + } + + val regenerate = false + + @Test + abstract fun checkTreeCorrectnessForGrammar() + + + fun runTests(grammar :Grammar) { + val grammarName = grammar.javaClass.simpleName + writeRsmToDot(grammar.rsm, "${grammarName}Rsm") + val path: Path = getRootDataFolder() + val testCasesFolder = File(path.resolve(grammarName).toUri()) + + if (!testCasesFolder.exists()) { + println("Can't find test case for $grammarName") + } + testCasesFolder.createDirectory() + for (folder in testCasesFolder.listFiles()) { + if (folder.isDirectory) { + testCreatedTreeForCorrectness(folder, grammar) + } + } + assertFalse { regenerate } + } + + fun testCreatedTreeForCorrectness(testCasesFolder: File, grammar: Grammar) { + val inputFile = testCasesFolder.toPath().resolve("input.dot") + val expectedFile = testCasesFolder.toPath().resolve("result.dot") + val input = inputFile.readText() + val expectedResult = expectedFile.readText() + val start = System.nanoTime() + val actualResult = createTree(input, grammar) + val workTime = System.nanoTime() - start + println("Work time: $workTime") + if (expectedResult.isEmpty() || regenerate) { + expectedFile.writeText(actualResult) + } else { + assertEquals( + expectedResult, + actualResult, + "for grammar ${grammar.javaClass.simpleName} at ${testCasesFolder.name}" + ) + } + } + + + fun createTree(input: String, grammar: Grammar): String { + val inputGraph = DotParser().parseDot(input) + val gll = Gll.gll(grammar.rsm, inputGraph) + val sppf = gll.parse() + assertNotNull(sppf) { "Can't parse input!" } + return getSppfDot(sppf) + } + +} \ No newline at end of file diff --git a/test-shared/src/test/kotlin/solver/correctnessTests/AmbiguousAStar1GrammarTest/AmbiguousAStar1Grammar.kt b/test-shared/src/test/kotlin/solver/correctnessTests/AmbiguousAStar1GrammarTest/AmbiguousAStar1Grammar.kt new file mode 100644 index 000000000..88c9ad6cc --- /dev/null +++ b/test-shared/src/test/kotlin/solver/correctnessTests/AmbiguousAStar1GrammarTest/AmbiguousAStar1Grammar.kt @@ -0,0 +1,14 @@ +package solver.correctnessTests.AmbiguousAStar1GrammarTest + + +import org.ucfs.grammar.combinator.Grammar +import org.ucfs.grammar.combinator.extension.StringExtension.or +import org.ucfs.grammar.combinator.regexp.* + +class AmbiguousAStar1Grammar : Grammar() { + val S by Nt().asStart() + + init { + S /= "a" or S + } +} \ No newline at end of file diff --git a/test-shared/src/test/kotlin/solver/correctnessTests/AmbiguousAStar1GrammarTest/AmbiguousAStar1GrammarTreeCorrectnessTest.kt b/test-shared/src/test/kotlin/solver/correctnessTests/AmbiguousAStar1GrammarTest/AmbiguousAStar1GrammarTreeCorrectnessTest.kt new file mode 100644 index 000000000..cf744272d --- /dev/null +++ b/test-shared/src/test/kotlin/solver/correctnessTests/AmbiguousAStar1GrammarTest/AmbiguousAStar1GrammarTreeCorrectnessTest.kt @@ -0,0 +1,11 @@ +package solver.correctnessTests.AmbiguousAStar1GrammarTest + +import org.junit.jupiter.api.Test +import solver.correctnessTests.AbstractCorrectnessTest + +class AmbiguousAStar1GrammarTreeCorrectnessTest : AbstractCorrectnessTest() { + @Test + override fun checkTreeCorrectnessForGrammar() { + runTests(AmbiguousAStar1Grammar()) + } +} \ No newline at end of file diff --git a/test-shared/src/test/kotlin/solver/correctnessTests/AmbiguousAStar2GrammarTest/AmbiguousAStar2Grammar.kt b/test-shared/src/test/kotlin/solver/correctnessTests/AmbiguousAStar2GrammarTest/AmbiguousAStar2Grammar.kt new file mode 100644 index 000000000..729e79f17 --- /dev/null +++ b/test-shared/src/test/kotlin/solver/correctnessTests/AmbiguousAStar2GrammarTest/AmbiguousAStar2Grammar.kt @@ -0,0 +1,14 @@ +package solver.correctnessTests.AmbiguousAStar2GrammarTest + + +import org.ucfs.grammar.combinator.Grammar +import org.ucfs.grammar.combinator.extension.StringExtension.or +import org.ucfs.grammar.combinator.regexp.* + +class AmbiguousAStar2Grammar : Grammar() { + val S by Nt().asStart() + + init { + S /= "a" or S * S + } +} \ No newline at end of file diff --git a/test-shared/src/test/kotlin/solver/correctnessTests/AmbiguousAStar2GrammarTest/AmbiguousAStar2GrammarTreeCorrectnessTest.kt b/test-shared/src/test/kotlin/solver/correctnessTests/AmbiguousAStar2GrammarTest/AmbiguousAStar2GrammarTreeCorrectnessTest.kt new file mode 100644 index 000000000..119726721 --- /dev/null +++ b/test-shared/src/test/kotlin/solver/correctnessTests/AmbiguousAStar2GrammarTest/AmbiguousAStar2GrammarTreeCorrectnessTest.kt @@ -0,0 +1,11 @@ +package solver.correctnessTests.AmbiguousAStar2GrammarTest + +import org.junit.jupiter.api.Test +import solver.correctnessTests.AbstractCorrectnessTest + +class AmbiguousAStar2GrammarTreeCorrectnessTest : AbstractCorrectnessTest() { + @Test + override fun checkTreeCorrectnessForGrammar() { + runTests(AmbiguousAStar2Grammar()) + } +} \ No newline at end of file diff --git a/test-shared/src/test/kotlin/solver/correctnessTests/AmbiguousAStar3GrammarTest/AmbiguousAStar3Grammar.kt b/test-shared/src/test/kotlin/solver/correctnessTests/AmbiguousAStar3GrammarTest/AmbiguousAStar3Grammar.kt new file mode 100644 index 000000000..d63710c06 --- /dev/null +++ b/test-shared/src/test/kotlin/solver/correctnessTests/AmbiguousAStar3GrammarTest/AmbiguousAStar3Grammar.kt @@ -0,0 +1,16 @@ +package solver.correctnessTests.AmbiguousAStar3GrammarTest + + +import org.ucfs.grammar.combinator.Grammar +import org.ucfs.grammar.combinator.extension.StringExtension.or +import org.ucfs.grammar.combinator.extension.StringExtension.times +import org.ucfs.grammar.combinator.regexp.* + +class AmbiguousAStar3Grammar : Grammar() { + val S by Nt().asStart() + + init { + S /= "(" * S * ")" or "a" + // S = eps | ( S ) + } +} diff --git a/test-shared/src/test/kotlin/solver/correctnessTests/AmbiguousAStar3GrammarTest/AmbiguousAStar3GrammarTreeCorrectnessTest.kt b/test-shared/src/test/kotlin/solver/correctnessTests/AmbiguousAStar3GrammarTest/AmbiguousAStar3GrammarTreeCorrectnessTest.kt new file mode 100644 index 000000000..83fe059b0 --- /dev/null +++ b/test-shared/src/test/kotlin/solver/correctnessTests/AmbiguousAStar3GrammarTest/AmbiguousAStar3GrammarTreeCorrectnessTest.kt @@ -0,0 +1,11 @@ +package solver.correctnessTests.AmbiguousAStar3GrammarTest + +import org.junit.jupiter.api.Test +import solver.correctnessTests.AbstractCorrectnessTest + +class AmbiguousAStar3GrammarTreeCorrectnessTest : AbstractCorrectnessTest() { + @Test + override fun checkTreeCorrectnessForGrammar() { + runTests(AmbiguousAStar3Grammar()) + } +} \ No newline at end of file diff --git a/test-shared/src/test/kotlin/solver/correctnessTests/BipartitleGrammarTest/BipartitleGrammar.kt b/test-shared/src/test/kotlin/solver/correctnessTests/BipartitleGrammarTest/BipartitleGrammar.kt new file mode 100644 index 000000000..5e35fd0d5 --- /dev/null +++ b/test-shared/src/test/kotlin/solver/correctnessTests/BipartitleGrammarTest/BipartitleGrammar.kt @@ -0,0 +1,15 @@ +package solver.correctnessTests.BipartitleGrammarTest + + +import org.ucfs.grammar.combinator.Grammar +import org.ucfs.grammar.combinator.regexp.* +import org.ucfs.rsm.symbol.Term + +class BipartitleGrammar : Grammar() { + val A by Nt() + val B by Nt((Term("b") * A) or (Term("b"))) + val S by Nt(A).asStart() + init { + A /= (Term("a") * B) or (Term("a")) + } +} diff --git a/test-shared/src/test/kotlin/solver/correctnessTests/BipartitleGrammarTest/BipartitleGrammarTreeCorrectnessTest.kt b/test-shared/src/test/kotlin/solver/correctnessTests/BipartitleGrammarTest/BipartitleGrammarTreeCorrectnessTest.kt new file mode 100644 index 000000000..2ab0e2003 --- /dev/null +++ b/test-shared/src/test/kotlin/solver/correctnessTests/BipartitleGrammarTest/BipartitleGrammarTreeCorrectnessTest.kt @@ -0,0 +1,11 @@ +package solver.correctnessTests.BipartitleGrammarTest + +import org.junit.jupiter.api.Test +import solver.correctnessTests.AbstractCorrectnessTest + +class BipartitleGrammarTreeCorrectnessTest : AbstractCorrectnessTest() { + @Test + override fun checkTreeCorrectnessForGrammar() { + runTests(BipartitleGrammar()) + } +} \ No newline at end of file diff --git a/test-shared/src/test/kotlin/solver/correctnessTests/EpsilonGrammarTest/EpsilonGrammar.kt b/test-shared/src/test/kotlin/solver/correctnessTests/EpsilonGrammarTest/EpsilonGrammar.kt new file mode 100644 index 000000000..5257b8bbf --- /dev/null +++ b/test-shared/src/test/kotlin/solver/correctnessTests/EpsilonGrammarTest/EpsilonGrammar.kt @@ -0,0 +1,10 @@ +package solver.correctnessTests.EpsilonGrammarTest + + +import org.ucfs.grammar.combinator.Grammar +import org.ucfs.grammar.combinator.regexp.* + +class EpsilonGrammar : Grammar() { + + val S by Nt(Epsilon).asStart() +} \ No newline at end of file diff --git a/test-shared/src/test/kotlin/solver/correctnessTests/EpsilonGrammarTest/EpsilonGrammarTreeCorrectnessTest.kt b/test-shared/src/test/kotlin/solver/correctnessTests/EpsilonGrammarTest/EpsilonGrammarTreeCorrectnessTest.kt new file mode 100644 index 000000000..7686e8344 --- /dev/null +++ b/test-shared/src/test/kotlin/solver/correctnessTests/EpsilonGrammarTest/EpsilonGrammarTreeCorrectnessTest.kt @@ -0,0 +1,11 @@ +package solver.correctnessTests.EpsilonGrammarTest + +import org.junit.jupiter.api.Test +import solver.correctnessTests.AbstractCorrectnessTest + +class EpsilonGrammarTreeCorrectnessTest : AbstractCorrectnessTest() { + @Test + override fun checkTreeCorrectnessForGrammar() { + runTests(EpsilonGrammar()) + } +} \ No newline at end of file diff --git a/test-shared/src/test/kotlin/solver/correctnessTests/LoopDyckGrammarTest/LoopDyckGrammar.kt b/test-shared/src/test/kotlin/solver/correctnessTests/LoopDyckGrammarTest/LoopDyckGrammar.kt new file mode 100644 index 000000000..9018ff36b --- /dev/null +++ b/test-shared/src/test/kotlin/solver/correctnessTests/LoopDyckGrammarTest/LoopDyckGrammar.kt @@ -0,0 +1,15 @@ +package solver.correctnessTests.LoopDyckGrammarTest + + +import org.ucfs.grammar.combinator.Grammar +import org.ucfs.grammar.combinator.extension.StringExtension.times +import org.ucfs.grammar.combinator.regexp.* + +class LoopDyckGrammar : Grammar() { + val S by Nt().asStart() + + init { + S /= Many("(" * S * ")") + // S = [ ( S ) ]* + } +} diff --git a/test-shared/src/test/kotlin/solver/correctnessTests/LoopDyckGrammarTest/LoopDyckGrammarTreeCorrectnessTest.kt b/test-shared/src/test/kotlin/solver/correctnessTests/LoopDyckGrammarTest/LoopDyckGrammarTreeCorrectnessTest.kt new file mode 100644 index 000000000..b40337451 --- /dev/null +++ b/test-shared/src/test/kotlin/solver/correctnessTests/LoopDyckGrammarTest/LoopDyckGrammarTreeCorrectnessTest.kt @@ -0,0 +1,11 @@ +package solver.correctnessTests.LoopDyckGrammarTest + +import org.junit.jupiter.api.Test +import solver.correctnessTests.AbstractCorrectnessTest + +class LoopDyckGrammarTreeCorrectnessTest : AbstractCorrectnessTest() { + @Test + override fun checkTreeCorrectnessForGrammar() { + runTests(LoopDyckGrammar()) + } +} \ No newline at end of file diff --git a/test-shared/src/test/kotlin/solver/correctnessTests/SALangGrammarTest/SALangGrammar.kt b/test-shared/src/test/kotlin/solver/correctnessTests/SALangGrammarTest/SALangGrammar.kt new file mode 100644 index 000000000..9104c14d7 --- /dev/null +++ b/test-shared/src/test/kotlin/solver/correctnessTests/SALangGrammarTest/SALangGrammar.kt @@ -0,0 +1,11 @@ +package solver.correctnessTests.SALangGrammarTest + + +import org.ucfs.grammar.combinator.Grammar +import org.ucfs.grammar.combinator.extension.StringExtension.times +import org.ucfs.grammar.combinator.regexp.* + +class SALangGrammar : Grammar() { + val A by Nt("a" * "b") + val S by Nt((A or ("a" * "b")) * "c").asStart() +} \ No newline at end of file diff --git a/test-shared/src/test/kotlin/solver/correctnessTests/SALangGrammarTest/SALangGrammarTreeCorrectnessTest.kt b/test-shared/src/test/kotlin/solver/correctnessTests/SALangGrammarTest/SALangGrammarTreeCorrectnessTest.kt new file mode 100644 index 000000000..328ebfd18 --- /dev/null +++ b/test-shared/src/test/kotlin/solver/correctnessTests/SALangGrammarTest/SALangGrammarTreeCorrectnessTest.kt @@ -0,0 +1,11 @@ +package solver.correctnessTests.SALangGrammarTest + +import org.junit.jupiter.api.Test +import solver.correctnessTests.AbstractCorrectnessTest + +class SALangGrammarTreeCorrectnessTest : AbstractCorrectnessTest() { + @Test + override fun checkTreeCorrectnessForGrammar() { + runTests(SALangGrammar()) + } +} \ No newline at end of file diff --git a/test-shared/src/test/kotlin/solver/correctnessTests/SimplifiedDyckGrammarTest/SimplifiedDyckGrammar.kt b/test-shared/src/test/kotlin/solver/correctnessTests/SimplifiedDyckGrammarTest/SimplifiedDyckGrammar.kt new file mode 100644 index 000000000..fed242693 --- /dev/null +++ b/test-shared/src/test/kotlin/solver/correctnessTests/SimplifiedDyckGrammarTest/SimplifiedDyckGrammar.kt @@ -0,0 +1,15 @@ +package solver.correctnessTests.SimplifiedDyckGrammarTest + + +import org.ucfs.grammar.combinator.Grammar +import org.ucfs.grammar.combinator.extension.StringExtension.times +import org.ucfs.grammar.combinator.regexp.* + +class SimplifiedDyckGrammar : Grammar() { + val S by Nt().asStart() + + init { + S /= Option("(" * S * ")") + // S = ( S ) ? + } +} \ No newline at end of file diff --git a/test-shared/src/test/kotlin/solver/correctnessTests/SimplifiedDyckGrammarTest/SimplifiedDyckGrammarTreeCorrectnessTest.kt b/test-shared/src/test/kotlin/solver/correctnessTests/SimplifiedDyckGrammarTest/SimplifiedDyckGrammarTreeCorrectnessTest.kt new file mode 100644 index 000000000..8547eb903 --- /dev/null +++ b/test-shared/src/test/kotlin/solver/correctnessTests/SimplifiedDyckGrammarTest/SimplifiedDyckGrammarTreeCorrectnessTest.kt @@ -0,0 +1,11 @@ +package solver.correctnessTests.SimplifiedDyckGrammarTest + +import org.junit.jupiter.api.Test +import solver.correctnessTests.AbstractCorrectnessTest + +class SimplifiedDyckGrammarTreeCorrectnessTest : AbstractCorrectnessTest() { + @Test + override fun checkTreeCorrectnessForGrammar() { + runTests(SimplifiedDyckGrammar()) + } +} \ No newline at end of file diff --git a/test-shared/src/test/kotlin/solver/correctnessTests/StrangeDyckGrammarTest/StrangeDyckGrammar.kt b/test-shared/src/test/kotlin/solver/correctnessTests/StrangeDyckGrammarTest/StrangeDyckGrammar.kt new file mode 100644 index 000000000..d2e77c518 --- /dev/null +++ b/test-shared/src/test/kotlin/solver/correctnessTests/StrangeDyckGrammarTest/StrangeDyckGrammar.kt @@ -0,0 +1,16 @@ +package solver.correctnessTests.StrangeDyckGrammarTest + + +import org.ucfs.grammar.combinator.Grammar +import org.ucfs.grammar.combinator.extension.StringExtension.or +import org.ucfs.grammar.combinator.extension.StringExtension.times +import org.ucfs.grammar.combinator.regexp.* + +class StrangeDyckGrammar : Grammar() { + val S by Nt().asStart() + + init { + S /= "(" * S * ")" or "a" + // S = eps | ( S ) + } +} diff --git a/test-shared/src/test/kotlin/solver/correctnessTests/StrangeDyckGrammarTest/StrangeDyckGrammarTreeCorrectnessTest.kt b/test-shared/src/test/kotlin/solver/correctnessTests/StrangeDyckGrammarTest/StrangeDyckGrammarTreeCorrectnessTest.kt new file mode 100644 index 000000000..1d15a8fcb --- /dev/null +++ b/test-shared/src/test/kotlin/solver/correctnessTests/StrangeDyckGrammarTest/StrangeDyckGrammarTreeCorrectnessTest.kt @@ -0,0 +1,11 @@ +package solver.correctnessTests.StrangeDyckGrammarTest + +import org.junit.jupiter.api.Test +import solver.correctnessTests.AbstractCorrectnessTest + +class StrangeDyckGrammarTreeCorrectnessTest : AbstractCorrectnessTest() { + @Test + override fun checkTreeCorrectnessForGrammar() { + runTests(StrangeDyckGrammar()) + } +} \ No newline at end of file diff --git a/test-shared/src/test/resources/benchmarks/BipartitleGrammar/midle/input.dot b/test-shared/src/test/resources/benchmarks/BipartitleGrammar/midle/input.dot new file mode 100644 index 000000000..72698aaa9 --- /dev/null +++ b/test-shared/src/test/resources/benchmarks/BipartitleGrammar/midle/input.dot @@ -0,0 +1,103 @@ +digraph Input { + start -> 0; + 0 -> 0 [label = "c"]; + 0 -> 1 [label = "a"]; + 0 -> 2 [label = "c"]; + 0 -> 3 [label = "a"]; + 0 -> 4 [label = "c"]; + 0 -> 5 [label = "a"]; + 0 -> 6 [label = "c"]; + 0 -> 7 [label = "a"]; + 0 -> 8 [label = "c"]; + 0 -> 9 [label = "a"]; + 1 -> 0 [label = "b"]; + 1 -> 1 [label = "c"]; + 1 -> 2 [label = "b"]; + 1 -> 3 [label = "c"]; + 1 -> 4 [label = "b"]; + 1 -> 5 [label = "c"]; + 1 -> 6 [label = "b"]; + 1 -> 7 [label = "c"]; + 1 -> 8 [label = "b"]; + 1 -> 9 [label = "c"]; + 2 -> 0 [label = "c"]; + 2 -> 1 [label = "a"]; + 2 -> 2 [label = "c"]; + 2 -> 3 [label = "a"]; + 2 -> 4 [label = "c"]; + 2 -> 5 [label = "a"]; + 2 -> 6 [label = "c"]; + 2 -> 7 [label = "a"]; + 2 -> 8 [label = "c"]; + 2 -> 9 [label = "a"]; + 3 -> 0 [label = "b"]; + 3 -> 1 [label = "c"]; + 3 -> 2 [label = "b"]; + 3 -> 3 [label = "c"]; + 3 -> 4 [label = "b"]; + 3 -> 5 [label = "c"]; + 3 -> 6 [label = "b"]; + 3 -> 7 [label = "c"]; + 3 -> 8 [label = "b"]; + 3 -> 9 [label = "c"]; + 4 -> 0 [label = "c"]; + 4 -> 1 [label = "a"]; + 4 -> 2 [label = "c"]; + 4 -> 3 [label = "a"]; + 4 -> 4 [label = "c"]; + 4 -> 5 [label = "a"]; + 4 -> 6 [label = "c"]; + 4 -> 7 [label = "a"]; + 4 -> 8 [label = "c"]; + 4 -> 9 [label = "a"]; + 5 -> 0 [label = "b"]; + 5 -> 1 [label = "c"]; + 5 -> 2 [label = "b"]; + 5 -> 3 [label = "c"]; + 5 -> 4 [label = "b"]; + 5 -> 5 [label = "c"]; + 5 -> 6 [label = "b"]; + 5 -> 7 [label = "c"]; + 5 -> 8 [label = "b"]; + 5 -> 9 [label = "c"]; + 6 -> 0 [label = "c"]; + 6 -> 1 [label = "a"]; + 6 -> 2 [label = "c"]; + 6 -> 3 [label = "a"]; + 6 -> 4 [label = "c"]; + 6 -> 5 [label = "a"]; + 6 -> 6 [label = "c"]; + 6 -> 7 [label = "a"]; + 6 -> 8 [label = "c"]; + 6 -> 9 [label = "a"]; + 7 -> 0 [label = "b"]; + 7 -> 1 [label = "c"]; + 7 -> 2 [label = "b"]; + 7 -> 3 [label = "c"]; + 7 -> 4 [label = "b"]; + 7 -> 5 [label = "c"]; + 7 -> 6 [label = "b"]; + 7 -> 7 [label = "c"]; + 7 -> 8 [label = "b"]; + 7 -> 9 [label = "c"]; + 8 -> 0 [label = "c"]; + 8 -> 1 [label = "a"]; + 8 -> 2 [label = "c"]; + 8 -> 3 [label = "a"]; + 8 -> 4 [label = "c"]; + 8 -> 5 [label = "a"]; + 8 -> 6 [label = "c"]; + 8 -> 7 [label = "a"]; + 8 -> 8 [label = "c"]; + 8 -> 9 [label = "a"]; + 9 -> 0 [label = "b"]; + 9 -> 1 [label = "c"]; + 9 -> 2 [label = "b"]; + 9 -> 3 [label = "c"]; + 9 -> 4 [label = "b"]; + 9 -> 5 [label = "c"]; + 9 -> 6 [label = "b"]; + 9 -> 7 [label = "c"]; + 9 -> 8 [label = "b"]; + 9 -> 9 [label = "c"]; +} \ No newline at end of file diff --git a/test-shared/src/test/resources/benchmarks/BipartitleGrammar/smaller/input.dot b/test-shared/src/test/resources/benchmarks/BipartitleGrammar/smaller/input.dot new file mode 100644 index 000000000..ee04b3238 --- /dev/null +++ b/test-shared/src/test/resources/benchmarks/BipartitleGrammar/smaller/input.dot @@ -0,0 +1,28 @@ +digraph Input { + start -> 0; + 0 -> 0 [label = "c"]; + 0 -> 1 [label = "a"]; + 0 -> 2 [label = "c"]; + 0 -> 3 [label = "a"]; + 0 -> 4 [label = "c"]; + 1 -> 0 [label = "b"]; + 1 -> 1 [label = "c"]; + 1 -> 2 [label = "b"]; + 1 -> 3 [label = "c"]; + 1 -> 4 [label = "b"]; + 2 -> 0 [label = "c"]; + 2 -> 1 [label = "a"]; + 2 -> 2 [label = "c"]; + 2 -> 3 [label = "a"]; + 2 -> 4 [label = "c"]; + 3 -> 0 [label = "b"]; + 3 -> 1 [label = "c"]; + 3 -> 2 [label = "b"]; + 3 -> 3 [label = "c"]; + 3 -> 4 [label = "b"]; + 4 -> 0 [label = "c"]; + 4 -> 1 [label = "a"]; + 4 -> 2 [label = "c"]; + 4 -> 3 [label = "a"]; + 4 -> 4 [label = "c"]; +} \ No newline at end of file diff --git a/test-shared/src/test/resources/benchmarks/CAliasGrammar/smallTest/input.dot b/test-shared/src/test/resources/benchmarks/CAliasGrammar/smallTest/input.dot new file mode 100644 index 000000000..73a7f6688 --- /dev/null +++ b/test-shared/src/test/resources/benchmarks/CAliasGrammar/smallTest/input.dot @@ -0,0 +1,872 @@ +digraph Input { + 0 -> 1 [label = "d"]; + 1 -> 0 [label = "d_r"]; + 2 -> 3 [label = "d"]; + 3 -> 2 [label = "d_r"]; + 3 -> 71 [label = "a"]; + 71 -> 3 [label = "a_r"]; + 3 -> 90 [label = "a"]; + 90 -> 3 [label = "a_r"]; + 4 -> 5 [label = "d"]; + 5 -> 4 [label = "d_r"]; + 5 -> 239 [label = "d"]; + 239 -> 5 [label = "d_r"]; + 6 -> 7 [label = "a"]; + 7 -> 6 [label = "a_r"]; + 7 -> 218 [label = "d"]; + 218 -> 7 [label = "d_r"]; + 7 -> 6 [label = "a"]; + 6 -> 7 [label = "a_r"]; + 7 -> 7 [label = "a"]; + 7 -> 7 [label = "a_r"]; + 8 -> 9 [label = "a"]; + 9 -> 8 [label = "a_r"]; + 9 -> 116 [label = "a"]; + 116 -> 9 [label = "a_r"]; + 9 -> 9 [label = "a"]; + 9 -> 9 [label = "a_r"]; + 9 -> 75 [label = "a"]; + 75 -> 9 [label = "a_r"]; + 10 -> 11 [label = "d"]; + 11 -> 10 [label = "d_r"]; + 11 -> 296 [label = "d"]; + 296 -> 11 [label = "d_r"]; + 12 -> 13 [label = "d"]; + 13 -> 12 [label = "d_r"]; + 14 -> 15 [label = "d"]; + 15 -> 14 [label = "d_r"]; + 15 -> 211 [label = "a"]; + 211 -> 15 [label = "a_r"]; + 16 -> 17 [label = "d"]; + 17 -> 16 [label = "d_r"]; + 18 -> 19 [label = "d"]; + 19 -> 18 [label = "d_r"]; + 20 -> 21 [label = "d"]; + 21 -> 20 [label = "d_r"]; + 21 -> 222 [label = "a"]; + 222 -> 21 [label = "a_r"]; + 22 -> 23 [label = "d"]; + 23 -> 22 [label = "d_r"]; + 24 -> 25 [label = "d"]; + 25 -> 24 [label = "d_r"]; + 26 -> 27 [label = "d"]; + 27 -> 26 [label = "d_r"]; + 27 -> 215 [label = "d"]; + 215 -> 27 [label = "d_r"]; + 28 -> 29 [label = "d"]; + 29 -> 28 [label = "d_r"]; + 29 -> 7 [label = "a"]; + 7 -> 29 [label = "a_r"]; + 29 -> 6 [label = "a"]; + 6 -> 29 [label = "a_r"]; + 30 -> 19 [label = "a"]; + 19 -> 30 [label = "a_r"]; + 31 -> 32 [label = "a"]; + 32 -> 31 [label = "a_r"]; + 32 -> 32 [label = "a"]; + 32 -> 32 [label = "a_r"]; + 32 -> 31 [label = "a"]; + 31 -> 32 [label = "a_r"]; + 33 -> 34 [label = "d"]; + 34 -> 33 [label = "d_r"]; + 34 -> 35 [label = "d"]; + 35 -> 34 [label = "d_r"]; + 36 -> 37 [label = "d"]; + 37 -> 36 [label = "d_r"]; + 38 -> 39 [label = "a"]; + 39 -> 38 [label = "a_r"]; + 39 -> 38 [label = "a"]; + 38 -> 39 [label = "a_r"]; + 40 -> 41 [label = "a"]; + 41 -> 40 [label = "a_r"]; + 42 -> 43 [label = "a"]; + 43 -> 42 [label = "a_r"]; + 43 -> 43 [label = "a"]; + 43 -> 43 [label = "a_r"]; + 43 -> 42 [label = "a"]; + 42 -> 43 [label = "a_r"]; + 44 -> 45 [label = "d"]; + 45 -> 44 [label = "d_r"]; + 45 -> 214 [label = "a"]; + 214 -> 45 [label = "a_r"]; + 46 -> 47 [label = "d"]; + 47 -> 46 [label = "d_r"]; + 47 -> 209 [label = "d"]; + 209 -> 47 [label = "d_r"]; + 48 -> 9 [label = "d"]; + 9 -> 48 [label = "d_r"]; + 49 -> 50 [label = "a"]; + 50 -> 49 [label = "a_r"]; + 50 -> 50 [label = "a"]; + 50 -> 50 [label = "a_r"]; + 50 -> 70 [label = "a"]; + 70 -> 50 [label = "a_r"]; + 50 -> 152 [label = "a"]; + 152 -> 50 [label = "a_r"]; + 51 -> 52 [label = "d"]; + 52 -> 51 [label = "d_r"]; + 53 -> 54 [label = "d"]; + 54 -> 53 [label = "d_r"]; + 55 -> 56 [label = "d"]; + 56 -> 55 [label = "d_r"]; + 56 -> 283 [label = "d"]; + 283 -> 56 [label = "d_r"]; + 57 -> 58 [label = "a"]; + 58 -> 57 [label = "a_r"]; + 57 -> 91 [label = "a"]; + 91 -> 57 [label = "a_r"]; + 57 -> 206 [label = "a"]; + 206 -> 57 [label = "a_r"]; + 58 -> 224 [label = "d"]; + 224 -> 58 [label = "d_r"]; + 59 -> 6 [label = "d"]; + 6 -> 59 [label = "d_r"]; + 60 -> 61 [label = "a"]; + 61 -> 60 [label = "a_r"]; + 61 -> 115 [label = "a"]; + 115 -> 61 [label = "a_r"]; + 62 -> 32 [label = "d"]; + 32 -> 62 [label = "d_r"]; + 63 -> 64 [label = "d"]; + 64 -> 63 [label = "d_r"]; + 64 -> 165 [label = "a"]; + 165 -> 64 [label = "a_r"]; + 65 -> 66 [label = "d"]; + 66 -> 65 [label = "d_r"]; + 66 -> 269 [label = "d"]; + 269 -> 66 [label = "d_r"]; + 67 -> 68 [label = "d"]; + 68 -> 67 [label = "d_r"]; + 69 -> 70 [label = "a"]; + 70 -> 69 [label = "a_r"]; + 70 -> 70 [label = "a"]; + 70 -> 70 [label = "a_r"]; + 70 -> 198 [label = "a"]; + 198 -> 70 [label = "a_r"]; + 71 -> 90 [label = "a"]; + 90 -> 71 [label = "a_r"]; + 72 -> 73 [label = "d"]; + 73 -> 72 [label = "d_r"]; + 74 -> 75 [label = "d"]; + 75 -> 74 [label = "d_r"]; + 75 -> 116 [label = "a"]; + 116 -> 75 [label = "a_r"]; + 75 -> 9 [label = "a"]; + 9 -> 75 [label = "a_r"]; + 76 -> 77 [label = "d"]; + 77 -> 76 [label = "d_r"]; + 77 -> 94 [label = "d"]; + 94 -> 77 [label = "d_r"]; + 78 -> 79 [label = "a"]; + 79 -> 78 [label = "a_r"]; + 79 -> 167 [label = "a"]; + 167 -> 79 [label = "a_r"]; + 80 -> 7 [label = "d"]; + 7 -> 80 [label = "d_r"]; + 81 -> 82 [label = "d"]; + 82 -> 81 [label = "d_r"]; + 83 -> 84 [label = "a"]; + 84 -> 83 [label = "a_r"]; + 85 -> 79 [label = "a"]; + 79 -> 85 [label = "a_r"]; + 86 -> 87 [label = "d"]; + 87 -> 86 [label = "d_r"]; + 88 -> 89 [label = "d"]; + 89 -> 88 [label = "d_r"]; + 90 -> 90 [label = "a"]; + 90 -> 90 [label = "a_r"]; + 90 -> 71 [label = "a"]; + 71 -> 90 [label = "a_r"]; + 92 -> 93 [label = "d"]; + 93 -> 92 [label = "d_r"]; + 94 -> 7 [label = "a"]; + 7 -> 94 [label = "a_r"]; + 94 -> 6 [label = "a"]; + 6 -> 94 [label = "a_r"]; + 94 -> 276 [label = "a"]; + 276 -> 94 [label = "a_r"]; + 95 -> 8 [label = "d"]; + 8 -> 95 [label = "d_r"]; + 96 -> 97 [label = "a"]; + 97 -> 96 [label = "a_r"]; + 98 -> 99 [label = "d"]; + 99 -> 98 [label = "d_r"]; + 100 -> 8 [label = "a"]; + 8 -> 100 [label = "a_r"]; + 101 -> 102 [label = "d"]; + 102 -> 101 [label = "d_r"]; + 102 -> 143 [label = "a"]; + 143 -> 102 [label = "a_r"]; + 103 -> 104 [label = "a"]; + 104 -> 103 [label = "a_r"]; + 105 -> 106 [label = "d"]; + 106 -> 105 [label = "d_r"]; + 107 -> 97 [label = "d"]; + 97 -> 107 [label = "d_r"]; + 108 -> 109 [label = "d"]; + 109 -> 108 [label = "d_r"]; + 110 -> 61 [label = "d"]; + 61 -> 110 [label = "d_r"]; + 111 -> 39 [label = "d"]; + 39 -> 111 [label = "d_r"]; + 112 -> 7 [label = "a"]; + 7 -> 112 [label = "a_r"]; + 112 -> 205 [label = "a"]; + 205 -> 112 [label = "a_r"]; + 112 -> 6 [label = "a"]; + 6 -> 112 [label = "a_r"]; + 113 -> 114 [label = "d"]; + 114 -> 113 [label = "d_r"]; + 116 -> 9 [label = "a"]; + 9 -> 116 [label = "a_r"]; + 117 -> 90 [label = "d"]; + 90 -> 117 [label = "d_r"]; + 118 -> 119 [label = "d"]; + 119 -> 118 [label = "d_r"]; + 119 -> 130 [label = "a"]; + 130 -> 119 [label = "a_r"]; + 120 -> 79 [label = "a"]; + 79 -> 120 [label = "a_r"]; + 121 -> 38 [label = "d"]; + 38 -> 121 [label = "d_r"]; + 122 -> 58 [label = "d"]; + 58 -> 122 [label = "d_r"]; + 123 -> 124 [label = "d"]; + 124 -> 123 [label = "d_r"]; + 125 -> 126 [label = "a"]; + 126 -> 125 [label = "a_r"]; + 127 -> 128 [label = "d"]; + 128 -> 127 [label = "d_r"]; + 129 -> 70 [label = "a"]; + 70 -> 129 [label = "a_r"]; + 129 -> 198 [label = "a"]; + 198 -> 129 [label = "a_r"]; + 130 -> 93 [label = "a"]; + 93 -> 130 [label = "a_r"]; + 130 -> 188 [label = "a"]; + 188 -> 130 [label = "a_r"]; + 130 -> 169 [label = "a"]; + 169 -> 130 [label = "a_r"]; + 131 -> 132 [label = "d"]; + 132 -> 131 [label = "d_r"]; + 132 -> 258 [label = "d"]; + 258 -> 132 [label = "d_r"]; + 133 -> 134 [label = "d"]; + 134 -> 133 [label = "d_r"]; + 134 -> 311 [label = "a"]; + 311 -> 134 [label = "a_r"]; + 135 -> 42 [label = "d"]; + 42 -> 135 [label = "d_r"]; + 136 -> 43 [label = "a"]; + 43 -> 136 [label = "a_r"]; + 136 -> 42 [label = "a"]; + 42 -> 136 [label = "a_r"]; + 137 -> 138 [label = "d"]; + 138 -> 137 [label = "d_r"]; + 139 -> 140 [label = "d"]; + 140 -> 139 [label = "d_r"]; + 141 -> 142 [label = "d"]; + 142 -> 141 [label = "d_r"]; + 144 -> 145 [label = "a"]; + 145 -> 144 [label = "a_r"]; + 146 -> 147 [label = "d"]; + 147 -> 146 [label = "d_r"]; + 148 -> 129 [label = "d"]; + 129 -> 148 [label = "d_r"]; + 149 -> 150 [label = "d"]; + 150 -> 149 [label = "d_r"]; + 151 -> 77 [label = "a"]; + 77 -> 151 [label = "a_r"]; + 152 -> 50 [label = "a"]; + 50 -> 152 [label = "a_r"]; + 153 -> 79 [label = "d"]; + 79 -> 153 [label = "d_r"]; + 154 -> 155 [label = "d"]; + 155 -> 154 [label = "d_r"]; + 155 -> 196 [label = "d"]; + 196 -> 155 [label = "d_r"]; + 156 -> 136 [label = "a"]; + 136 -> 156 [label = "a_r"]; + 157 -> 70 [label = "d"]; + 70 -> 157 [label = "d_r"]; + 158 -> 91 [label = "a"]; + 91 -> 158 [label = "a_r"]; + 159 -> 61 [label = "a"]; + 61 -> 159 [label = "a_r"]; + 160 -> 161 [label = "d"]; + 161 -> 160 [label = "d_r"]; + 161 -> 152 [label = "a"]; + 152 -> 161 [label = "a_r"]; + 161 -> 50 [label = "a"]; + 50 -> 161 [label = "a_r"]; + 162 -> 163 [label = "d"]; + 163 -> 162 [label = "d_r"]; + 163 -> 37 [label = "a"]; + 37 -> 163 [label = "a_r"]; + 164 -> 31 [label = "d"]; + 31 -> 164 [label = "d_r"]; + 166 -> 167 [label = "d"]; + 167 -> 166 [label = "d_r"]; + 168 -> 169 [label = "d"]; + 169 -> 168 [label = "d_r"]; + 170 -> 171 [label = "d"]; + 171 -> 170 [label = "d_r"]; + 172 -> 136 [label = "d"]; + 136 -> 172 [label = "d_r"]; + 173 -> 126 [label = "d"]; + 126 -> 173 [label = "d_r"]; + 174 -> 85 [label = "d"]; + 85 -> 174 [label = "d_r"]; + 175 -> 176 [label = "d"]; + 176 -> 175 [label = "d_r"]; + 177 -> 178 [label = "a"]; + 178 -> 177 [label = "a_r"]; + 179 -> 180 [label = "d"]; + 180 -> 179 [label = "d_r"]; + 181 -> 182 [label = "d"]; + 182 -> 181 [label = "d_r"]; + 183 -> 184 [label = "d"]; + 184 -> 183 [label = "d_r"]; + 185 -> 186 [label = "d"]; + 186 -> 185 [label = "d_r"]; + 187 -> 188 [label = "d"]; + 188 -> 187 [label = "d_r"]; + 189 -> 190 [label = "d"]; + 190 -> 189 [label = "d_r"]; + 190 -> 191 [label = "a"]; + 191 -> 190 [label = "a_r"]; + 192 -> 193 [label = "a"]; + 193 -> 192 [label = "a_r"]; + 193 -> 9 [label = "a"]; + 9 -> 193 [label = "a_r"]; + 194 -> 195 [label = "d"]; + 195 -> 194 [label = "d_r"]; + 196 -> 197 [label = "a"]; + 197 -> 196 [label = "a_r"]; + 198 -> 70 [label = "a"]; + 70 -> 198 [label = "a_r"]; + 199 -> 102 [label = "a"]; + 102 -> 199 [label = "a_r"]; + 200 -> 201 [label = "d"]; + 201 -> 200 [label = "d_r"]; + 201 -> 54 [label = "a"]; + 54 -> 201 [label = "a_r"]; + 202 -> 104 [label = "d"]; + 104 -> 202 [label = "d_r"]; + 203 -> 204 [label = "d"]; + 204 -> 203 [label = "d_r"]; + 207 -> 143 [label = "d"]; + 143 -> 207 [label = "d_r"]; + 208 -> 205 [label = "d"]; + 205 -> 208 [label = "d_r"]; + 209 -> 210 [label = "d"]; + 210 -> 209 [label = "d_r"]; + 212 -> 213 [label = "d"]; + 213 -> 212 [label = "d_r"]; + 213 -> 325 [label = "d"]; + 325 -> 213 [label = "d_r"]; + 214 -> 50 [label = "a"]; + 50 -> 214 [label = "a_r"]; + 216 -> 217 [label = "d"]; + 217 -> 216 [label = "d_r"]; + 219 -> 158 [label = "d"]; + 158 -> 219 [label = "d_r"]; + 220 -> 3 [label = "a"]; + 3 -> 220 [label = "a_r"]; + 221 -> 222 [label = "d"]; + 222 -> 221 [label = "d_r"]; + 222 -> 21 [label = "a"]; + 21 -> 222 [label = "a_r"]; + 223 -> 30 [label = "d"]; + 30 -> 223 [label = "d_r"]; + 224 -> 87 [label = "a"]; + 87 -> 224 [label = "a_r"]; + 225 -> 178 [label = "d"]; + 178 -> 225 [label = "d_r"]; + 226 -> 227 [label = "d"]; + 227 -> 226 [label = "d_r"]; + 228 -> 229 [label = "d"]; + 229 -> 228 [label = "d_r"]; + 229 -> 237 [label = "d"]; + 237 -> 229 [label = "d_r"]; + 230 -> 165 [label = "d"]; + 165 -> 230 [label = "d_r"]; + 231 -> 84 [label = "d"]; + 84 -> 231 [label = "d_r"]; + 232 -> 41 [label = "d"]; + 41 -> 232 [label = "d_r"]; + 233 -> 234 [label = "d"]; + 234 -> 233 [label = "d_r"]; + 234 -> 79 [label = "a"]; + 79 -> 234 [label = "a_r"]; + 235 -> 43 [label = "a"]; + 43 -> 235 [label = "a_r"]; + 236 -> 197 [label = "d"]; + 197 -> 236 [label = "d_r"]; + 238 -> 71 [label = "d"]; + 71 -> 238 [label = "d_r"]; + 240 -> 241 [label = "d"]; + 241 -> 240 [label = "d_r"]; + 242 -> 198 [label = "d"]; + 198 -> 242 [label = "d_r"]; + 243 -> 244 [label = "d"]; + 244 -> 243 [label = "d_r"]; + 245 -> 246 [label = "d"]; + 246 -> 245 [label = "d_r"]; + 247 -> 8 [label = "a"]; + 8 -> 247 [label = "a_r"]; + 248 -> 145 [label = "d"]; + 145 -> 248 [label = "d_r"]; + 249 -> 250 [label = "d"]; + 250 -> 249 [label = "d_r"]; + 251 -> 252 [label = "d"]; + 252 -> 251 [label = "d_r"]; + 253 -> 79 [label = "a"]; + 79 -> 253 [label = "a_r"]; + 254 -> 255 [label = "d"]; + 255 -> 254 [label = "d_r"]; + 255 -> 277 [label = "d"]; + 277 -> 255 [label = "d_r"]; + 256 -> 129 [label = "a"]; + 129 -> 256 [label = "a_r"]; + 257 -> 8 [label = "a"]; + 8 -> 257 [label = "a_r"]; + 259 -> 205 [label = "a"]; + 205 -> 259 [label = "a_r"]; + 260 -> 261 [label = "d"]; + 261 -> 260 [label = "d_r"]; + 262 -> 79 [label = "a"]; + 79 -> 262 [label = "a_r"]; + 263 -> 161 [label = "a"]; + 161 -> 263 [label = "a_r"]; + 264 -> 253 [label = "d"]; + 253 -> 264 [label = "d_r"]; + 265 -> 266 [label = "d"]; + 266 -> 265 [label = "d_r"]; + 267 -> 268 [label = "d"]; + 268 -> 267 [label = "d_r"]; + 269 -> 270 [label = "d"]; + 270 -> 269 [label = "d_r"]; + 271 -> 41 [label = "a"]; + 41 -> 271 [label = "a_r"]; + 272 -> 177 [label = "d"]; + 177 -> 272 [label = "d_r"]; + 273 -> 91 [label = "d"]; + 91 -> 273 [label = "d_r"]; + 274 -> 275 [label = "d"]; + 275 -> 274 [label = "d_r"]; + 278 -> 211 [label = "d"]; + 211 -> 278 [label = "d_r"]; + 279 -> 280 [label = "d"]; + 280 -> 279 [label = "d_r"]; + 281 -> 130 [label = "d"]; + 130 -> 281 [label = "d_r"]; + 282 -> 241 [label = "a"]; + 241 -> 282 [label = "a_r"]; + 282 -> 90 [label = "a"]; + 90 -> 282 [label = "a_r"]; + 284 -> 41 [label = "a"]; + 41 -> 284 [label = "a_r"]; + 285 -> 50 [label = "d"]; + 50 -> 285 [label = "d_r"]; + 286 -> 287 [label = "d"]; + 287 -> 286 [label = "d_r"]; + 288 -> 276 [label = "d"]; + 276 -> 288 [label = "d_r"]; + 289 -> 102 [label = "a"]; + 102 -> 289 [label = "a_r"]; + 290 -> 291 [label = "d"]; + 291 -> 290 [label = "d_r"]; + 292 -> 41 [label = "a"]; + 41 -> 292 [label = "a_r"]; + 293 -> 294 [label = "d"]; + 294 -> 293 [label = "d_r"]; + 295 -> 193 [label = "d"]; + 193 -> 295 [label = "d_r"]; + 297 -> 191 [label = "d"]; + 191 -> 297 [label = "d_r"]; + 298 -> 299 [label = "d"]; + 299 -> 298 [label = "d_r"]; + 300 -> 151 [label = "d"]; + 151 -> 300 [label = "d_r"]; + 301 -> 193 [label = "a"]; + 193 -> 301 [label = "a_r"]; + 302 -> 41 [label = "a"]; + 41 -> 302 [label = "a_r"]; + 303 -> 45 [label = "a"]; + 45 -> 303 [label = "a_r"]; + 304 -> 41 [label = "a"]; + 41 -> 304 [label = "a_r"]; + 305 -> 191 [label = "a"]; + 191 -> 305 [label = "a_r"]; + 306 -> 125 [label = "d"]; + 125 -> 306 [label = "d_r"]; + 307 -> 308 [label = "d"]; + 308 -> 307 [label = "d_r"]; + 309 -> 115 [label = "d"]; + 115 -> 309 [label = "d_r"]; + 310 -> 311 [label = "d"]; + 311 -> 310 [label = "d_r"]; + 312 -> 313 [label = "d"]; + 313 -> 312 [label = "d_r"]; + 314 -> 82 [label = "a"]; + 82 -> 314 [label = "a_r"]; + 315 -> 144 [label = "d"]; + 144 -> 315 [label = "d_r"]; + 316 -> 214 [label = "d"]; + 214 -> 316 [label = "d_r"]; + 317 -> 152 [label = "d"]; + 152 -> 317 [label = "d_r"]; + 318 -> 319 [label = "d"]; + 319 -> 318 [label = "d_r"]; + 320 -> 321 [label = "d"]; + 321 -> 320 [label = "d_r"]; + 322 -> 79 [label = "a"]; + 79 -> 322 [label = "a_r"]; + 323 -> 120 [label = "d"]; + 120 -> 323 [label = "d_r"]; + 324 -> 116 [label = "d"]; + 116 -> 324 [label = "d_r"]; + 326 -> 206 [label = "d"]; + 206 -> 326 [label = "d_r"]; + 327 -> 328 [label = "d"]; + 328 -> 327 [label = "d_r"]; + 329 -> 41 [label = "a"]; + 41 -> 329 [label = "a_r"]; + 330 -> 319 [label = "a"]; + 319 -> 330 [label = "a_r"]; + 331 -> 43 [label = "d"]; + 43 -> 331 [label = "d_r"]; + start -> 243 ; + start -> 282 ; + start -> 322 ; + start -> 296 ; + start -> 162 ; + start -> 173 ; + start -> 196 ; + start -> 312 ; + start -> 16 ; + start -> 8 ; + start -> 191 ; + start -> 307 ; + start -> 228 ; + start -> 236 ; + start -> 225 ; + start -> 178 ; + start -> 289 ; + start -> 198 ; + start -> 331 ; + start -> 121 ; + start -> 106 ; + start -> 69 ; + start -> 263 ; + start -> 224 ; + start -> 184 ; + start -> 313 ; + start -> 179 ; + start -> 260 ; + start -> 271 ; + start -> 96 ; + start -> 61 ; + start -> 97 ; + start -> 143 ; + start -> 320 ; + start -> 264 ; + start -> 248 ; + start -> 151 ; + start -> 242 ; + start -> 39 ; + start -> 206 ; + start -> 274 ; + start -> 78 ; + start -> 98 ; + start -> 79 ; + start -> 302 ; + start -> 280 ; + start -> 53 ; + start -> 73 ; + start -> 160 ; + start -> 144 ; + start -> 211 ; + start -> 273 ; + start -> 7 ; + start -> 125 ; + start -> 155 ; + start -> 19 ; + start -> 255 ; + start -> 325 ; + start -> 64 ; + start -> 100 ; + start -> 266 ; + start -> 59 ; + start -> 142 ; + start -> 291 ; + start -> 315 ; + start -> 292 ; + start -> 148 ; + start -> 204 ; + start -> 199 ; + start -> 4 ; + start -> 316 ; + start -> 26 ; + start -> 300 ; + start -> 240 ; + start -> 101 ; + start -> 159 ; + start -> 235 ; + start -> 283 ; + start -> 189 ; + start -> 294 ; + start -> 20 ; + start -> 269 ; + start -> 201 ; + start -> 68 ; + start -> 232 ; + start -> 150 ; + start -> 87 ; + start -> 152 ; + start -> 247 ; + start -> 207 ; + start -> 131 ; + start -> 103 ; + start -> 163 ; + start -> 52 ; + start -> 284 ; + start -> 229 ; + start -> 63 ; + start -> 220 ; + start -> 181 ; + start -> 208 ; + start -> 172 ; + start -> 200 ; + start -> 74 ; + start -> 31 ; + start -> 49 ; + start -> 102 ; + start -> 10 ; + start -> 48 ; + start -> 230 ; + start -> 71 ; + start -> 47 ; + start -> 161 ; + start -> 295 ; + start -> 13 ; + start -> 272 ; + start -> 324 ; + start -> 314 ; + start -> 287 ; + start -> 99 ; + start -> 132 ; + start -> 279 ; + start -> 328 ; + start -> 41 ; + start -> 75 ; + start -> 192 ; + start -> 5 ; + start -> 88 ; + start -> 319 ; + start -> 122 ; + start -> 233 ; + start -> 55 ; + start -> 138 ; + start -> 135 ; + start -> 213 ; + start -> 227 ; + start -> 66 ; + start -> 58 ; + start -> 218 ; + start -> 146 ; + start -> 166 ; + start -> 297 ; + start -> 246 ; + start -> 261 ; + start -> 60 ; + start -> 265 ; + start -> 180 ; + start -> 65 ; + start -> 137 ; + start -> 46 ; + start -> 72 ; + start -> 3 ; + start -> 214 ; + start -> 70 ; + start -> 45 ; + start -> 76 ; + start -> 114 ; + start -> 308 ; + start -> 241 ; + start -> 92 ; + start -> 169 ; + start -> 238 ; + start -> 285 ; + start -> 252 ; + start -> 109 ; + start -> 245 ; + start -> 27 ; + start -> 321 ; + start -> 77 ; + start -> 249 ; + start -> 111 ; + start -> 309 ; + start -> 290 ; + start -> 23 ; + start -> 149 ; + start -> 28 ; + start -> 1 ; + start -> 222 ; + start -> 21 ; + start -> 326 ; + start -> 221 ; + start -> 32 ; + start -> 209 ; + start -> 299 ; + start -> 183 ; + start -> 288 ; + start -> 259 ; + start -> 84 ; + start -> 140 ; + start -> 215 ; + start -> 212 ; + start -> 124 ; + start -> 18 ; + start -> 51 ; + start -> 185 ; + start -> 244 ; + start -> 86 ; + start -> 156 ; + start -> 30 ; + start -> 104 ; + start -> 113 ; + start -> 329 ; + start -> 171 ; + start -> 129 ; + start -> 275 ; + start -> 117 ; + start -> 234 ; + start -> 311 ; + start -> 44 ; + start -> 145 ; + start -> 268 ; + start -> 130 ; + start -> 188 ; + start -> 219 ; + start -> 25 ; + start -> 62 ; + start -> 120 ; + start -> 36 ; + start -> 12 ; + start -> 177 ; + start -> 133 ; + start -> 108 ; + start -> 286 ; + start -> 128 ; + start -> 134 ; + start -> 157 ; + start -> 22 ; + start -> 239 ; + start -> 190 ; + start -> 237 ; + start -> 164 ; + start -> 223 ; + start -> 119 ; + start -> 11 ; + start -> 17 ; + start -> 33 ; + start -> 40 ; + start -> 56 ; + start -> 310 ; + start -> 182 ; + start -> 168 ; + start -> 254 ; + start -> 174 ; + start -> 110 ; + start -> 167 ; + start -> 327 ; + start -> 136 ; + start -> 35 ; + start -> 217 ; + start -> 123 ; + start -> 170 ; + start -> 158 ; + start -> 34 ; + start -> 107 ; + start -> 193 ; + start -> 42 ; + start -> 256 ; + start -> 54 ; + start -> 15 ; + start -> 250 ; + start -> 276 ; + start -> 194 ; + start -> 301 ; + start -> 186 ; + start -> 251 ; + start -> 67 ; + start -> 304 ; + start -> 202 ; + start -> 216 ; + start -> 82 ; + start -> 141 ; + start -> 127 ; + start -> 14 ; + start -> 94 ; + start -> 115 ; + start -> 57 ; + start -> 89 ; + start -> 90 ; + start -> 91 ; + start -> 93 ; + start -> 305 ; + start -> 105 ; + start -> 50 ; + start -> 267 ; + start -> 153 ; + start -> 112 ; + start -> 281 ; + start -> 29 ; + start -> 258 ; + start -> 116 ; + start -> 257 ; + start -> 278 ; + start -> 95 ; + start -> 176 ; + start -> 303 ; + start -> 175 ; + start -> 83 ; + start -> 195 ; + start -> 231 ; + start -> 80 ; + start -> 298 ; + start -> 24 ; + start -> 118 ; + start -> 262 ; + start -> 197 ; + start -> 165 ; + start -> 277 ; + start -> 43 ; + start -> 2 ; + start -> 203 ; + start -> 323 ; + start -> 85 ; + start -> 139 ; + start -> 147 ; + start -> 318 ; + start -> 6 ; + start -> 330 ; + start -> 126 ; + start -> 38 ; + start -> 317 ; + start -> 81 ; + start -> 205 ; + start -> 0 ; + start -> 187 ; + start -> 293 ; + start -> 210 ; + start -> 37 ; + start -> 9 ; + start -> 154 ; + start -> 226 ; + start -> 306 ; + start -> 253 ; + start -> 270 ; +} \ No newline at end of file diff --git a/test-shared/src/test/resources/benchmarks/LoopDyckGrammar/minimalWorstCase/input.dot b/test-shared/src/test/resources/benchmarks/LoopDyckGrammar/minimalWorstCase/input.dot new file mode 100644 index 000000000..7c08420c5 --- /dev/null +++ b/test-shared/src/test/resources/benchmarks/LoopDyckGrammar/minimalWorstCase/input.dot @@ -0,0 +1,7 @@ +digraph Input { + label="Minimal worst case, simple loop RSM for Dyck language" + start -> 0; + 0 -> 0 [label = "("]; + 0 -> 1 [label = ")"]; + 1 -> 0 [label = ")"]; +} \ No newline at end of file diff --git a/test-shared/src/test/resources/benchmarks/LoopDyckGrammar/minimalWorstCase/result.dot b/test-shared/src/test/resources/benchmarks/LoopDyckGrammar/minimalWorstCase/result.dot new file mode 100644 index 000000000..4e34aec1a --- /dev/null +++ b/test-shared/src/test/resources/benchmarks/LoopDyckGrammar/minimalWorstCase/result.dot @@ -0,0 +1,73 @@ +digraph g { +labelloc="t" +label="" +subgraph cluster_0{ +labelloc="t" +_0_0 [label = "0 Nonterminal S, input: [0, 0]", shape = invtrapezium] +_0_1 [label = "1 Range , input: [0, 0], rsm: [S_0, S_0]", shape = ellipse] +_0_2 [label = "10 Terminal '(', input: [0, 0]", shape = rectangle] +_0_3 [label = "11 Nonterminal S, input: [0, 1]", shape = invtrapezium] +_0_4 [label = "12 Range , input: [0, 1], rsm: [S_0, S_0]", shape = ellipse] +_0_5 [label = "13 Intermediate input: 0, rsm: S_2, input: [0, 1]", shape = plain] +_0_6 [label = "14 Range , input: [0, 0], rsm: [S_0, S_2]", shape = ellipse] +_0_7 [label = "15 Range , input: [0, 1], rsm: [S_2, S_0]", shape = ellipse] +_0_8 [label = "16 Intermediate input: 0, rsm: S_1, input: [0, 0]", shape = plain] +_0_9 [label = "17 Terminal ')', input: [0, 1]", shape = rectangle] +_0_10 [label = "18 Range , input: [0, 0], rsm: [S_1, S_2]", shape = ellipse] +_0_11 [label = "19 Nonterminal S, input: [0, 0]", shape = invtrapezium] +_0_12 [label = "2 Epsilon RSM: S_0, input: [0, 0]", shape = invhouse] +_0_13 [label = "3 Intermediate input: 1, rsm: S_2, input: [0, 0]", shape = plain] +_0_14 [label = "4 Range , input: [0, 1], rsm: [S_0, S_2]", shape = ellipse] +_0_15 [label = "5 Range , input: [1, 0], rsm: [S_2, S_0]", shape = ellipse] +_0_16 [label = "6 Intermediate input: 0, rsm: S_1, input: [0, 1]", shape = plain] +_0_17 [label = "7 Terminal ')', input: [1, 0]", shape = rectangle] +_0_18 [label = "8 Range , input: [0, 0], rsm: [S_0, S_1]", shape = ellipse] +_0_19 [label = "9 Range , input: [0, 1], rsm: [S_1, S_2]", shape = ellipse] +_0_0->_0_1 +_0_1->_0_12 +_0_1->_0_13 +_0_3->_0_4 +_0_4->_0_5 +_0_5->_0_6 +_0_5->_0_7 +_0_6->_0_8 +_0_7->_0_9 +_0_8->_0_18 +_0_8->_0_10 +_0_10->_0_11 +_0_13->_0_14 +_0_13->_0_15 +_0_14->_0_16 +_0_15->_0_17 +_0_16->_0_18 +_0_16->_0_19 +_0_18->_0_2 +_0_19->_0_3 +} + +subgraph cluster_1{ +labelloc="t" +_1_0 [label = "0 Nonterminal S, input: [0, 1]", shape = invtrapezium] +_1_1 [label = "1 Range , input: [0, 1], rsm: [S_0, S_0]", shape = ellipse] +_1_2 [label = "10 Nonterminal S, input: [0, 0]", shape = invtrapezium] +_1_3 [label = "2 Intermediate input: 0, rsm: S_2, input: [0, 1]", shape = plain] +_1_4 [label = "3 Range , input: [0, 0], rsm: [S_0, S_2]", shape = ellipse] +_1_5 [label = "4 Range , input: [0, 1], rsm: [S_2, S_0]", shape = ellipse] +_1_6 [label = "5 Intermediate input: 0, rsm: S_1, input: [0, 0]", shape = plain] +_1_7 [label = "6 Terminal ')', input: [0, 1]", shape = rectangle] +_1_8 [label = "7 Range , input: [0, 0], rsm: [S_0, S_1]", shape = ellipse] +_1_9 [label = "8 Range , input: [0, 0], rsm: [S_1, S_2]", shape = ellipse] +_1_10 [label = "9 Terminal '(', input: [0, 0]", shape = rectangle] +_1_0->_1_1 +_1_1->_1_3 +_1_3->_1_4 +_1_3->_1_5 +_1_4->_1_6 +_1_5->_1_7 +_1_6->_1_8 +_1_6->_1_9 +_1_8->_1_10 +_1_9->_1_2 +} + +} diff --git a/test-shared/src/test/resources/benchmarks/LoopDyckGrammar/oneVertex/input.dot b/test-shared/src/test/resources/benchmarks/LoopDyckGrammar/oneVertex/input.dot new file mode 100644 index 000000000..21edd13ff --- /dev/null +++ b/test-shared/src/test/resources/benchmarks/LoopDyckGrammar/oneVertex/input.dot @@ -0,0 +1,6 @@ +digraph Input { + label="Two loops with common vertex, simple loop RSM for Dyck language" + start -> 0; + 0 -> 0 [label = "("]; + 0 -> 0 [label = ")"]; +} \ No newline at end of file diff --git a/test-shared/src/test/resources/benchmarks/LoopDyckGrammar/oneVertex/result.dot b/test-shared/src/test/resources/benchmarks/LoopDyckGrammar/oneVertex/result.dot new file mode 100644 index 000000000..4e0733b02 --- /dev/null +++ b/test-shared/src/test/resources/benchmarks/LoopDyckGrammar/oneVertex/result.dot @@ -0,0 +1,31 @@ +digraph g { +labelloc="t" +label="" +subgraph cluster_0{ +labelloc="t" +_0_0 [label = "0 Nonterminal S, input: [0, 0]", shape = invtrapezium] +_0_1 [label = "1 Range , input: [0, 0], rsm: [S_0, S_0]", shape = ellipse] +_0_2 [label = "10 Terminal '(', input: [0, 0]", shape = rectangle] +_0_3 [label = "11 Nonterminal S, input: [0, 0]", shape = invtrapezium] +_0_4 [label = "2 Epsilon RSM: S_0, input: [0, 0]", shape = invhouse] +_0_5 [label = "3 Intermediate input: 0, rsm: S_2, input: [0, 0]", shape = plain] +_0_6 [label = "4 Range , input: [0, 0], rsm: [S_0, S_2]", shape = ellipse] +_0_7 [label = "5 Range , input: [0, 0], rsm: [S_2, S_0]", shape = ellipse] +_0_8 [label = "6 Intermediate input: 0, rsm: S_1, input: [0, 0]", shape = plain] +_0_9 [label = "7 Terminal ')', input: [0, 0]", shape = rectangle] +_0_10 [label = "8 Range , input: [0, 0], rsm: [S_0, S_1]", shape = ellipse] +_0_11 [label = "9 Range , input: [0, 0], rsm: [S_1, S_2]", shape = ellipse] +_0_0->_0_1 +_0_1->_0_4 +_0_1->_0_5 +_0_5->_0_6 +_0_5->_0_7 +_0_6->_0_8 +_0_7->_0_9 +_0_8->_0_10 +_0_8->_0_11 +_0_10->_0_2 +_0_11->_0_3 +} + +} diff --git a/test-shared/src/test/resources/benchmarks/LoopDyckGrammar/secondWorstCase/input.dot b/test-shared/src/test/resources/benchmarks/LoopDyckGrammar/secondWorstCase/input.dot new file mode 100644 index 000000000..2a79063bc --- /dev/null +++ b/test-shared/src/test/resources/benchmarks/LoopDyckGrammar/secondWorstCase/input.dot @@ -0,0 +1,10 @@ +digraph Input { + label="Second worst case, simple loop RSM for Dyck language" + start -> 0; + 0 -> 1 [label = ")"]; + 1 -> 2 [label = ")"]; + 2 -> 0 [label = ")"]; + + 0 -> 3 [label = "("]; + 3 -> 0 [label = "("]; +} \ No newline at end of file diff --git a/test-shared/src/test/resources/benchmarks/LoopDyckGrammar/secondWorstCase/result.dot b/test-shared/src/test/resources/benchmarks/LoopDyckGrammar/secondWorstCase/result.dot new file mode 100644 index 000000000..4dc0db29d --- /dev/null +++ b/test-shared/src/test/resources/benchmarks/LoopDyckGrammar/secondWorstCase/result.dot @@ -0,0 +1,349 @@ +digraph g { +labelloc="t" +label="" +subgraph cluster_0{ +labelloc="t" +_0_0 [label = "0 Nonterminal S, input: [0, 0]", shape = invtrapezium] +_0_1 [label = "1 Range , input: [0, 0], rsm: [S_0, S_0]", shape = ellipse] +_0_2 [label = "10 Terminal '(', input: [0, 3]", shape = rectangle] +_0_3 [label = "11 Nonterminal S, input: [3, 2]", shape = invtrapezium] +_0_4 [label = "12 Range , input: [3, 2], rsm: [S_0, S_0]", shape = ellipse] +_0_5 [label = "13 Intermediate input: 1, rsm: S_2, input: [3, 2]", shape = plain] +_0_6 [label = "14 Range , input: [3, 1], rsm: [S_0, S_2]", shape = ellipse] +_0_7 [label = "15 Range , input: [1, 2], rsm: [S_2, S_0]", shape = ellipse] +_0_8 [label = "16 Intermediate input: 3, rsm: S_1, input: [3, 1]", shape = plain] +_0_9 [label = "17 Intermediate input: 0, rsm: S_1, input: [3, 1]", shape = plain] +_0_10 [label = "18 Terminal ')', input: [1, 2]", shape = rectangle] +_0_11 [label = "19 Range , input: [3, 3], rsm: [S_0, S_1]", shape = ellipse] +_0_12 [label = "2 Epsilon RSM: S_0, input: [0, 0]", shape = invhouse] +_0_13 [label = "20 Range , input: [3, 1], rsm: [S_1, S_2]", shape = ellipse] +_0_14 [label = "21 Range , input: [3, 0], rsm: [S_0, S_1]", shape = ellipse] +_0_15 [label = "22 Range , input: [0, 1], rsm: [S_1, S_2]", shape = ellipse] +_0_16 [label = "23 Intermediate input: 0, rsm: S_0, input: [3, 3]", shape = plain] +_0_17 [label = "24 Nonterminal S, input: [3, 1]", shape = invtrapezium] +_0_18 [label = "25 Terminal '(', input: [3, 0]", shape = rectangle] +_0_19 [label = "26 Nonterminal S, input: [0, 1]", shape = invtrapezium] +_0_20 [label = "27 Range , input: [3, 0], rsm: [S_0, S_0]", shape = ellipse] +_0_21 [label = "28 Range , input: [3, 1], rsm: [S_0, S_0]", shape = ellipse] +_0_22 [label = "29 Range , input: [0, 1], rsm: [S_0, S_0]", shape = ellipse] +_0_23 [label = "3 Intermediate input: 2, rsm: S_2, input: [0, 0]", shape = plain] +_0_24 [label = "30 Intermediate input: 2, rsm: S_2, input: [3, 0]", shape = plain] +_0_25 [label = "31 Intermediate input: 0, rsm: S_2, input: [3, 1]", shape = plain] +_0_26 [label = "32 Intermediate input: 0, rsm: S_2, input: [0, 1]", shape = plain] +_0_27 [label = "33 Range , input: [3, 2], rsm: [S_0, S_2]", shape = ellipse] +_0_28 [label = "34 Range , input: [3, 0], rsm: [S_0, S_2]", shape = ellipse] +_0_29 [label = "35 Range , input: [0, 1], rsm: [S_2, S_0]", shape = ellipse] +_0_30 [label = "36 Range , input: [0, 0], rsm: [S_0, S_2]", shape = ellipse] +_0_31 [label = "37 Intermediate input: 0, rsm: S_1, input: [3, 2]", shape = plain] +_0_32 [label = "38 Intermediate input: 3, rsm: S_1, input: [3, 2]", shape = plain] +_0_33 [label = "39 Intermediate input: 0, rsm: S_1, input: [3, 0]", shape = plain] +_0_34 [label = "4 Range , input: [0, 2], rsm: [S_0, S_2]", shape = ellipse] +_0_35 [label = "40 Intermediate input: 3, rsm: S_1, input: [3, 0]", shape = plain] +_0_36 [label = "41 Terminal ')', input: [0, 1]", shape = rectangle] +_0_37 [label = "42 Intermediate input: 3, rsm: S_1, input: [0, 0]", shape = plain] +_0_38 [label = "43 Range , input: [0, 2], rsm: [S_1, S_2]", shape = ellipse] +_0_39 [label = "44 Range , input: [0, 0], rsm: [S_1, S_2]", shape = ellipse] +_0_40 [label = "45 Range , input: [3, 0], rsm: [S_1, S_2]", shape = ellipse] +_0_41 [label = "46 Nonterminal S, input: [0, 2]", shape = invtrapezium] +_0_42 [label = "47 Nonterminal S, input: [0, 0]", shape = invtrapezium] +_0_43 [label = "48 Nonterminal S, input: [3, 0]", shape = invtrapezium] +_0_44 [label = "49 Range , input: [0, 2], rsm: [S_0, S_0]", shape = ellipse] +_0_45 [label = "5 Range , input: [2, 0], rsm: [S_2, S_0]", shape = ellipse] +_0_46 [label = "50 Intermediate input: 1, rsm: S_2, input: [0, 2]", shape = plain] +_0_47 [label = "51 Range , input: [0, 1], rsm: [S_0, S_2]", shape = ellipse] +_0_48 [label = "52 Intermediate input: 3, rsm: S_1, input: [0, 1]", shape = plain] +_0_49 [label = "6 Intermediate input: 3, rsm: S_1, input: [0, 2]", shape = plain] +_0_50 [label = "7 Terminal ')', input: [2, 0]", shape = rectangle] +_0_51 [label = "8 Range , input: [0, 3], rsm: [S_0, S_1]", shape = ellipse] +_0_52 [label = "9 Range , input: [3, 2], rsm: [S_1, S_2]", shape = ellipse] +_0_0->_0_1 +_0_1->_0_12 +_0_1->_0_23 +_0_3->_0_4 +_0_4->_0_5 +_0_5->_0_6 +_0_5->_0_7 +_0_6->_0_8 +_0_6->_0_9 +_0_7->_0_10 +_0_8->_0_11 +_0_8->_0_13 +_0_9->_0_14 +_0_9->_0_15 +_0_11->_0_16 +_0_13->_0_17 +_0_14->_0_18 +_0_15->_0_19 +_0_16->_0_20 +_0_16->_0_51 +_0_17->_0_21 +_0_19->_0_22 +_0_20->_0_24 +_0_21->_0_25 +_0_22->_0_26 +_0_23->_0_34 +_0_23->_0_45 +_0_24->_0_27 +_0_24->_0_45 +_0_25->_0_28 +_0_25->_0_29 +_0_26->_0_30 +_0_26->_0_29 +_0_27->_0_31 +_0_27->_0_32 +_0_28->_0_33 +_0_28->_0_35 +_0_29->_0_36 +_0_30->_0_37 +_0_31->_0_14 +_0_31->_0_38 +_0_32->_0_11 +_0_32->_0_52 +_0_33->_0_14 +_0_33->_0_39 +_0_34->_0_49 +_0_35->_0_11 +_0_35->_0_40 +_0_37->_0_51 +_0_37->_0_40 +_0_38->_0_41 +_0_39->_0_42 +_0_40->_0_43 +_0_41->_0_44 +_0_43->_0_20 +_0_44->_0_46 +_0_45->_0_50 +_0_46->_0_47 +_0_46->_0_7 +_0_47->_0_48 +_0_48->_0_51 +_0_48->_0_13 +_0_49->_0_51 +_0_49->_0_52 +_0_51->_0_2 +_0_52->_0_3 +} + +subgraph cluster_1{ +labelloc="t" +_1_0 [label = "0 Nonterminal S, input: [0, 1]", shape = invtrapezium] +_1_1 [label = "1 Range , input: [0, 1], rsm: [S_0, S_0]", shape = ellipse] +_1_2 [label = "10 Nonterminal S, input: [3, 0]", shape = invtrapezium] +_1_3 [label = "11 Range , input: [3, 0], rsm: [S_0, S_0]", shape = ellipse] +_1_4 [label = "12 Intermediate input: 2, rsm: S_2, input: [3, 0]", shape = plain] +_1_5 [label = "13 Range , input: [3, 2], rsm: [S_0, S_2]", shape = ellipse] +_1_6 [label = "14 Range , input: [2, 0], rsm: [S_2, S_0]", shape = ellipse] +_1_7 [label = "15 Intermediate input: 0, rsm: S_1, input: [3, 2]", shape = plain] +_1_8 [label = "16 Intermediate input: 3, rsm: S_1, input: [3, 2]", shape = plain] +_1_9 [label = "17 Terminal ')', input: [2, 0]", shape = rectangle] +_1_10 [label = "18 Range , input: [3, 0], rsm: [S_0, S_1]", shape = ellipse] +_1_11 [label = "19 Range , input: [0, 2], rsm: [S_1, S_2]", shape = ellipse] +_1_12 [label = "2 Intermediate input: 0, rsm: S_2, input: [0, 1]", shape = plain] +_1_13 [label = "20 Range , input: [3, 3], rsm: [S_0, S_1]", shape = ellipse] +_1_14 [label = "21 Range , input: [3, 2], rsm: [S_1, S_2]", shape = ellipse] +_1_15 [label = "22 Terminal '(', input: [3, 0]", shape = rectangle] +_1_16 [label = "23 Nonterminal S, input: [0, 2]", shape = invtrapezium] +_1_17 [label = "24 Intermediate input: 0, rsm: S_0, input: [3, 3]", shape = plain] +_1_18 [label = "25 Nonterminal S, input: [3, 2]", shape = invtrapezium] +_1_19 [label = "26 Range , input: [0, 2], rsm: [S_0, S_0]", shape = ellipse] +_1_20 [label = "27 Range , input: [3, 2], rsm: [S_0, S_0]", shape = ellipse] +_1_21 [label = "28 Intermediate input: 1, rsm: S_2, input: [0, 2]", shape = plain] +_1_22 [label = "29 Intermediate input: 1, rsm: S_2, input: [3, 2]", shape = plain] +_1_23 [label = "3 Range , input: [0, 0], rsm: [S_0, S_2]", shape = ellipse] +_1_24 [label = "30 Range , input: [0, 1], rsm: [S_0, S_2]", shape = ellipse] +_1_25 [label = "31 Range , input: [1, 2], rsm: [S_2, S_0]", shape = ellipse] +_1_26 [label = "32 Range , input: [3, 1], rsm: [S_0, S_2]", shape = ellipse] +_1_27 [label = "33 Intermediate input: 3, rsm: S_1, input: [0, 1]", shape = plain] +_1_28 [label = "34 Terminal ')', input: [1, 2]", shape = rectangle] +_1_29 [label = "35 Intermediate input: 3, rsm: S_1, input: [3, 1]", shape = plain] +_1_30 [label = "36 Intermediate input: 0, rsm: S_1, input: [3, 1]", shape = plain] +_1_31 [label = "37 Range , input: [3, 1], rsm: [S_1, S_2]", shape = ellipse] +_1_32 [label = "38 Range , input: [0, 1], rsm: [S_1, S_2]", shape = ellipse] +_1_33 [label = "39 Nonterminal S, input: [3, 1]", shape = invtrapezium] +_1_34 [label = "4 Range , input: [0, 1], rsm: [S_2, S_0]", shape = ellipse] +_1_35 [label = "40 Nonterminal S, input: [0, 1]", shape = invtrapezium] +_1_36 [label = "41 Range , input: [3, 1], rsm: [S_0, S_0]", shape = ellipse] +_1_37 [label = "42 Intermediate input: 0, rsm: S_2, input: [3, 1]", shape = plain] +_1_38 [label = "43 Range , input: [3, 0], rsm: [S_0, S_2]", shape = ellipse] +_1_39 [label = "44 Intermediate input: 0, rsm: S_1, input: [3, 0]", shape = plain] +_1_40 [label = "45 Intermediate input: 3, rsm: S_1, input: [3, 0]", shape = plain] +_1_41 [label = "46 Range , input: [0, 0], rsm: [S_1, S_2]", shape = ellipse] +_1_42 [label = "47 Nonterminal S, input: [0, 0]", shape = invtrapezium] +_1_43 [label = "5 Intermediate input: 3, rsm: S_1, input: [0, 0]", shape = plain] +_1_44 [label = "6 Terminal ')', input: [0, 1]", shape = rectangle] +_1_45 [label = "7 Range , input: [0, 3], rsm: [S_0, S_1]", shape = ellipse] +_1_46 [label = "8 Range , input: [3, 0], rsm: [S_1, S_2]", shape = ellipse] +_1_47 [label = "9 Terminal '(', input: [0, 3]", shape = rectangle] +_1_0->_1_1 +_1_1->_1_12 +_1_2->_1_3 +_1_3->_1_4 +_1_4->_1_5 +_1_4->_1_6 +_1_5->_1_7 +_1_5->_1_8 +_1_6->_1_9 +_1_7->_1_10 +_1_7->_1_11 +_1_8->_1_13 +_1_8->_1_14 +_1_10->_1_15 +_1_11->_1_16 +_1_12->_1_23 +_1_12->_1_34 +_1_13->_1_17 +_1_14->_1_18 +_1_16->_1_19 +_1_17->_1_3 +_1_17->_1_45 +_1_18->_1_20 +_1_19->_1_21 +_1_20->_1_22 +_1_21->_1_24 +_1_21->_1_25 +_1_22->_1_26 +_1_22->_1_25 +_1_23->_1_43 +_1_24->_1_27 +_1_25->_1_28 +_1_26->_1_29 +_1_26->_1_30 +_1_27->_1_45 +_1_27->_1_31 +_1_29->_1_13 +_1_29->_1_31 +_1_30->_1_10 +_1_30->_1_32 +_1_31->_1_33 +_1_32->_1_35 +_1_33->_1_36 +_1_34->_1_44 +_1_35->_1_1 +_1_36->_1_37 +_1_37->_1_38 +_1_37->_1_34 +_1_38->_1_39 +_1_38->_1_40 +_1_39->_1_10 +_1_39->_1_41 +_1_40->_1_13 +_1_40->_1_46 +_1_41->_1_42 +_1_43->_1_45 +_1_43->_1_46 +_1_45->_1_47 +_1_46->_1_2 +} + +subgraph cluster_2{ +labelloc="t" +_2_0 [label = "0 Nonterminal S, input: [0, 2]", shape = invtrapezium] +_2_1 [label = "1 Range , input: [0, 2], rsm: [S_0, S_0]", shape = ellipse] +_2_2 [label = "10 Nonterminal S, input: [3, 1]", shape = invtrapezium] +_2_3 [label = "11 Range , input: [3, 1], rsm: [S_0, S_0]", shape = ellipse] +_2_4 [label = "12 Intermediate input: 0, rsm: S_2, input: [3, 1]", shape = plain] +_2_5 [label = "13 Range , input: [3, 0], rsm: [S_0, S_2]", shape = ellipse] +_2_6 [label = "14 Range , input: [0, 1], rsm: [S_2, S_0]", shape = ellipse] +_2_7 [label = "15 Intermediate input: 0, rsm: S_1, input: [3, 0]", shape = plain] +_2_8 [label = "16 Intermediate input: 3, rsm: S_1, input: [3, 0]", shape = plain] +_2_9 [label = "17 Terminal ')', input: [0, 1]", shape = rectangle] +_2_10 [label = "18 Range , input: [3, 0], rsm: [S_0, S_1]", shape = ellipse] +_2_11 [label = "19 Range , input: [0, 0], rsm: [S_1, S_2]", shape = ellipse] +_2_12 [label = "2 Intermediate input: 1, rsm: S_2, input: [0, 2]", shape = plain] +_2_13 [label = "20 Range , input: [3, 3], rsm: [S_0, S_1]", shape = ellipse] +_2_14 [label = "21 Range , input: [3, 0], rsm: [S_1, S_2]", shape = ellipse] +_2_15 [label = "22 Terminal '(', input: [3, 0]", shape = rectangle] +_2_16 [label = "23 Nonterminal S, input: [0, 0]", shape = invtrapezium] +_2_17 [label = "24 Intermediate input: 0, rsm: S_0, input: [3, 3]", shape = plain] +_2_18 [label = "25 Nonterminal S, input: [3, 0]", shape = invtrapezium] +_2_19 [label = "26 Range , input: [3, 0], rsm: [S_0, S_0]", shape = ellipse] +_2_20 [label = "27 Intermediate input: 2, rsm: S_2, input: [3, 0]", shape = plain] +_2_21 [label = "28 Range , input: [3, 2], rsm: [S_0, S_2]", shape = ellipse] +_2_22 [label = "29 Range , input: [2, 0], rsm: [S_2, S_0]", shape = ellipse] +_2_23 [label = "3 Range , input: [0, 1], rsm: [S_0, S_2]", shape = ellipse] +_2_24 [label = "30 Intermediate input: 0, rsm: S_1, input: [3, 2]", shape = plain] +_2_25 [label = "31 Intermediate input: 3, rsm: S_1, input: [3, 2]", shape = plain] +_2_26 [label = "32 Terminal ')', input: [2, 0]", shape = rectangle] +_2_27 [label = "33 Range , input: [0, 2], rsm: [S_1, S_2]", shape = ellipse] +_2_28 [label = "34 Range , input: [3, 2], rsm: [S_1, S_2]", shape = ellipse] +_2_29 [label = "35 Nonterminal S, input: [0, 2]", shape = invtrapezium] +_2_30 [label = "36 Nonterminal S, input: [3, 2]", shape = invtrapezium] +_2_31 [label = "37 Range , input: [3, 2], rsm: [S_0, S_0]", shape = ellipse] +_2_32 [label = "38 Intermediate input: 1, rsm: S_2, input: [3, 2]", shape = plain] +_2_33 [label = "39 Range , input: [3, 1], rsm: [S_0, S_2]", shape = ellipse] +_2_34 [label = "4 Range , input: [1, 2], rsm: [S_2, S_0]", shape = ellipse] +_2_35 [label = "40 Intermediate input: 3, rsm: S_1, input: [3, 1]", shape = plain] +_2_36 [label = "41 Intermediate input: 0, rsm: S_1, input: [3, 1]", shape = plain] +_2_37 [label = "42 Range , input: [0, 1], rsm: [S_1, S_2]", shape = ellipse] +_2_38 [label = "43 Nonterminal S, input: [0, 1]", shape = invtrapezium] +_2_39 [label = "44 Range , input: [0, 1], rsm: [S_0, S_0]", shape = ellipse] +_2_40 [label = "45 Intermediate input: 0, rsm: S_2, input: [0, 1]", shape = plain] +_2_41 [label = "46 Range , input: [0, 0], rsm: [S_0, S_2]", shape = ellipse] +_2_42 [label = "47 Intermediate input: 3, rsm: S_1, input: [0, 0]", shape = plain] +_2_43 [label = "5 Intermediate input: 3, rsm: S_1, input: [0, 1]", shape = plain] +_2_44 [label = "6 Terminal ')', input: [1, 2]", shape = rectangle] +_2_45 [label = "7 Range , input: [0, 3], rsm: [S_0, S_1]", shape = ellipse] +_2_46 [label = "8 Range , input: [3, 1], rsm: [S_1, S_2]", shape = ellipse] +_2_47 [label = "9 Terminal '(', input: [0, 3]", shape = rectangle] +_2_0->_2_1 +_2_1->_2_12 +_2_2->_2_3 +_2_3->_2_4 +_2_4->_2_5 +_2_4->_2_6 +_2_5->_2_7 +_2_5->_2_8 +_2_6->_2_9 +_2_7->_2_10 +_2_7->_2_11 +_2_8->_2_13 +_2_8->_2_14 +_2_10->_2_15 +_2_11->_2_16 +_2_12->_2_23 +_2_12->_2_34 +_2_13->_2_17 +_2_14->_2_18 +_2_17->_2_19 +_2_17->_2_45 +_2_18->_2_19 +_2_19->_2_20 +_2_20->_2_21 +_2_20->_2_22 +_2_21->_2_24 +_2_21->_2_25 +_2_22->_2_26 +_2_23->_2_43 +_2_24->_2_10 +_2_24->_2_27 +_2_25->_2_13 +_2_25->_2_28 +_2_27->_2_29 +_2_28->_2_30 +_2_29->_2_1 +_2_30->_2_31 +_2_31->_2_32 +_2_32->_2_33 +_2_32->_2_34 +_2_33->_2_35 +_2_33->_2_36 +_2_34->_2_44 +_2_35->_2_13 +_2_35->_2_46 +_2_36->_2_10 +_2_36->_2_37 +_2_37->_2_38 +_2_38->_2_39 +_2_39->_2_40 +_2_40->_2_41 +_2_40->_2_6 +_2_41->_2_42 +_2_42->_2_45 +_2_42->_2_14 +_2_43->_2_45 +_2_43->_2_46 +_2_45->_2_47 +_2_46->_2_2 +} + +} diff --git a/test-shared/src/test/resources/benchmarks/LoopDyckGrammar/twoPairs/input.dot b/test-shared/src/test/resources/benchmarks/LoopDyckGrammar/twoPairs/input.dot new file mode 100644 index 000000000..385ff2cdb --- /dev/null +++ b/test-shared/src/test/resources/benchmarks/LoopDyckGrammar/twoPairs/input.dot @@ -0,0 +1,8 @@ +digraph Input { + label="Two concatenated linear pairs of brackets, simple loop RSM for Dyck language" + start -> 0; + 0 -> 1 [label = "("]; + 1 -> 2 [label = ")"]; + 2 -> 3 [label = "("]; + 3 -> 4 [label = ")"]; +} \ No newline at end of file diff --git a/test-shared/src/test/resources/benchmarks/LoopDyckGrammar/twoPairs/result.dot b/test-shared/src/test/resources/benchmarks/LoopDyckGrammar/twoPairs/result.dot new file mode 100644 index 000000000..af1a0bd98 --- /dev/null +++ b/test-shared/src/test/resources/benchmarks/LoopDyckGrammar/twoPairs/result.dot @@ -0,0 +1,99 @@ +digraph g { +labelloc="t" +label="" +subgraph cluster_0{ +labelloc="t" +_0_0 [label = "0 Nonterminal S, input: [0, 0]", shape = invtrapezium] +_0_1 [label = "1 Range , input: [0, 0], rsm: [S_0, S_0]", shape = ellipse] +_0_2 [label = "2 Epsilon RSM: S_0, input: [0, 0]", shape = invhouse] +_0_0->_0_1 +_0_1->_0_2 +} + +subgraph cluster_1{ +labelloc="t" +_1_0 [label = "0 Nonterminal S, input: [0, 2]", shape = invtrapezium] +_1_1 [label = "1 Range , input: [0, 2], rsm: [S_0, S_0]", shape = ellipse] +_1_2 [label = "10 Nonterminal S, input: [1, 1]", shape = invtrapezium] +_1_3 [label = "11 Range , input: [1, 1], rsm: [S_0, S_0]", shape = ellipse] +_1_4 [label = "12 Epsilon RSM: S_0, input: [1, 1]", shape = invhouse] +_1_5 [label = "2 Intermediate input: 1, rsm: S_2, input: [0, 2]", shape = plain] +_1_6 [label = "3 Range , input: [0, 1], rsm: [S_0, S_2]", shape = ellipse] +_1_7 [label = "4 Range , input: [1, 2], rsm: [S_2, S_0]", shape = ellipse] +_1_8 [label = "5 Intermediate input: 1, rsm: S_1, input: [0, 1]", shape = plain] +_1_9 [label = "6 Terminal ')', input: [1, 2]", shape = rectangle] +_1_10 [label = "7 Range , input: [0, 1], rsm: [S_0, S_1]", shape = ellipse] +_1_11 [label = "8 Range , input: [1, 1], rsm: [S_1, S_2]", shape = ellipse] +_1_12 [label = "9 Terminal '(', input: [0, 1]", shape = rectangle] +_1_0->_1_1 +_1_1->_1_5 +_1_2->_1_3 +_1_3->_1_4 +_1_5->_1_6 +_1_5->_1_7 +_1_6->_1_8 +_1_7->_1_9 +_1_8->_1_10 +_1_8->_1_11 +_1_10->_1_12 +_1_11->_1_2 +} + +subgraph cluster_2{ +labelloc="t" +_2_0 [label = "0 Nonterminal S, input: [0, 4]", shape = invtrapezium] +_2_1 [label = "1 Range , input: [0, 4], rsm: [S_0, S_0]", shape = ellipse] +_2_2 [label = "10 Nonterminal S, input: [3, 3]", shape = invtrapezium] +_2_3 [label = "11 Range , input: [0, 2], rsm: [S_0, S_0]", shape = ellipse] +_2_4 [label = "12 Range , input: [2, 3], rsm: [S_0, S_1]", shape = ellipse] +_2_5 [label = "13 Range , input: [3, 3], rsm: [S_0, S_0]", shape = ellipse] +_2_6 [label = "14 Intermediate input: 1, rsm: S_2, input: [0, 2]", shape = plain] +_2_7 [label = "15 Terminal '(', input: [2, 3]", shape = rectangle] +_2_8 [label = "16 Epsilon RSM: S_0, input: [3, 3]", shape = invhouse] +_2_9 [label = "17 Range , input: [0, 1], rsm: [S_0, S_2]", shape = ellipse] +_2_10 [label = "18 Range , input: [1, 2], rsm: [S_2, S_0]", shape = ellipse] +_2_11 [label = "19 Intermediate input: 1, rsm: S_1, input: [0, 1]", shape = plain] +_2_12 [label = "2 Intermediate input: 3, rsm: S_2, input: [0, 4]", shape = plain] +_2_13 [label = "20 Terminal ')', input: [1, 2]", shape = rectangle] +_2_14 [label = "21 Range , input: [0, 1], rsm: [S_0, S_1]", shape = ellipse] +_2_15 [label = "22 Range , input: [1, 1], rsm: [S_1, S_2]", shape = ellipse] +_2_16 [label = "23 Terminal '(', input: [0, 1]", shape = rectangle] +_2_17 [label = "24 Nonterminal S, input: [1, 1]", shape = invtrapezium] +_2_18 [label = "25 Range , input: [1, 1], rsm: [S_0, S_0]", shape = ellipse] +_2_19 [label = "26 Epsilon RSM: S_0, input: [1, 1]", shape = invhouse] +_2_20 [label = "3 Range , input: [0, 3], rsm: [S_0, S_2]", shape = ellipse] +_2_21 [label = "4 Range , input: [3, 4], rsm: [S_2, S_0]", shape = ellipse] +_2_22 [label = "5 Intermediate input: 3, rsm: S_1, input: [0, 3]", shape = plain] +_2_23 [label = "6 Terminal ')', input: [3, 4]", shape = rectangle] +_2_24 [label = "7 Range , input: [0, 3], rsm: [S_0, S_1]", shape = ellipse] +_2_25 [label = "8 Range , input: [3, 3], rsm: [S_1, S_2]", shape = ellipse] +_2_26 [label = "9 Intermediate input: 2, rsm: S_0, input: [0, 3]", shape = plain] +_2_0->_2_1 +_2_1->_2_12 +_2_2->_2_5 +_2_3->_2_6 +_2_4->_2_7 +_2_5->_2_8 +_2_6->_2_9 +_2_6->_2_10 +_2_9->_2_11 +_2_10->_2_13 +_2_11->_2_14 +_2_11->_2_15 +_2_12->_2_20 +_2_12->_2_21 +_2_14->_2_16 +_2_15->_2_17 +_2_17->_2_18 +_2_18->_2_19 +_2_20->_2_22 +_2_21->_2_23 +_2_22->_2_24 +_2_22->_2_25 +_2_24->_2_26 +_2_25->_2_2 +_2_26->_2_3 +_2_26->_2_4 +} + +} diff --git a/test-shared/src/test/resources/benchmarks/StrangeDyckGrammar/linear/input.dot b/test-shared/src/test/resources/benchmarks/StrangeDyckGrammar/linear/input.dot new file mode 100644 index 000000000..2e11c7190 --- /dev/null +++ b/test-shared/src/test/resources/benchmarks/StrangeDyckGrammar/linear/input.dot @@ -0,0 +1,6 @@ +digraph Input { + start -> 0; + 0 -> 1 [label = "("]; + 1 -> 2 [label = "a"]; + 2 -> 3 [label = ")"]; +} \ No newline at end of file diff --git a/test-shared/src/test/resources/benchmarks/StrangeDyckGrammar/linear/result.dot b/test-shared/src/test/resources/benchmarks/StrangeDyckGrammar/linear/result.dot new file mode 100644 index 000000000..8d3b00501 --- /dev/null +++ b/test-shared/src/test/resources/benchmarks/StrangeDyckGrammar/linear/result.dot @@ -0,0 +1,33 @@ +digraph g { +labelloc="t" +label="" +subgraph cluster_0{ +labelloc="t" +_0_0 [label = "0 Nonterminal S, input: [0, 3]", shape = invtrapezium] +_0_1 [label = "1 Range , input: [0, 3], rsm: [S_0, S_2]", shape = ellipse] +_0_2 [label = "10 Nonterminal S, input: [1, 2]", shape = invtrapezium] +_0_3 [label = "11 Range , input: [1, 2], rsm: [S_0, S_2]", shape = ellipse] +_0_4 [label = "12 Terminal 'a', input: [1, 2]", shape = rectangle] +_0_5 [label = "2 Intermediate input: 2, rsm: S_3, input: [0, 3]", shape = plain] +_0_6 [label = "3 Range , input: [0, 2], rsm: [S_0, S_3]", shape = ellipse] +_0_7 [label = "4 Range , input: [2, 3], rsm: [S_3, S_2]", shape = ellipse] +_0_8 [label = "5 Intermediate input: 1, rsm: S_1, input: [0, 2]", shape = plain] +_0_9 [label = "6 Terminal ')', input: [2, 3]", shape = rectangle] +_0_10 [label = "7 Range , input: [0, 1], rsm: [S_0, S_1]", shape = ellipse] +_0_11 [label = "8 Range , input: [1, 2], rsm: [S_1, S_3]", shape = ellipse] +_0_12 [label = "9 Terminal '(', input: [0, 1]", shape = rectangle] +_0_0->_0_1 +_0_1->_0_5 +_0_2->_0_3 +_0_3->_0_4 +_0_5->_0_6 +_0_5->_0_7 +_0_6->_0_8 +_0_7->_0_9 +_0_8->_0_10 +_0_8->_0_11 +_0_10->_0_12 +_0_11->_0_2 +} + +} diff --git a/test-shared/src/test/resources/benchmarks/StrangeDyckGrammar/nothingPath/input.dot b/test-shared/src/test/resources/benchmarks/StrangeDyckGrammar/nothingPath/input.dot new file mode 100644 index 000000000..c7cc8faa7 --- /dev/null +++ b/test-shared/src/test/resources/benchmarks/StrangeDyckGrammar/nothingPath/input.dot @@ -0,0 +1,6 @@ +digraph Input { + start -> 0; + 0 -> 1 [label = "("]; + 4 -> 2 [label = "a"]; + 2 -> 3 [label = ")"]; +} \ No newline at end of file diff --git a/test-shared/src/test/resources/benchmarks/StrangeDyckGrammar/nothingPath/result.dot b/test-shared/src/test/resources/benchmarks/StrangeDyckGrammar/nothingPath/result.dot new file mode 100644 index 000000000..fab3d9d46 --- /dev/null +++ b/test-shared/src/test/resources/benchmarks/StrangeDyckGrammar/nothingPath/result.dot @@ -0,0 +1,4 @@ +digraph g { +labelloc="t" +label="" +} diff --git a/test-shared/src/test/resources/correctness/tree/ABGrammar/ambig/input.dot b/test-shared/src/test/resources/correctness/tree/ABGrammar/ambig/input.dot new file mode 100644 index 000000000..f97b01474 --- /dev/null +++ b/test-shared/src/test/resources/correctness/tree/ABGrammar/ambig/input.dot @@ -0,0 +1,4 @@ +digraph Input { + start -> 0; + 0 -> 1 [label = "a"]; +} \ No newline at end of file diff --git a/test-shared/src/test/resources/correctness/tree/ABGrammar/ambig/result.dot b/test-shared/src/test/resources/correctness/tree/ABGrammar/ambig/result.dot new file mode 100644 index 000000000..ae31e2147 --- /dev/null +++ b/test-shared/src/test/resources/correctness/tree/ABGrammar/ambig/result.dot @@ -0,0 +1,26 @@ +digraph g { +labelloc="t" +label="" +subgraph cluster_0{ +labelloc="t" +_0_0 [label = "0 Nonterminal S, input: [0, 1]", shape = invtrapezium] +_0_1 [label = "1 Range , input: [0, 1], rsm: [S_0, S_1]", shape = ellipse] +_0_2 [label = "2 Nonterminal B, input: [0, 1]", shape = invtrapezium] +_0_3 [label = "3 Nonterminal A, input: [0, 1]", shape = invtrapezium] +_0_4 [label = "4 Range , input: [0, 1], rsm: [B_0, B_1]", shape = ellipse] +_0_5 [label = "5 Range , input: [0, 1], rsm: [A_0, A_1]", shape = ellipse] +_0_6 [label = "6 Nonterminal C, input: [0, 1]", shape = invtrapezium] +_0_7 [label = "7 Terminal 'a', input: [0, 1]", shape = rectangle] +_0_8 [label = "8 Range , input: [0, 1], rsm: [C_0, C_1]", shape = ellipse] +_0_0->_0_1 +_0_1->_0_2 +_0_1->_0_3 +_0_2->_0_4 +_0_3->_0_5 +_0_4->_0_6 +_0_5->_0_7 +_0_6->_0_8 +_0_8->_0_7 +} + +} diff --git a/test-shared/src/test/resources/correctness/tree/AmbiguousAStar1Grammar/simple/input.dot b/test-shared/src/test/resources/correctness/tree/AmbiguousAStar1Grammar/simple/input.dot new file mode 100644 index 000000000..2ff53cdf3 --- /dev/null +++ b/test-shared/src/test/resources/correctness/tree/AmbiguousAStar1Grammar/simple/input.dot @@ -0,0 +1,6 @@ +digraph Input { + start -> 0; + 0 -> 1 [label = "a"]; + 1 -> 2 [label = "a"]; + 2 -> 3 [label = "a"]; +} \ No newline at end of file diff --git a/test-shared/src/test/resources/correctness/tree/AmbiguousAStar1Grammar/simple/result.dot b/test-shared/src/test/resources/correctness/tree/AmbiguousAStar1Grammar/simple/result.dot new file mode 100644 index 000000000..bf9dfc78e --- /dev/null +++ b/test-shared/src/test/resources/correctness/tree/AmbiguousAStar1Grammar/simple/result.dot @@ -0,0 +1,16 @@ +digraph g { +labelloc="t" +label="" +subgraph cluster_0{ +labelloc="t" +_0_0 [label = "0 Nonterminal S, input: [0, 1]", shape = invtrapezium] +_0_1 [label = "1 Range , input: [0, 1], rsm: [S_0, S_1]", shape = ellipse] +_0_2 [label = "2 Terminal 'a', input: [0, 1]", shape = rectangle] +_0_3 [label = "3 Nonterminal S, input: [0, 1]", shape = invtrapezium] +_0_0->_0_1 +_0_1->_0_2 +_0_1->_0_3 +_0_3->_0_1 +} + +} diff --git a/test-shared/src/test/resources/correctness/tree/AmbiguousAStar2Grammar/simple/input.dot b/test-shared/src/test/resources/correctness/tree/AmbiguousAStar2Grammar/simple/input.dot new file mode 100644 index 000000000..2ff53cdf3 --- /dev/null +++ b/test-shared/src/test/resources/correctness/tree/AmbiguousAStar2Grammar/simple/input.dot @@ -0,0 +1,6 @@ +digraph Input { + start -> 0; + 0 -> 1 [label = "a"]; + 1 -> 2 [label = "a"]; + 2 -> 3 [label = "a"]; +} \ No newline at end of file diff --git a/test-shared/src/test/resources/correctness/tree/AmbiguousAStar2Grammar/simple/result.dot b/test-shared/src/test/resources/correctness/tree/AmbiguousAStar2Grammar/simple/result.dot new file mode 100644 index 000000000..cfe4acabd --- /dev/null +++ b/test-shared/src/test/resources/correctness/tree/AmbiguousAStar2Grammar/simple/result.dot @@ -0,0 +1,96 @@ +digraph g { +labelloc="t" +label="" +subgraph cluster_0{ +labelloc="t" +_0_0 [label = "0 Nonterminal S, input: [0, 1]", shape = invtrapezium] +_0_1 [label = "1 Range , input: [0, 1], rsm: [S_0, S_1]", shape = ellipse] +_0_2 [label = "2 Terminal 'a', input: [0, 1]", shape = rectangle] +_0_0->_0_1 +_0_1->_0_2 +} + +subgraph cluster_1{ +labelloc="t" +_1_0 [label = "0 Nonterminal S, input: [0, 2]", shape = invtrapezium] +_1_1 [label = "1 Range , input: [0, 2], rsm: [S_0, S_1]", shape = ellipse] +_1_2 [label = "10 Terminal 'a', input: [1, 2]", shape = rectangle] +_1_3 [label = "2 Intermediate input: 1, rsm: S_2, input: [0, 2]", shape = plain] +_1_4 [label = "3 Range , input: [0, 1], rsm: [S_0, S_2]", shape = ellipse] +_1_5 [label = "4 Range , input: [1, 2], rsm: [S_2, S_1]", shape = ellipse] +_1_6 [label = "5 Nonterminal S, input: [0, 1]", shape = invtrapezium] +_1_7 [label = "6 Nonterminal S, input: [1, 2]", shape = invtrapezium] +_1_8 [label = "7 Range , input: [0, 1], rsm: [S_0, S_1]", shape = ellipse] +_1_9 [label = "8 Range , input: [1, 2], rsm: [S_0, S_1]", shape = ellipse] +_1_10 [label = "9 Terminal 'a', input: [0, 1]", shape = rectangle] +_1_0->_1_1 +_1_1->_1_3 +_1_3->_1_4 +_1_3->_1_5 +_1_4->_1_6 +_1_5->_1_7 +_1_6->_1_8 +_1_7->_1_9 +_1_8->_1_10 +_1_9->_1_2 +} + +subgraph cluster_2{ +labelloc="t" +_2_0 [label = "0 Nonterminal S, input: [0, 3]", shape = invtrapezium] +_2_1 [label = "1 Range , input: [0, 3], rsm: [S_0, S_1]", shape = ellipse] +_2_2 [label = "10 Nonterminal S, input: [0, 2]", shape = invtrapezium] +_2_3 [label = "11 Nonterminal S, input: [2, 3]", shape = invtrapezium] +_2_4 [label = "12 Range , input: [0, 1], rsm: [S_0, S_1]", shape = ellipse] +_2_5 [label = "13 Range , input: [1, 3], rsm: [S_0, S_1]", shape = ellipse] +_2_6 [label = "14 Range , input: [0, 2], rsm: [S_0, S_1]", shape = ellipse] +_2_7 [label = "15 Range , input: [2, 3], rsm: [S_0, S_1]", shape = ellipse] +_2_8 [label = "16 Terminal 'a', input: [0, 1]", shape = rectangle] +_2_9 [label = "17 Intermediate input: 2, rsm: S_2, input: [1, 3]", shape = plain] +_2_10 [label = "18 Intermediate input: 1, rsm: S_2, input: [0, 2]", shape = plain] +_2_11 [label = "19 Terminal 'a', input: [2, 3]", shape = rectangle] +_2_12 [label = "2 Intermediate input: 1, rsm: S_2, input: [0, 3]", shape = plain] +_2_13 [label = "20 Range , input: [1, 2], rsm: [S_0, S_2]", shape = ellipse] +_2_14 [label = "21 Range , input: [1, 2], rsm: [S_2, S_1]", shape = ellipse] +_2_15 [label = "22 Nonterminal S, input: [1, 2]", shape = invtrapezium] +_2_16 [label = "23 Nonterminal S, input: [1, 2]", shape = invtrapezium] +_2_17 [label = "24 Range , input: [1, 2], rsm: [S_0, S_1]", shape = ellipse] +_2_18 [label = "25 Terminal 'a', input: [1, 2]", shape = rectangle] +_2_19 [label = "3 Intermediate input: 2, rsm: S_2, input: [0, 3]", shape = plain] +_2_20 [label = "4 Range , input: [0, 1], rsm: [S_0, S_2]", shape = ellipse] +_2_21 [label = "5 Range , input: [1, 3], rsm: [S_2, S_1]", shape = ellipse] +_2_22 [label = "6 Range , input: [0, 2], rsm: [S_0, S_2]", shape = ellipse] +_2_23 [label = "7 Range , input: [2, 3], rsm: [S_2, S_1]", shape = ellipse] +_2_24 [label = "8 Nonterminal S, input: [0, 1]", shape = invtrapezium] +_2_25 [label = "9 Nonterminal S, input: [1, 3]", shape = invtrapezium] +_2_0->_2_1 +_2_1->_2_12 +_2_1->_2_19 +_2_2->_2_6 +_2_3->_2_7 +_2_4->_2_8 +_2_5->_2_9 +_2_6->_2_10 +_2_7->_2_11 +_2_9->_2_13 +_2_9->_2_23 +_2_10->_2_20 +_2_10->_2_14 +_2_12->_2_20 +_2_12->_2_21 +_2_13->_2_15 +_2_14->_2_16 +_2_15->_2_17 +_2_16->_2_17 +_2_17->_2_18 +_2_19->_2_22 +_2_19->_2_23 +_2_20->_2_24 +_2_21->_2_25 +_2_22->_2_2 +_2_23->_2_3 +_2_24->_2_4 +_2_25->_2_5 +} + +} diff --git a/test-shared/src/test/resources/correctness/tree/AmbiguousAStar3Grammar/simple/input.dot b/test-shared/src/test/resources/correctness/tree/AmbiguousAStar3Grammar/simple/input.dot new file mode 100644 index 000000000..2ff53cdf3 --- /dev/null +++ b/test-shared/src/test/resources/correctness/tree/AmbiguousAStar3Grammar/simple/input.dot @@ -0,0 +1,6 @@ +digraph Input { + start -> 0; + 0 -> 1 [label = "a"]; + 1 -> 2 [label = "a"]; + 2 -> 3 [label = "a"]; +} \ No newline at end of file diff --git a/test-shared/src/test/resources/correctness/tree/AmbiguousAStar3Grammar/simple/result.dot b/test-shared/src/test/resources/correctness/tree/AmbiguousAStar3Grammar/simple/result.dot new file mode 100644 index 000000000..009ecbb32 --- /dev/null +++ b/test-shared/src/test/resources/correctness/tree/AmbiguousAStar3Grammar/simple/result.dot @@ -0,0 +1,13 @@ +digraph g { +labelloc="t" +label="" +subgraph cluster_0{ +labelloc="t" +_0_0 [label = "0 Nonterminal S, input: [0, 1]", shape = invtrapezium] +_0_1 [label = "1 Range , input: [0, 1], rsm: [S_0, S_2]", shape = ellipse] +_0_2 [label = "2 Terminal 'a', input: [0, 1]", shape = rectangle] +_0_0->_0_1 +_0_1->_0_2 +} + +} diff --git a/test-shared/src/test/resources/correctness/tree/BipartitleGrammar/smaller/input.dot b/test-shared/src/test/resources/correctness/tree/BipartitleGrammar/smaller/input.dot new file mode 100644 index 000000000..ee04b3238 --- /dev/null +++ b/test-shared/src/test/resources/correctness/tree/BipartitleGrammar/smaller/input.dot @@ -0,0 +1,28 @@ +digraph Input { + start -> 0; + 0 -> 0 [label = "c"]; + 0 -> 1 [label = "a"]; + 0 -> 2 [label = "c"]; + 0 -> 3 [label = "a"]; + 0 -> 4 [label = "c"]; + 1 -> 0 [label = "b"]; + 1 -> 1 [label = "c"]; + 1 -> 2 [label = "b"]; + 1 -> 3 [label = "c"]; + 1 -> 4 [label = "b"]; + 2 -> 0 [label = "c"]; + 2 -> 1 [label = "a"]; + 2 -> 2 [label = "c"]; + 2 -> 3 [label = "a"]; + 2 -> 4 [label = "c"]; + 3 -> 0 [label = "b"]; + 3 -> 1 [label = "c"]; + 3 -> 2 [label = "b"]; + 3 -> 3 [label = "c"]; + 3 -> 4 [label = "b"]; + 4 -> 0 [label = "c"]; + 4 -> 1 [label = "a"]; + 4 -> 2 [label = "c"]; + 4 -> 3 [label = "a"]; + 4 -> 4 [label = "c"]; +} \ No newline at end of file diff --git a/test-shared/src/test/resources/correctness/tree/BipartitleGrammar/smaller/result.dot b/test-shared/src/test/resources/correctness/tree/BipartitleGrammar/smaller/result.dot new file mode 100644 index 000000000..4f4b0ee81 --- /dev/null +++ b/test-shared/src/test/resources/correctness/tree/BipartitleGrammar/smaller/result.dot @@ -0,0 +1,609 @@ +digraph g { +labelloc="t" +label="" +subgraph cluster_0{ +labelloc="t" +_0_0 [label = "0 Nonterminal S, input: [0, 0]", shape = invtrapezium] +_0_1 [label = "1 Range , input: [0, 0], rsm: [S_0, S_1]", shape = ellipse] +_0_2 [label = "10 Terminal 'a', input: [0, 3]", shape = rectangle] +_0_3 [label = "11 Nonterminal B, input: [3, 0]", shape = invtrapezium] +_0_4 [label = "12 Terminal 'a', input: [0, 1]", shape = rectangle] +_0_5 [label = "13 Nonterminal B, input: [1, 0]", shape = invtrapezium] +_0_6 [label = "14 Range , input: [3, 0], rsm: [B_0, B_2]", shape = ellipse] +_0_7 [label = "15 Range , input: [3, 0], rsm: [B_0, B_1]", shape = ellipse] +_0_8 [label = "16 Range , input: [1, 0], rsm: [B_0, B_1]", shape = ellipse] +_0_9 [label = "17 Range , input: [1, 0], rsm: [B_0, B_2]", shape = ellipse] +_0_10 [label = "18 Intermediate input: 4, rsm: B_1, input: [3, 0]", shape = plain] +_0_11 [label = "19 Intermediate input: 2, rsm: B_1, input: [3, 0]", shape = plain] +_0_12 [label = "2 Nonterminal A, input: [0, 0]", shape = invtrapezium] +_0_13 [label = "20 Intermediate input: 0, rsm: B_1, input: [3, 0]", shape = plain] +_0_14 [label = "21 Terminal 'b', input: [3, 0]", shape = rectangle] +_0_15 [label = "22 Terminal 'b', input: [1, 0]", shape = rectangle] +_0_16 [label = "23 Intermediate input: 2, rsm: B_1, input: [1, 0]", shape = plain] +_0_17 [label = "24 Intermediate input: 4, rsm: B_1, input: [1, 0]", shape = plain] +_0_18 [label = "25 Intermediate input: 0, rsm: B_1, input: [1, 0]", shape = plain] +_0_19 [label = "26 Range , input: [3, 4], rsm: [B_0, B_1]", shape = ellipse] +_0_20 [label = "27 Range , input: [4, 0], rsm: [B_1, B_2]", shape = ellipse] +_0_21 [label = "28 Range , input: [3, 2], rsm: [B_0, B_1]", shape = ellipse] +_0_22 [label = "29 Range , input: [2, 0], rsm: [B_1, B_2]", shape = ellipse] +_0_23 [label = "3 Range , input: [0, 0], rsm: [A_0, A_2]", shape = ellipse] +_0_24 [label = "30 Range , input: [0, 0], rsm: [B_1, B_2]", shape = ellipse] +_0_25 [label = "31 Range , input: [1, 2], rsm: [B_0, B_1]", shape = ellipse] +_0_26 [label = "32 Range , input: [1, 4], rsm: [B_0, B_1]", shape = ellipse] +_0_27 [label = "33 Terminal 'b', input: [3, 4]", shape = rectangle] +_0_28 [label = "34 Nonterminal A, input: [4, 0]", shape = invtrapezium] +_0_29 [label = "35 Terminal 'b', input: [3, 2]", shape = rectangle] +_0_30 [label = "36 Nonterminal A, input: [2, 0]", shape = invtrapezium] +_0_31 [label = "37 Nonterminal A, input: [0, 0]", shape = invtrapezium] +_0_32 [label = "38 Terminal 'b', input: [1, 2]", shape = rectangle] +_0_33 [label = "39 Terminal 'b', input: [1, 4]", shape = rectangle] +_0_34 [label = "4 Intermediate input: 3, rsm: A_1, input: [0, 0]", shape = plain] +_0_35 [label = "40 Range , input: [4, 0], rsm: [A_0, A_2]", shape = ellipse] +_0_36 [label = "41 Range , input: [2, 0], rsm: [A_0, A_2]", shape = ellipse] +_0_37 [label = "42 Intermediate input: 1, rsm: A_1, input: [4, 0]", shape = plain] +_0_38 [label = "43 Intermediate input: 3, rsm: A_1, input: [4, 0]", shape = plain] +_0_39 [label = "44 Intermediate input: 1, rsm: A_1, input: [2, 0]", shape = plain] +_0_40 [label = "45 Intermediate input: 3, rsm: A_1, input: [2, 0]", shape = plain] +_0_41 [label = "46 Range , input: [4, 1], rsm: [A_0, A_1]", shape = ellipse] +_0_42 [label = "47 Range , input: [4, 3], rsm: [A_0, A_1]", shape = ellipse] +_0_43 [label = "48 Range , input: [2, 1], rsm: [A_0, A_1]", shape = ellipse] +_0_44 [label = "49 Range , input: [2, 3], rsm: [A_0, A_1]", shape = ellipse] +_0_45 [label = "5 Intermediate input: 1, rsm: A_1, input: [0, 0]", shape = plain] +_0_46 [label = "50 Terminal 'a', input: [4, 1]", shape = rectangle] +_0_47 [label = "51 Terminal 'a', input: [4, 3]", shape = rectangle] +_0_48 [label = "52 Terminal 'a', input: [2, 1]", shape = rectangle] +_0_49 [label = "53 Terminal 'a', input: [2, 3]", shape = rectangle] +_0_50 [label = "6 Range , input: [0, 3], rsm: [A_0, A_1]", shape = ellipse] +_0_51 [label = "7 Range , input: [3, 0], rsm: [A_1, A_2]", shape = ellipse] +_0_52 [label = "8 Range , input: [0, 1], rsm: [A_0, A_1]", shape = ellipse] +_0_53 [label = "9 Range , input: [1, 0], rsm: [A_1, A_2]", shape = ellipse] +_0_0->_0_1 +_0_1->_0_12 +_0_3->_0_6 +_0_3->_0_7 +_0_5->_0_8 +_0_5->_0_9 +_0_6->_0_10 +_0_6->_0_11 +_0_6->_0_13 +_0_7->_0_14 +_0_8->_0_15 +_0_9->_0_16 +_0_9->_0_17 +_0_9->_0_18 +_0_10->_0_19 +_0_10->_0_20 +_0_11->_0_21 +_0_11->_0_22 +_0_12->_0_23 +_0_13->_0_7 +_0_13->_0_24 +_0_16->_0_25 +_0_16->_0_22 +_0_17->_0_26 +_0_17->_0_20 +_0_18->_0_8 +_0_18->_0_24 +_0_19->_0_27 +_0_20->_0_28 +_0_21->_0_29 +_0_22->_0_30 +_0_23->_0_34 +_0_23->_0_45 +_0_24->_0_31 +_0_25->_0_32 +_0_26->_0_33 +_0_28->_0_35 +_0_30->_0_36 +_0_31->_0_23 +_0_34->_0_50 +_0_34->_0_51 +_0_35->_0_37 +_0_35->_0_38 +_0_36->_0_39 +_0_36->_0_40 +_0_37->_0_41 +_0_37->_0_53 +_0_38->_0_42 +_0_38->_0_51 +_0_39->_0_43 +_0_39->_0_53 +_0_40->_0_44 +_0_40->_0_51 +_0_41->_0_46 +_0_42->_0_47 +_0_43->_0_48 +_0_44->_0_49 +_0_45->_0_52 +_0_45->_0_53 +_0_50->_0_2 +_0_51->_0_3 +_0_52->_0_4 +_0_53->_0_5 +} + +subgraph cluster_1{ +labelloc="t" +_1_0 [label = "0 Nonterminal S, input: [0, 1]", shape = invtrapezium] +_1_1 [label = "1 Range , input: [0, 1], rsm: [S_0, S_1]", shape = ellipse] +_1_2 [label = "10 Range , input: [1, 1], rsm: [A_1, A_2]", shape = ellipse] +_1_3 [label = "11 Terminal 'a', input: [0, 3]", shape = rectangle] +_1_4 [label = "12 Nonterminal B, input: [3, 1]", shape = invtrapezium] +_1_5 [label = "13 Nonterminal B, input: [1, 1]", shape = invtrapezium] +_1_6 [label = "14 Range , input: [3, 1], rsm: [B_0, B_2]", shape = ellipse] +_1_7 [label = "15 Range , input: [1, 1], rsm: [B_0, B_2]", shape = ellipse] +_1_8 [label = "16 Intermediate input: 4, rsm: B_1, input: [3, 1]", shape = plain] +_1_9 [label = "17 Intermediate input: 2, rsm: B_1, input: [3, 1]", shape = plain] +_1_10 [label = "18 Intermediate input: 0, rsm: B_1, input: [3, 1]", shape = plain] +_1_11 [label = "19 Intermediate input: 4, rsm: B_1, input: [1, 1]", shape = plain] +_1_12 [label = "2 Nonterminal A, input: [0, 1]", shape = invtrapezium] +_1_13 [label = "20 Intermediate input: 2, rsm: B_1, input: [1, 1]", shape = plain] +_1_14 [label = "21 Intermediate input: 0, rsm: B_1, input: [1, 1]", shape = plain] +_1_15 [label = "22 Range , input: [3, 4], rsm: [B_0, B_1]", shape = ellipse] +_1_16 [label = "23 Range , input: [4, 1], rsm: [B_1, B_2]", shape = ellipse] +_1_17 [label = "24 Range , input: [3, 2], rsm: [B_0, B_1]", shape = ellipse] +_1_18 [label = "25 Range , input: [2, 1], rsm: [B_1, B_2]", shape = ellipse] +_1_19 [label = "26 Range , input: [3, 0], rsm: [B_0, B_1]", shape = ellipse] +_1_20 [label = "27 Range , input: [0, 1], rsm: [B_1, B_2]", shape = ellipse] +_1_21 [label = "28 Range , input: [1, 4], rsm: [B_0, B_1]", shape = ellipse] +_1_22 [label = "29 Range , input: [1, 2], rsm: [B_0, B_1]", shape = ellipse] +_1_23 [label = "3 Range , input: [0, 1], rsm: [A_0, A_2]", shape = ellipse] +_1_24 [label = "30 Range , input: [1, 0], rsm: [B_0, B_1]", shape = ellipse] +_1_25 [label = "31 Terminal 'b', input: [3, 4]", shape = rectangle] +_1_26 [label = "32 Nonterminal A, input: [4, 1]", shape = invtrapezium] +_1_27 [label = "33 Terminal 'b', input: [3, 2]", shape = rectangle] +_1_28 [label = "34 Nonterminal A, input: [2, 1]", shape = invtrapezium] +_1_29 [label = "35 Terminal 'b', input: [3, 0]", shape = rectangle] +_1_30 [label = "36 Nonterminal A, input: [0, 1]", shape = invtrapezium] +_1_31 [label = "37 Terminal 'b', input: [1, 4]", shape = rectangle] +_1_32 [label = "38 Terminal 'b', input: [1, 2]", shape = rectangle] +_1_33 [label = "39 Terminal 'b', input: [1, 0]", shape = rectangle] +_1_34 [label = "4 Range , input: [0, 1], rsm: [A_0, A_1]", shape = ellipse] +_1_35 [label = "40 Range , input: [4, 1], rsm: [A_0, A_1]", shape = ellipse] +_1_36 [label = "41 Range , input: [4, 1], rsm: [A_0, A_2]", shape = ellipse] +_1_37 [label = "42 Range , input: [2, 1], rsm: [A_0, A_2]", shape = ellipse] +_1_38 [label = "43 Range , input: [2, 1], rsm: [A_0, A_1]", shape = ellipse] +_1_39 [label = "44 Terminal 'a', input: [4, 1]", shape = rectangle] +_1_40 [label = "45 Intermediate input: 1, rsm: A_1, input: [4, 1]", shape = plain] +_1_41 [label = "46 Intermediate input: 3, rsm: A_1, input: [4, 1]", shape = plain] +_1_42 [label = "47 Intermediate input: 3, rsm: A_1, input: [2, 1]", shape = plain] +_1_43 [label = "48 Intermediate input: 1, rsm: A_1, input: [2, 1]", shape = plain] +_1_44 [label = "49 Terminal 'a', input: [2, 1]", shape = rectangle] +_1_45 [label = "5 Intermediate input: 3, rsm: A_1, input: [0, 1]", shape = plain] +_1_46 [label = "50 Range , input: [4, 3], rsm: [A_0, A_1]", shape = ellipse] +_1_47 [label = "51 Range , input: [2, 3], rsm: [A_0, A_1]", shape = ellipse] +_1_48 [label = "52 Terminal 'a', input: [4, 3]", shape = rectangle] +_1_49 [label = "53 Terminal 'a', input: [2, 3]", shape = rectangle] +_1_50 [label = "6 Intermediate input: 1, rsm: A_1, input: [0, 1]", shape = plain] +_1_51 [label = "7 Terminal 'a', input: [0, 1]", shape = rectangle] +_1_52 [label = "8 Range , input: [0, 3], rsm: [A_0, A_1]", shape = ellipse] +_1_53 [label = "9 Range , input: [3, 1], rsm: [A_1, A_2]", shape = ellipse] +_1_0->_1_1 +_1_1->_1_12 +_1_2->_1_5 +_1_4->_1_6 +_1_5->_1_7 +_1_6->_1_8 +_1_6->_1_9 +_1_6->_1_10 +_1_7->_1_11 +_1_7->_1_13 +_1_7->_1_14 +_1_8->_1_15 +_1_8->_1_16 +_1_9->_1_17 +_1_9->_1_18 +_1_10->_1_19 +_1_10->_1_20 +_1_11->_1_21 +_1_11->_1_16 +_1_12->_1_23 +_1_12->_1_34 +_1_13->_1_22 +_1_13->_1_18 +_1_14->_1_24 +_1_14->_1_20 +_1_15->_1_25 +_1_16->_1_26 +_1_17->_1_27 +_1_18->_1_28 +_1_19->_1_29 +_1_20->_1_30 +_1_21->_1_31 +_1_22->_1_32 +_1_23->_1_45 +_1_23->_1_50 +_1_24->_1_33 +_1_26->_1_35 +_1_26->_1_36 +_1_28->_1_37 +_1_28->_1_38 +_1_30->_1_34 +_1_34->_1_51 +_1_35->_1_39 +_1_36->_1_40 +_1_36->_1_41 +_1_37->_1_42 +_1_37->_1_43 +_1_38->_1_44 +_1_40->_1_35 +_1_40->_1_2 +_1_41->_1_46 +_1_41->_1_53 +_1_42->_1_47 +_1_42->_1_53 +_1_43->_1_38 +_1_43->_1_2 +_1_45->_1_52 +_1_45->_1_53 +_1_46->_1_48 +_1_47->_1_49 +_1_50->_1_34 +_1_50->_1_2 +_1_52->_1_3 +_1_53->_1_4 +} + +subgraph cluster_2{ +labelloc="t" +_2_0 [label = "0 Nonterminal S, input: [0, 2]", shape = invtrapezium] +_2_1 [label = "1 Range , input: [0, 2], rsm: [S_0, S_1]", shape = ellipse] +_2_2 [label = "10 Terminal 'a', input: [0, 3]", shape = rectangle] +_2_3 [label = "11 Nonterminal B, input: [3, 2]", shape = invtrapezium] +_2_4 [label = "12 Terminal 'a', input: [0, 1]", shape = rectangle] +_2_5 [label = "13 Nonterminal B, input: [1, 2]", shape = invtrapezium] +_2_6 [label = "14 Range , input: [3, 2], rsm: [B_0, B_2]", shape = ellipse] +_2_7 [label = "15 Range , input: [3, 2], rsm: [B_0, B_1]", shape = ellipse] +_2_8 [label = "16 Range , input: [1, 2], rsm: [B_0, B_1]", shape = ellipse] +_2_9 [label = "17 Range , input: [1, 2], rsm: [B_0, B_2]", shape = ellipse] +_2_10 [label = "18 Intermediate input: 4, rsm: B_1, input: [3, 2]", shape = plain] +_2_11 [label = "19 Intermediate input: 2, rsm: B_1, input: [3, 2]", shape = plain] +_2_12 [label = "2 Nonterminal A, input: [0, 2]", shape = invtrapezium] +_2_13 [label = "20 Intermediate input: 0, rsm: B_1, input: [3, 2]", shape = plain] +_2_14 [label = "21 Terminal 'b', input: [3, 2]", shape = rectangle] +_2_15 [label = "22 Terminal 'b', input: [1, 2]", shape = rectangle] +_2_16 [label = "23 Intermediate input: 2, rsm: B_1, input: [1, 2]", shape = plain] +_2_17 [label = "24 Intermediate input: 4, rsm: B_1, input: [1, 2]", shape = plain] +_2_18 [label = "25 Intermediate input: 0, rsm: B_1, input: [1, 2]", shape = plain] +_2_19 [label = "26 Range , input: [3, 4], rsm: [B_0, B_1]", shape = ellipse] +_2_20 [label = "27 Range , input: [4, 2], rsm: [B_1, B_2]", shape = ellipse] +_2_21 [label = "28 Range , input: [2, 2], rsm: [B_1, B_2]", shape = ellipse] +_2_22 [label = "29 Range , input: [3, 0], rsm: [B_0, B_1]", shape = ellipse] +_2_23 [label = "3 Range , input: [0, 2], rsm: [A_0, A_2]", shape = ellipse] +_2_24 [label = "30 Range , input: [0, 2], rsm: [B_1, B_2]", shape = ellipse] +_2_25 [label = "31 Range , input: [1, 4], rsm: [B_0, B_1]", shape = ellipse] +_2_26 [label = "32 Range , input: [1, 0], rsm: [B_0, B_1]", shape = ellipse] +_2_27 [label = "33 Terminal 'b', input: [3, 4]", shape = rectangle] +_2_28 [label = "34 Nonterminal A, input: [4, 2]", shape = invtrapezium] +_2_29 [label = "35 Nonterminal A, input: [2, 2]", shape = invtrapezium] +_2_30 [label = "36 Terminal 'b', input: [3, 0]", shape = rectangle] +_2_31 [label = "37 Nonterminal A, input: [0, 2]", shape = invtrapezium] +_2_32 [label = "38 Terminal 'b', input: [1, 4]", shape = rectangle] +_2_33 [label = "39 Terminal 'b', input: [1, 0]", shape = rectangle] +_2_34 [label = "4 Intermediate input: 3, rsm: A_1, input: [0, 2]", shape = plain] +_2_35 [label = "40 Range , input: [4, 2], rsm: [A_0, A_2]", shape = ellipse] +_2_36 [label = "41 Range , input: [2, 2], rsm: [A_0, A_2]", shape = ellipse] +_2_37 [label = "42 Intermediate input: 1, rsm: A_1, input: [4, 2]", shape = plain] +_2_38 [label = "43 Intermediate input: 3, rsm: A_1, input: [4, 2]", shape = plain] +_2_39 [label = "44 Intermediate input: 1, rsm: A_1, input: [2, 2]", shape = plain] +_2_40 [label = "45 Intermediate input: 3, rsm: A_1, input: [2, 2]", shape = plain] +_2_41 [label = "46 Range , input: [4, 1], rsm: [A_0, A_1]", shape = ellipse] +_2_42 [label = "47 Range , input: [4, 3], rsm: [A_0, A_1]", shape = ellipse] +_2_43 [label = "48 Range , input: [2, 1], rsm: [A_0, A_1]", shape = ellipse] +_2_44 [label = "49 Range , input: [2, 3], rsm: [A_0, A_1]", shape = ellipse] +_2_45 [label = "5 Intermediate input: 1, rsm: A_1, input: [0, 2]", shape = plain] +_2_46 [label = "50 Terminal 'a', input: [4, 1]", shape = rectangle] +_2_47 [label = "51 Terminal 'a', input: [4, 3]", shape = rectangle] +_2_48 [label = "52 Terminal 'a', input: [2, 1]", shape = rectangle] +_2_49 [label = "53 Terminal 'a', input: [2, 3]", shape = rectangle] +_2_50 [label = "6 Range , input: [0, 3], rsm: [A_0, A_1]", shape = ellipse] +_2_51 [label = "7 Range , input: [3, 2], rsm: [A_1, A_2]", shape = ellipse] +_2_52 [label = "8 Range , input: [0, 1], rsm: [A_0, A_1]", shape = ellipse] +_2_53 [label = "9 Range , input: [1, 2], rsm: [A_1, A_2]", shape = ellipse] +_2_0->_2_1 +_2_1->_2_12 +_2_3->_2_6 +_2_3->_2_7 +_2_5->_2_8 +_2_5->_2_9 +_2_6->_2_10 +_2_6->_2_11 +_2_6->_2_13 +_2_7->_2_14 +_2_8->_2_15 +_2_9->_2_16 +_2_9->_2_17 +_2_9->_2_18 +_2_10->_2_19 +_2_10->_2_20 +_2_11->_2_7 +_2_11->_2_21 +_2_12->_2_23 +_2_13->_2_22 +_2_13->_2_24 +_2_16->_2_8 +_2_16->_2_21 +_2_17->_2_25 +_2_17->_2_20 +_2_18->_2_26 +_2_18->_2_24 +_2_19->_2_27 +_2_20->_2_28 +_2_21->_2_29 +_2_22->_2_30 +_2_23->_2_34 +_2_23->_2_45 +_2_24->_2_31 +_2_25->_2_32 +_2_26->_2_33 +_2_28->_2_35 +_2_29->_2_36 +_2_34->_2_50 +_2_34->_2_51 +_2_35->_2_37 +_2_35->_2_38 +_2_36->_2_39 +_2_36->_2_40 +_2_37->_2_41 +_2_37->_2_53 +_2_38->_2_42 +_2_38->_2_51 +_2_39->_2_43 +_2_39->_2_53 +_2_40->_2_44 +_2_40->_2_51 +_2_41->_2_46 +_2_42->_2_47 +_2_43->_2_48 +_2_44->_2_49 +_2_45->_2_52 +_2_45->_2_53 +_2_50->_2_2 +_2_51->_2_3 +_2_52->_2_4 +_2_53->_2_5 +} + +subgraph cluster_3{ +labelloc="t" +_3_0 [label = "0 Nonterminal S, input: [0, 3]", shape = invtrapezium] +_3_1 [label = "1 Range , input: [0, 3], rsm: [S_0, S_1]", shape = ellipse] +_3_2 [label = "10 Range , input: [1, 3], rsm: [A_1, A_2]", shape = ellipse] +_3_3 [label = "11 Nonterminal B, input: [3, 3]", shape = invtrapezium] +_3_4 [label = "12 Terminal 'a', input: [0, 1]", shape = rectangle] +_3_5 [label = "13 Nonterminal B, input: [1, 3]", shape = invtrapezium] +_3_6 [label = "14 Range , input: [3, 3], rsm: [B_0, B_2]", shape = ellipse] +_3_7 [label = "15 Range , input: [1, 3], rsm: [B_0, B_2]", shape = ellipse] +_3_8 [label = "16 Intermediate input: 4, rsm: B_1, input: [3, 3]", shape = plain] +_3_9 [label = "17 Intermediate input: 2, rsm: B_1, input: [3, 3]", shape = plain] +_3_10 [label = "18 Intermediate input: 0, rsm: B_1, input: [3, 3]", shape = plain] +_3_11 [label = "19 Intermediate input: 4, rsm: B_1, input: [1, 3]", shape = plain] +_3_12 [label = "2 Nonterminal A, input: [0, 3]", shape = invtrapezium] +_3_13 [label = "20 Intermediate input: 2, rsm: B_1, input: [1, 3]", shape = plain] +_3_14 [label = "21 Intermediate input: 0, rsm: B_1, input: [1, 3]", shape = plain] +_3_15 [label = "22 Range , input: [3, 4], rsm: [B_0, B_1]", shape = ellipse] +_3_16 [label = "23 Range , input: [4, 3], rsm: [B_1, B_2]", shape = ellipse] +_3_17 [label = "24 Range , input: [3, 2], rsm: [B_0, B_1]", shape = ellipse] +_3_18 [label = "25 Range , input: [2, 3], rsm: [B_1, B_2]", shape = ellipse] +_3_19 [label = "26 Range , input: [3, 0], rsm: [B_0, B_1]", shape = ellipse] +_3_20 [label = "27 Range , input: [0, 3], rsm: [B_1, B_2]", shape = ellipse] +_3_21 [label = "28 Range , input: [1, 4], rsm: [B_0, B_1]", shape = ellipse] +_3_22 [label = "29 Range , input: [1, 2], rsm: [B_0, B_1]", shape = ellipse] +_3_23 [label = "3 Range , input: [0, 3], rsm: [A_0, A_1]", shape = ellipse] +_3_24 [label = "30 Range , input: [1, 0], rsm: [B_0, B_1]", shape = ellipse] +_3_25 [label = "31 Terminal 'b', input: [3, 4]", shape = rectangle] +_3_26 [label = "32 Nonterminal A, input: [4, 3]", shape = invtrapezium] +_3_27 [label = "33 Terminal 'b', input: [3, 2]", shape = rectangle] +_3_28 [label = "34 Nonterminal A, input: [2, 3]", shape = invtrapezium] +_3_29 [label = "35 Terminal 'b', input: [3, 0]", shape = rectangle] +_3_30 [label = "36 Nonterminal A, input: [0, 3]", shape = invtrapezium] +_3_31 [label = "37 Terminal 'b', input: [1, 4]", shape = rectangle] +_3_32 [label = "38 Terminal 'b', input: [1, 2]", shape = rectangle] +_3_33 [label = "39 Terminal 'b', input: [1, 0]", shape = rectangle] +_3_34 [label = "4 Range , input: [0, 3], rsm: [A_0, A_2]", shape = ellipse] +_3_35 [label = "40 Range , input: [4, 3], rsm: [A_0, A_1]", shape = ellipse] +_3_36 [label = "41 Range , input: [4, 3], rsm: [A_0, A_2]", shape = ellipse] +_3_37 [label = "42 Range , input: [2, 3], rsm: [A_0, A_1]", shape = ellipse] +_3_38 [label = "43 Range , input: [2, 3], rsm: [A_0, A_2]", shape = ellipse] +_3_39 [label = "44 Terminal 'a', input: [4, 3]", shape = rectangle] +_3_40 [label = "45 Intermediate input: 3, rsm: A_1, input: [4, 3]", shape = plain] +_3_41 [label = "46 Intermediate input: 1, rsm: A_1, input: [4, 3]", shape = plain] +_3_42 [label = "47 Terminal 'a', input: [2, 3]", shape = rectangle] +_3_43 [label = "48 Intermediate input: 3, rsm: A_1, input: [2, 3]", shape = plain] +_3_44 [label = "49 Intermediate input: 1, rsm: A_1, input: [2, 3]", shape = plain] +_3_45 [label = "5 Terminal 'a', input: [0, 3]", shape = rectangle] +_3_46 [label = "50 Range , input: [4, 1], rsm: [A_0, A_1]", shape = ellipse] +_3_47 [label = "51 Range , input: [2, 1], rsm: [A_0, A_1]", shape = ellipse] +_3_48 [label = "52 Terminal 'a', input: [4, 1]", shape = rectangle] +_3_49 [label = "53 Terminal 'a', input: [2, 1]", shape = rectangle] +_3_50 [label = "6 Intermediate input: 3, rsm: A_1, input: [0, 3]", shape = plain] +_3_51 [label = "7 Intermediate input: 1, rsm: A_1, input: [0, 3]", shape = plain] +_3_52 [label = "8 Range , input: [3, 3], rsm: [A_1, A_2]", shape = ellipse] +_3_53 [label = "9 Range , input: [0, 1], rsm: [A_0, A_1]", shape = ellipse] +_3_0->_3_1 +_3_1->_3_12 +_3_2->_3_5 +_3_3->_3_6 +_3_5->_3_7 +_3_6->_3_8 +_3_6->_3_9 +_3_6->_3_10 +_3_7->_3_11 +_3_7->_3_13 +_3_7->_3_14 +_3_8->_3_15 +_3_8->_3_16 +_3_9->_3_17 +_3_9->_3_18 +_3_10->_3_19 +_3_10->_3_20 +_3_11->_3_21 +_3_11->_3_16 +_3_12->_3_23 +_3_12->_3_34 +_3_13->_3_22 +_3_13->_3_18 +_3_14->_3_24 +_3_14->_3_20 +_3_15->_3_25 +_3_16->_3_26 +_3_17->_3_27 +_3_18->_3_28 +_3_19->_3_29 +_3_20->_3_30 +_3_21->_3_31 +_3_22->_3_32 +_3_23->_3_45 +_3_24->_3_33 +_3_26->_3_35 +_3_26->_3_36 +_3_28->_3_37 +_3_28->_3_38 +_3_34->_3_50 +_3_34->_3_51 +_3_35->_3_39 +_3_36->_3_40 +_3_36->_3_41 +_3_37->_3_42 +_3_38->_3_43 +_3_38->_3_44 +_3_40->_3_35 +_3_40->_3_52 +_3_41->_3_46 +_3_41->_3_2 +_3_43->_3_37 +_3_43->_3_52 +_3_44->_3_47 +_3_44->_3_2 +_3_46->_3_48 +_3_47->_3_49 +_3_50->_3_23 +_3_50->_3_52 +_3_51->_3_53 +_3_51->_3_2 +_3_52->_3_3 +_3_53->_3_4 +} + +subgraph cluster_4{ +labelloc="t" +_4_0 [label = "0 Nonterminal S, input: [0, 4]", shape = invtrapezium] +_4_1 [label = "1 Range , input: [0, 4], rsm: [S_0, S_1]", shape = ellipse] +_4_2 [label = "10 Terminal 'a', input: [0, 3]", shape = rectangle] +_4_3 [label = "11 Nonterminal B, input: [3, 4]", shape = invtrapezium] +_4_4 [label = "12 Terminal 'a', input: [0, 1]", shape = rectangle] +_4_5 [label = "13 Nonterminal B, input: [1, 4]", shape = invtrapezium] +_4_6 [label = "14 Range , input: [3, 4], rsm: [B_0, B_1]", shape = ellipse] +_4_7 [label = "15 Range , input: [3, 4], rsm: [B_0, B_2]", shape = ellipse] +_4_8 [label = "16 Range , input: [1, 4], rsm: [B_0, B_1]", shape = ellipse] +_4_9 [label = "17 Range , input: [1, 4], rsm: [B_0, B_2]", shape = ellipse] +_4_10 [label = "18 Terminal 'b', input: [3, 4]", shape = rectangle] +_4_11 [label = "19 Intermediate input: 4, rsm: B_1, input: [3, 4]", shape = plain] +_4_12 [label = "2 Nonterminal A, input: [0, 4]", shape = invtrapezium] +_4_13 [label = "20 Intermediate input: 2, rsm: B_1, input: [3, 4]", shape = plain] +_4_14 [label = "21 Intermediate input: 0, rsm: B_1, input: [3, 4]", shape = plain] +_4_15 [label = "22 Terminal 'b', input: [1, 4]", shape = rectangle] +_4_16 [label = "23 Intermediate input: 4, rsm: B_1, input: [1, 4]", shape = plain] +_4_17 [label = "24 Intermediate input: 2, rsm: B_1, input: [1, 4]", shape = plain] +_4_18 [label = "25 Intermediate input: 0, rsm: B_1, input: [1, 4]", shape = plain] +_4_19 [label = "26 Range , input: [4, 4], rsm: [B_1, B_2]", shape = ellipse] +_4_20 [label = "27 Range , input: [3, 2], rsm: [B_0, B_1]", shape = ellipse] +_4_21 [label = "28 Range , input: [2, 4], rsm: [B_1, B_2]", shape = ellipse] +_4_22 [label = "29 Range , input: [3, 0], rsm: [B_0, B_1]", shape = ellipse] +_4_23 [label = "3 Range , input: [0, 4], rsm: [A_0, A_2]", shape = ellipse] +_4_24 [label = "30 Range , input: [0, 4], rsm: [B_1, B_2]", shape = ellipse] +_4_25 [label = "31 Range , input: [1, 2], rsm: [B_0, B_1]", shape = ellipse] +_4_26 [label = "32 Range , input: [1, 0], rsm: [B_0, B_1]", shape = ellipse] +_4_27 [label = "33 Nonterminal A, input: [4, 4]", shape = invtrapezium] +_4_28 [label = "34 Terminal 'b', input: [3, 2]", shape = rectangle] +_4_29 [label = "35 Nonterminal A, input: [2, 4]", shape = invtrapezium] +_4_30 [label = "36 Terminal 'b', input: [3, 0]", shape = rectangle] +_4_31 [label = "37 Nonterminal A, input: [0, 4]", shape = invtrapezium] +_4_32 [label = "38 Terminal 'b', input: [1, 2]", shape = rectangle] +_4_33 [label = "39 Terminal 'b', input: [1, 0]", shape = rectangle] +_4_34 [label = "4 Intermediate input: 3, rsm: A_1, input: [0, 4]", shape = plain] +_4_35 [label = "40 Range , input: [4, 4], rsm: [A_0, A_2]", shape = ellipse] +_4_36 [label = "41 Range , input: [2, 4], rsm: [A_0, A_2]", shape = ellipse] +_4_37 [label = "42 Intermediate input: 3, rsm: A_1, input: [4, 4]", shape = plain] +_4_38 [label = "43 Intermediate input: 1, rsm: A_1, input: [4, 4]", shape = plain] +_4_39 [label = "44 Intermediate input: 3, rsm: A_1, input: [2, 4]", shape = plain] +_4_40 [label = "45 Intermediate input: 1, rsm: A_1, input: [2, 4]", shape = plain] +_4_41 [label = "46 Range , input: [4, 3], rsm: [A_0, A_1]", shape = ellipse] +_4_42 [label = "47 Range , input: [4, 1], rsm: [A_0, A_1]", shape = ellipse] +_4_43 [label = "48 Range , input: [2, 3], rsm: [A_0, A_1]", shape = ellipse] +_4_44 [label = "49 Range , input: [2, 1], rsm: [A_0, A_1]", shape = ellipse] +_4_45 [label = "5 Intermediate input: 1, rsm: A_1, input: [0, 4]", shape = plain] +_4_46 [label = "50 Terminal 'a', input: [4, 3]", shape = rectangle] +_4_47 [label = "51 Terminal 'a', input: [4, 1]", shape = rectangle] +_4_48 [label = "52 Terminal 'a', input: [2, 3]", shape = rectangle] +_4_49 [label = "53 Terminal 'a', input: [2, 1]", shape = rectangle] +_4_50 [label = "6 Range , input: [0, 3], rsm: [A_0, A_1]", shape = ellipse] +_4_51 [label = "7 Range , input: [3, 4], rsm: [A_1, A_2]", shape = ellipse] +_4_52 [label = "8 Range , input: [0, 1], rsm: [A_0, A_1]", shape = ellipse] +_4_53 [label = "9 Range , input: [1, 4], rsm: [A_1, A_2]", shape = ellipse] +_4_0->_4_1 +_4_1->_4_12 +_4_3->_4_6 +_4_3->_4_7 +_4_5->_4_8 +_4_5->_4_9 +_4_6->_4_10 +_4_7->_4_11 +_4_7->_4_13 +_4_7->_4_14 +_4_8->_4_15 +_4_9->_4_16 +_4_9->_4_17 +_4_9->_4_18 +_4_11->_4_6 +_4_11->_4_19 +_4_12->_4_23 +_4_13->_4_20 +_4_13->_4_21 +_4_14->_4_22 +_4_14->_4_24 +_4_16->_4_8 +_4_16->_4_19 +_4_17->_4_25 +_4_17->_4_21 +_4_18->_4_26 +_4_18->_4_24 +_4_19->_4_27 +_4_20->_4_28 +_4_21->_4_29 +_4_22->_4_30 +_4_23->_4_34 +_4_23->_4_45 +_4_24->_4_31 +_4_25->_4_32 +_4_26->_4_33 +_4_27->_4_35 +_4_29->_4_36 +_4_31->_4_23 +_4_34->_4_50 +_4_34->_4_51 +_4_35->_4_37 +_4_35->_4_38 +_4_36->_4_39 +_4_36->_4_40 +_4_37->_4_41 +_4_37->_4_51 +_4_38->_4_42 +_4_38->_4_53 +_4_39->_4_43 +_4_39->_4_51 +_4_40->_4_44 +_4_40->_4_53 +_4_41->_4_46 +_4_42->_4_47 +_4_43->_4_48 +_4_44->_4_49 +_4_45->_4_52 +_4_45->_4_53 +_4_50->_4_2 +_4_51->_4_3 +_4_52->_4_4 +_4_53->_4_5 +} + +} diff --git a/test-shared/src/test/resources/correctness/tree/EpsilonGrammar/epsilon/input.dot b/test-shared/src/test/resources/correctness/tree/EpsilonGrammar/epsilon/input.dot new file mode 100644 index 000000000..e858712e8 --- /dev/null +++ b/test-shared/src/test/resources/correctness/tree/EpsilonGrammar/epsilon/input.dot @@ -0,0 +1,3 @@ +digraph Input { + start -> 0; +} \ No newline at end of file diff --git a/test-shared/src/test/resources/correctness/tree/EpsilonGrammar/epsilon/result.dot b/test-shared/src/test/resources/correctness/tree/EpsilonGrammar/epsilon/result.dot new file mode 100644 index 000000000..57bf00687 --- /dev/null +++ b/test-shared/src/test/resources/correctness/tree/EpsilonGrammar/epsilon/result.dot @@ -0,0 +1,13 @@ +digraph g { +labelloc="t" +label="" +subgraph cluster_0{ +labelloc="t" +_0_0 [label = "0 Nonterminal S, input: [0, 0]", shape = invtrapezium] +_0_1 [label = "1 Range , input: [0, 0], rsm: [S_0, S_0]", shape = ellipse] +_0_2 [label = "2 Epsilon RSM: S_0, input: [0, 0]", shape = invhouse] +_0_0->_0_1 +_0_1->_0_2 +} + +} diff --git a/test-shared/src/test/resources/correctness/tree/LoopDyckGrammar/minimalWorstCase/input.dot b/test-shared/src/test/resources/correctness/tree/LoopDyckGrammar/minimalWorstCase/input.dot new file mode 100644 index 000000000..7c08420c5 --- /dev/null +++ b/test-shared/src/test/resources/correctness/tree/LoopDyckGrammar/minimalWorstCase/input.dot @@ -0,0 +1,7 @@ +digraph Input { + label="Minimal worst case, simple loop RSM for Dyck language" + start -> 0; + 0 -> 0 [label = "("]; + 0 -> 1 [label = ")"]; + 1 -> 0 [label = ")"]; +} \ No newline at end of file diff --git a/test-shared/src/test/resources/correctness/tree/LoopDyckGrammar/minimalWorstCase/result.dot b/test-shared/src/test/resources/correctness/tree/LoopDyckGrammar/minimalWorstCase/result.dot new file mode 100644 index 000000000..4e34aec1a --- /dev/null +++ b/test-shared/src/test/resources/correctness/tree/LoopDyckGrammar/minimalWorstCase/result.dot @@ -0,0 +1,73 @@ +digraph g { +labelloc="t" +label="" +subgraph cluster_0{ +labelloc="t" +_0_0 [label = "0 Nonterminal S, input: [0, 0]", shape = invtrapezium] +_0_1 [label = "1 Range , input: [0, 0], rsm: [S_0, S_0]", shape = ellipse] +_0_2 [label = "10 Terminal '(', input: [0, 0]", shape = rectangle] +_0_3 [label = "11 Nonterminal S, input: [0, 1]", shape = invtrapezium] +_0_4 [label = "12 Range , input: [0, 1], rsm: [S_0, S_0]", shape = ellipse] +_0_5 [label = "13 Intermediate input: 0, rsm: S_2, input: [0, 1]", shape = plain] +_0_6 [label = "14 Range , input: [0, 0], rsm: [S_0, S_2]", shape = ellipse] +_0_7 [label = "15 Range , input: [0, 1], rsm: [S_2, S_0]", shape = ellipse] +_0_8 [label = "16 Intermediate input: 0, rsm: S_1, input: [0, 0]", shape = plain] +_0_9 [label = "17 Terminal ')', input: [0, 1]", shape = rectangle] +_0_10 [label = "18 Range , input: [0, 0], rsm: [S_1, S_2]", shape = ellipse] +_0_11 [label = "19 Nonterminal S, input: [0, 0]", shape = invtrapezium] +_0_12 [label = "2 Epsilon RSM: S_0, input: [0, 0]", shape = invhouse] +_0_13 [label = "3 Intermediate input: 1, rsm: S_2, input: [0, 0]", shape = plain] +_0_14 [label = "4 Range , input: [0, 1], rsm: [S_0, S_2]", shape = ellipse] +_0_15 [label = "5 Range , input: [1, 0], rsm: [S_2, S_0]", shape = ellipse] +_0_16 [label = "6 Intermediate input: 0, rsm: S_1, input: [0, 1]", shape = plain] +_0_17 [label = "7 Terminal ')', input: [1, 0]", shape = rectangle] +_0_18 [label = "8 Range , input: [0, 0], rsm: [S_0, S_1]", shape = ellipse] +_0_19 [label = "9 Range , input: [0, 1], rsm: [S_1, S_2]", shape = ellipse] +_0_0->_0_1 +_0_1->_0_12 +_0_1->_0_13 +_0_3->_0_4 +_0_4->_0_5 +_0_5->_0_6 +_0_5->_0_7 +_0_6->_0_8 +_0_7->_0_9 +_0_8->_0_18 +_0_8->_0_10 +_0_10->_0_11 +_0_13->_0_14 +_0_13->_0_15 +_0_14->_0_16 +_0_15->_0_17 +_0_16->_0_18 +_0_16->_0_19 +_0_18->_0_2 +_0_19->_0_3 +} + +subgraph cluster_1{ +labelloc="t" +_1_0 [label = "0 Nonterminal S, input: [0, 1]", shape = invtrapezium] +_1_1 [label = "1 Range , input: [0, 1], rsm: [S_0, S_0]", shape = ellipse] +_1_2 [label = "10 Nonterminal S, input: [0, 0]", shape = invtrapezium] +_1_3 [label = "2 Intermediate input: 0, rsm: S_2, input: [0, 1]", shape = plain] +_1_4 [label = "3 Range , input: [0, 0], rsm: [S_0, S_2]", shape = ellipse] +_1_5 [label = "4 Range , input: [0, 1], rsm: [S_2, S_0]", shape = ellipse] +_1_6 [label = "5 Intermediate input: 0, rsm: S_1, input: [0, 0]", shape = plain] +_1_7 [label = "6 Terminal ')', input: [0, 1]", shape = rectangle] +_1_8 [label = "7 Range , input: [0, 0], rsm: [S_0, S_1]", shape = ellipse] +_1_9 [label = "8 Range , input: [0, 0], rsm: [S_1, S_2]", shape = ellipse] +_1_10 [label = "9 Terminal '(', input: [0, 0]", shape = rectangle] +_1_0->_1_1 +_1_1->_1_3 +_1_3->_1_4 +_1_3->_1_5 +_1_4->_1_6 +_1_5->_1_7 +_1_6->_1_8 +_1_6->_1_9 +_1_8->_1_10 +_1_9->_1_2 +} + +} diff --git a/test-shared/src/test/resources/correctness/tree/LoopDyckGrammar/oneVertex/input.dot b/test-shared/src/test/resources/correctness/tree/LoopDyckGrammar/oneVertex/input.dot new file mode 100644 index 000000000..21edd13ff --- /dev/null +++ b/test-shared/src/test/resources/correctness/tree/LoopDyckGrammar/oneVertex/input.dot @@ -0,0 +1,6 @@ +digraph Input { + label="Two loops with common vertex, simple loop RSM for Dyck language" + start -> 0; + 0 -> 0 [label = "("]; + 0 -> 0 [label = ")"]; +} \ No newline at end of file diff --git a/test-shared/src/test/resources/correctness/tree/LoopDyckGrammar/oneVertex/result.dot b/test-shared/src/test/resources/correctness/tree/LoopDyckGrammar/oneVertex/result.dot new file mode 100644 index 000000000..4e0733b02 --- /dev/null +++ b/test-shared/src/test/resources/correctness/tree/LoopDyckGrammar/oneVertex/result.dot @@ -0,0 +1,31 @@ +digraph g { +labelloc="t" +label="" +subgraph cluster_0{ +labelloc="t" +_0_0 [label = "0 Nonterminal S, input: [0, 0]", shape = invtrapezium] +_0_1 [label = "1 Range , input: [0, 0], rsm: [S_0, S_0]", shape = ellipse] +_0_2 [label = "10 Terminal '(', input: [0, 0]", shape = rectangle] +_0_3 [label = "11 Nonterminal S, input: [0, 0]", shape = invtrapezium] +_0_4 [label = "2 Epsilon RSM: S_0, input: [0, 0]", shape = invhouse] +_0_5 [label = "3 Intermediate input: 0, rsm: S_2, input: [0, 0]", shape = plain] +_0_6 [label = "4 Range , input: [0, 0], rsm: [S_0, S_2]", shape = ellipse] +_0_7 [label = "5 Range , input: [0, 0], rsm: [S_2, S_0]", shape = ellipse] +_0_8 [label = "6 Intermediate input: 0, rsm: S_1, input: [0, 0]", shape = plain] +_0_9 [label = "7 Terminal ')', input: [0, 0]", shape = rectangle] +_0_10 [label = "8 Range , input: [0, 0], rsm: [S_0, S_1]", shape = ellipse] +_0_11 [label = "9 Range , input: [0, 0], rsm: [S_1, S_2]", shape = ellipse] +_0_0->_0_1 +_0_1->_0_4 +_0_1->_0_5 +_0_5->_0_6 +_0_5->_0_7 +_0_6->_0_8 +_0_7->_0_9 +_0_8->_0_10 +_0_8->_0_11 +_0_10->_0_2 +_0_11->_0_3 +} + +} diff --git a/test-shared/src/test/resources/correctness/tree/LoopDyckGrammar/secondWorstCase/input.dot b/test-shared/src/test/resources/correctness/tree/LoopDyckGrammar/secondWorstCase/input.dot new file mode 100644 index 000000000..2a79063bc --- /dev/null +++ b/test-shared/src/test/resources/correctness/tree/LoopDyckGrammar/secondWorstCase/input.dot @@ -0,0 +1,10 @@ +digraph Input { + label="Second worst case, simple loop RSM for Dyck language" + start -> 0; + 0 -> 1 [label = ")"]; + 1 -> 2 [label = ")"]; + 2 -> 0 [label = ")"]; + + 0 -> 3 [label = "("]; + 3 -> 0 [label = "("]; +} \ No newline at end of file diff --git a/test-shared/src/test/resources/correctness/tree/LoopDyckGrammar/secondWorstCase/result.dot b/test-shared/src/test/resources/correctness/tree/LoopDyckGrammar/secondWorstCase/result.dot new file mode 100644 index 000000000..4dc0db29d --- /dev/null +++ b/test-shared/src/test/resources/correctness/tree/LoopDyckGrammar/secondWorstCase/result.dot @@ -0,0 +1,349 @@ +digraph g { +labelloc="t" +label="" +subgraph cluster_0{ +labelloc="t" +_0_0 [label = "0 Nonterminal S, input: [0, 0]", shape = invtrapezium] +_0_1 [label = "1 Range , input: [0, 0], rsm: [S_0, S_0]", shape = ellipse] +_0_2 [label = "10 Terminal '(', input: [0, 3]", shape = rectangle] +_0_3 [label = "11 Nonterminal S, input: [3, 2]", shape = invtrapezium] +_0_4 [label = "12 Range , input: [3, 2], rsm: [S_0, S_0]", shape = ellipse] +_0_5 [label = "13 Intermediate input: 1, rsm: S_2, input: [3, 2]", shape = plain] +_0_6 [label = "14 Range , input: [3, 1], rsm: [S_0, S_2]", shape = ellipse] +_0_7 [label = "15 Range , input: [1, 2], rsm: [S_2, S_0]", shape = ellipse] +_0_8 [label = "16 Intermediate input: 3, rsm: S_1, input: [3, 1]", shape = plain] +_0_9 [label = "17 Intermediate input: 0, rsm: S_1, input: [3, 1]", shape = plain] +_0_10 [label = "18 Terminal ')', input: [1, 2]", shape = rectangle] +_0_11 [label = "19 Range , input: [3, 3], rsm: [S_0, S_1]", shape = ellipse] +_0_12 [label = "2 Epsilon RSM: S_0, input: [0, 0]", shape = invhouse] +_0_13 [label = "20 Range , input: [3, 1], rsm: [S_1, S_2]", shape = ellipse] +_0_14 [label = "21 Range , input: [3, 0], rsm: [S_0, S_1]", shape = ellipse] +_0_15 [label = "22 Range , input: [0, 1], rsm: [S_1, S_2]", shape = ellipse] +_0_16 [label = "23 Intermediate input: 0, rsm: S_0, input: [3, 3]", shape = plain] +_0_17 [label = "24 Nonterminal S, input: [3, 1]", shape = invtrapezium] +_0_18 [label = "25 Terminal '(', input: [3, 0]", shape = rectangle] +_0_19 [label = "26 Nonterminal S, input: [0, 1]", shape = invtrapezium] +_0_20 [label = "27 Range , input: [3, 0], rsm: [S_0, S_0]", shape = ellipse] +_0_21 [label = "28 Range , input: [3, 1], rsm: [S_0, S_0]", shape = ellipse] +_0_22 [label = "29 Range , input: [0, 1], rsm: [S_0, S_0]", shape = ellipse] +_0_23 [label = "3 Intermediate input: 2, rsm: S_2, input: [0, 0]", shape = plain] +_0_24 [label = "30 Intermediate input: 2, rsm: S_2, input: [3, 0]", shape = plain] +_0_25 [label = "31 Intermediate input: 0, rsm: S_2, input: [3, 1]", shape = plain] +_0_26 [label = "32 Intermediate input: 0, rsm: S_2, input: [0, 1]", shape = plain] +_0_27 [label = "33 Range , input: [3, 2], rsm: [S_0, S_2]", shape = ellipse] +_0_28 [label = "34 Range , input: [3, 0], rsm: [S_0, S_2]", shape = ellipse] +_0_29 [label = "35 Range , input: [0, 1], rsm: [S_2, S_0]", shape = ellipse] +_0_30 [label = "36 Range , input: [0, 0], rsm: [S_0, S_2]", shape = ellipse] +_0_31 [label = "37 Intermediate input: 0, rsm: S_1, input: [3, 2]", shape = plain] +_0_32 [label = "38 Intermediate input: 3, rsm: S_1, input: [3, 2]", shape = plain] +_0_33 [label = "39 Intermediate input: 0, rsm: S_1, input: [3, 0]", shape = plain] +_0_34 [label = "4 Range , input: [0, 2], rsm: [S_0, S_2]", shape = ellipse] +_0_35 [label = "40 Intermediate input: 3, rsm: S_1, input: [3, 0]", shape = plain] +_0_36 [label = "41 Terminal ')', input: [0, 1]", shape = rectangle] +_0_37 [label = "42 Intermediate input: 3, rsm: S_1, input: [0, 0]", shape = plain] +_0_38 [label = "43 Range , input: [0, 2], rsm: [S_1, S_2]", shape = ellipse] +_0_39 [label = "44 Range , input: [0, 0], rsm: [S_1, S_2]", shape = ellipse] +_0_40 [label = "45 Range , input: [3, 0], rsm: [S_1, S_2]", shape = ellipse] +_0_41 [label = "46 Nonterminal S, input: [0, 2]", shape = invtrapezium] +_0_42 [label = "47 Nonterminal S, input: [0, 0]", shape = invtrapezium] +_0_43 [label = "48 Nonterminal S, input: [3, 0]", shape = invtrapezium] +_0_44 [label = "49 Range , input: [0, 2], rsm: [S_0, S_0]", shape = ellipse] +_0_45 [label = "5 Range , input: [2, 0], rsm: [S_2, S_0]", shape = ellipse] +_0_46 [label = "50 Intermediate input: 1, rsm: S_2, input: [0, 2]", shape = plain] +_0_47 [label = "51 Range , input: [0, 1], rsm: [S_0, S_2]", shape = ellipse] +_0_48 [label = "52 Intermediate input: 3, rsm: S_1, input: [0, 1]", shape = plain] +_0_49 [label = "6 Intermediate input: 3, rsm: S_1, input: [0, 2]", shape = plain] +_0_50 [label = "7 Terminal ')', input: [2, 0]", shape = rectangle] +_0_51 [label = "8 Range , input: [0, 3], rsm: [S_0, S_1]", shape = ellipse] +_0_52 [label = "9 Range , input: [3, 2], rsm: [S_1, S_2]", shape = ellipse] +_0_0->_0_1 +_0_1->_0_12 +_0_1->_0_23 +_0_3->_0_4 +_0_4->_0_5 +_0_5->_0_6 +_0_5->_0_7 +_0_6->_0_8 +_0_6->_0_9 +_0_7->_0_10 +_0_8->_0_11 +_0_8->_0_13 +_0_9->_0_14 +_0_9->_0_15 +_0_11->_0_16 +_0_13->_0_17 +_0_14->_0_18 +_0_15->_0_19 +_0_16->_0_20 +_0_16->_0_51 +_0_17->_0_21 +_0_19->_0_22 +_0_20->_0_24 +_0_21->_0_25 +_0_22->_0_26 +_0_23->_0_34 +_0_23->_0_45 +_0_24->_0_27 +_0_24->_0_45 +_0_25->_0_28 +_0_25->_0_29 +_0_26->_0_30 +_0_26->_0_29 +_0_27->_0_31 +_0_27->_0_32 +_0_28->_0_33 +_0_28->_0_35 +_0_29->_0_36 +_0_30->_0_37 +_0_31->_0_14 +_0_31->_0_38 +_0_32->_0_11 +_0_32->_0_52 +_0_33->_0_14 +_0_33->_0_39 +_0_34->_0_49 +_0_35->_0_11 +_0_35->_0_40 +_0_37->_0_51 +_0_37->_0_40 +_0_38->_0_41 +_0_39->_0_42 +_0_40->_0_43 +_0_41->_0_44 +_0_43->_0_20 +_0_44->_0_46 +_0_45->_0_50 +_0_46->_0_47 +_0_46->_0_7 +_0_47->_0_48 +_0_48->_0_51 +_0_48->_0_13 +_0_49->_0_51 +_0_49->_0_52 +_0_51->_0_2 +_0_52->_0_3 +} + +subgraph cluster_1{ +labelloc="t" +_1_0 [label = "0 Nonterminal S, input: [0, 1]", shape = invtrapezium] +_1_1 [label = "1 Range , input: [0, 1], rsm: [S_0, S_0]", shape = ellipse] +_1_2 [label = "10 Nonterminal S, input: [3, 0]", shape = invtrapezium] +_1_3 [label = "11 Range , input: [3, 0], rsm: [S_0, S_0]", shape = ellipse] +_1_4 [label = "12 Intermediate input: 2, rsm: S_2, input: [3, 0]", shape = plain] +_1_5 [label = "13 Range , input: [3, 2], rsm: [S_0, S_2]", shape = ellipse] +_1_6 [label = "14 Range , input: [2, 0], rsm: [S_2, S_0]", shape = ellipse] +_1_7 [label = "15 Intermediate input: 0, rsm: S_1, input: [3, 2]", shape = plain] +_1_8 [label = "16 Intermediate input: 3, rsm: S_1, input: [3, 2]", shape = plain] +_1_9 [label = "17 Terminal ')', input: [2, 0]", shape = rectangle] +_1_10 [label = "18 Range , input: [3, 0], rsm: [S_0, S_1]", shape = ellipse] +_1_11 [label = "19 Range , input: [0, 2], rsm: [S_1, S_2]", shape = ellipse] +_1_12 [label = "2 Intermediate input: 0, rsm: S_2, input: [0, 1]", shape = plain] +_1_13 [label = "20 Range , input: [3, 3], rsm: [S_0, S_1]", shape = ellipse] +_1_14 [label = "21 Range , input: [3, 2], rsm: [S_1, S_2]", shape = ellipse] +_1_15 [label = "22 Terminal '(', input: [3, 0]", shape = rectangle] +_1_16 [label = "23 Nonterminal S, input: [0, 2]", shape = invtrapezium] +_1_17 [label = "24 Intermediate input: 0, rsm: S_0, input: [3, 3]", shape = plain] +_1_18 [label = "25 Nonterminal S, input: [3, 2]", shape = invtrapezium] +_1_19 [label = "26 Range , input: [0, 2], rsm: [S_0, S_0]", shape = ellipse] +_1_20 [label = "27 Range , input: [3, 2], rsm: [S_0, S_0]", shape = ellipse] +_1_21 [label = "28 Intermediate input: 1, rsm: S_2, input: [0, 2]", shape = plain] +_1_22 [label = "29 Intermediate input: 1, rsm: S_2, input: [3, 2]", shape = plain] +_1_23 [label = "3 Range , input: [0, 0], rsm: [S_0, S_2]", shape = ellipse] +_1_24 [label = "30 Range , input: [0, 1], rsm: [S_0, S_2]", shape = ellipse] +_1_25 [label = "31 Range , input: [1, 2], rsm: [S_2, S_0]", shape = ellipse] +_1_26 [label = "32 Range , input: [3, 1], rsm: [S_0, S_2]", shape = ellipse] +_1_27 [label = "33 Intermediate input: 3, rsm: S_1, input: [0, 1]", shape = plain] +_1_28 [label = "34 Terminal ')', input: [1, 2]", shape = rectangle] +_1_29 [label = "35 Intermediate input: 3, rsm: S_1, input: [3, 1]", shape = plain] +_1_30 [label = "36 Intermediate input: 0, rsm: S_1, input: [3, 1]", shape = plain] +_1_31 [label = "37 Range , input: [3, 1], rsm: [S_1, S_2]", shape = ellipse] +_1_32 [label = "38 Range , input: [0, 1], rsm: [S_1, S_2]", shape = ellipse] +_1_33 [label = "39 Nonterminal S, input: [3, 1]", shape = invtrapezium] +_1_34 [label = "4 Range , input: [0, 1], rsm: [S_2, S_0]", shape = ellipse] +_1_35 [label = "40 Nonterminal S, input: [0, 1]", shape = invtrapezium] +_1_36 [label = "41 Range , input: [3, 1], rsm: [S_0, S_0]", shape = ellipse] +_1_37 [label = "42 Intermediate input: 0, rsm: S_2, input: [3, 1]", shape = plain] +_1_38 [label = "43 Range , input: [3, 0], rsm: [S_0, S_2]", shape = ellipse] +_1_39 [label = "44 Intermediate input: 0, rsm: S_1, input: [3, 0]", shape = plain] +_1_40 [label = "45 Intermediate input: 3, rsm: S_1, input: [3, 0]", shape = plain] +_1_41 [label = "46 Range , input: [0, 0], rsm: [S_1, S_2]", shape = ellipse] +_1_42 [label = "47 Nonterminal S, input: [0, 0]", shape = invtrapezium] +_1_43 [label = "5 Intermediate input: 3, rsm: S_1, input: [0, 0]", shape = plain] +_1_44 [label = "6 Terminal ')', input: [0, 1]", shape = rectangle] +_1_45 [label = "7 Range , input: [0, 3], rsm: [S_0, S_1]", shape = ellipse] +_1_46 [label = "8 Range , input: [3, 0], rsm: [S_1, S_2]", shape = ellipse] +_1_47 [label = "9 Terminal '(', input: [0, 3]", shape = rectangle] +_1_0->_1_1 +_1_1->_1_12 +_1_2->_1_3 +_1_3->_1_4 +_1_4->_1_5 +_1_4->_1_6 +_1_5->_1_7 +_1_5->_1_8 +_1_6->_1_9 +_1_7->_1_10 +_1_7->_1_11 +_1_8->_1_13 +_1_8->_1_14 +_1_10->_1_15 +_1_11->_1_16 +_1_12->_1_23 +_1_12->_1_34 +_1_13->_1_17 +_1_14->_1_18 +_1_16->_1_19 +_1_17->_1_3 +_1_17->_1_45 +_1_18->_1_20 +_1_19->_1_21 +_1_20->_1_22 +_1_21->_1_24 +_1_21->_1_25 +_1_22->_1_26 +_1_22->_1_25 +_1_23->_1_43 +_1_24->_1_27 +_1_25->_1_28 +_1_26->_1_29 +_1_26->_1_30 +_1_27->_1_45 +_1_27->_1_31 +_1_29->_1_13 +_1_29->_1_31 +_1_30->_1_10 +_1_30->_1_32 +_1_31->_1_33 +_1_32->_1_35 +_1_33->_1_36 +_1_34->_1_44 +_1_35->_1_1 +_1_36->_1_37 +_1_37->_1_38 +_1_37->_1_34 +_1_38->_1_39 +_1_38->_1_40 +_1_39->_1_10 +_1_39->_1_41 +_1_40->_1_13 +_1_40->_1_46 +_1_41->_1_42 +_1_43->_1_45 +_1_43->_1_46 +_1_45->_1_47 +_1_46->_1_2 +} + +subgraph cluster_2{ +labelloc="t" +_2_0 [label = "0 Nonterminal S, input: [0, 2]", shape = invtrapezium] +_2_1 [label = "1 Range , input: [0, 2], rsm: [S_0, S_0]", shape = ellipse] +_2_2 [label = "10 Nonterminal S, input: [3, 1]", shape = invtrapezium] +_2_3 [label = "11 Range , input: [3, 1], rsm: [S_0, S_0]", shape = ellipse] +_2_4 [label = "12 Intermediate input: 0, rsm: S_2, input: [3, 1]", shape = plain] +_2_5 [label = "13 Range , input: [3, 0], rsm: [S_0, S_2]", shape = ellipse] +_2_6 [label = "14 Range , input: [0, 1], rsm: [S_2, S_0]", shape = ellipse] +_2_7 [label = "15 Intermediate input: 0, rsm: S_1, input: [3, 0]", shape = plain] +_2_8 [label = "16 Intermediate input: 3, rsm: S_1, input: [3, 0]", shape = plain] +_2_9 [label = "17 Terminal ')', input: [0, 1]", shape = rectangle] +_2_10 [label = "18 Range , input: [3, 0], rsm: [S_0, S_1]", shape = ellipse] +_2_11 [label = "19 Range , input: [0, 0], rsm: [S_1, S_2]", shape = ellipse] +_2_12 [label = "2 Intermediate input: 1, rsm: S_2, input: [0, 2]", shape = plain] +_2_13 [label = "20 Range , input: [3, 3], rsm: [S_0, S_1]", shape = ellipse] +_2_14 [label = "21 Range , input: [3, 0], rsm: [S_1, S_2]", shape = ellipse] +_2_15 [label = "22 Terminal '(', input: [3, 0]", shape = rectangle] +_2_16 [label = "23 Nonterminal S, input: [0, 0]", shape = invtrapezium] +_2_17 [label = "24 Intermediate input: 0, rsm: S_0, input: [3, 3]", shape = plain] +_2_18 [label = "25 Nonterminal S, input: [3, 0]", shape = invtrapezium] +_2_19 [label = "26 Range , input: [3, 0], rsm: [S_0, S_0]", shape = ellipse] +_2_20 [label = "27 Intermediate input: 2, rsm: S_2, input: [3, 0]", shape = plain] +_2_21 [label = "28 Range , input: [3, 2], rsm: [S_0, S_2]", shape = ellipse] +_2_22 [label = "29 Range , input: [2, 0], rsm: [S_2, S_0]", shape = ellipse] +_2_23 [label = "3 Range , input: [0, 1], rsm: [S_0, S_2]", shape = ellipse] +_2_24 [label = "30 Intermediate input: 0, rsm: S_1, input: [3, 2]", shape = plain] +_2_25 [label = "31 Intermediate input: 3, rsm: S_1, input: [3, 2]", shape = plain] +_2_26 [label = "32 Terminal ')', input: [2, 0]", shape = rectangle] +_2_27 [label = "33 Range , input: [0, 2], rsm: [S_1, S_2]", shape = ellipse] +_2_28 [label = "34 Range , input: [3, 2], rsm: [S_1, S_2]", shape = ellipse] +_2_29 [label = "35 Nonterminal S, input: [0, 2]", shape = invtrapezium] +_2_30 [label = "36 Nonterminal S, input: [3, 2]", shape = invtrapezium] +_2_31 [label = "37 Range , input: [3, 2], rsm: [S_0, S_0]", shape = ellipse] +_2_32 [label = "38 Intermediate input: 1, rsm: S_2, input: [3, 2]", shape = plain] +_2_33 [label = "39 Range , input: [3, 1], rsm: [S_0, S_2]", shape = ellipse] +_2_34 [label = "4 Range , input: [1, 2], rsm: [S_2, S_0]", shape = ellipse] +_2_35 [label = "40 Intermediate input: 3, rsm: S_1, input: [3, 1]", shape = plain] +_2_36 [label = "41 Intermediate input: 0, rsm: S_1, input: [3, 1]", shape = plain] +_2_37 [label = "42 Range , input: [0, 1], rsm: [S_1, S_2]", shape = ellipse] +_2_38 [label = "43 Nonterminal S, input: [0, 1]", shape = invtrapezium] +_2_39 [label = "44 Range , input: [0, 1], rsm: [S_0, S_0]", shape = ellipse] +_2_40 [label = "45 Intermediate input: 0, rsm: S_2, input: [0, 1]", shape = plain] +_2_41 [label = "46 Range , input: [0, 0], rsm: [S_0, S_2]", shape = ellipse] +_2_42 [label = "47 Intermediate input: 3, rsm: S_1, input: [0, 0]", shape = plain] +_2_43 [label = "5 Intermediate input: 3, rsm: S_1, input: [0, 1]", shape = plain] +_2_44 [label = "6 Terminal ')', input: [1, 2]", shape = rectangle] +_2_45 [label = "7 Range , input: [0, 3], rsm: [S_0, S_1]", shape = ellipse] +_2_46 [label = "8 Range , input: [3, 1], rsm: [S_1, S_2]", shape = ellipse] +_2_47 [label = "9 Terminal '(', input: [0, 3]", shape = rectangle] +_2_0->_2_1 +_2_1->_2_12 +_2_2->_2_3 +_2_3->_2_4 +_2_4->_2_5 +_2_4->_2_6 +_2_5->_2_7 +_2_5->_2_8 +_2_6->_2_9 +_2_7->_2_10 +_2_7->_2_11 +_2_8->_2_13 +_2_8->_2_14 +_2_10->_2_15 +_2_11->_2_16 +_2_12->_2_23 +_2_12->_2_34 +_2_13->_2_17 +_2_14->_2_18 +_2_17->_2_19 +_2_17->_2_45 +_2_18->_2_19 +_2_19->_2_20 +_2_20->_2_21 +_2_20->_2_22 +_2_21->_2_24 +_2_21->_2_25 +_2_22->_2_26 +_2_23->_2_43 +_2_24->_2_10 +_2_24->_2_27 +_2_25->_2_13 +_2_25->_2_28 +_2_27->_2_29 +_2_28->_2_30 +_2_29->_2_1 +_2_30->_2_31 +_2_31->_2_32 +_2_32->_2_33 +_2_32->_2_34 +_2_33->_2_35 +_2_33->_2_36 +_2_34->_2_44 +_2_35->_2_13 +_2_35->_2_46 +_2_36->_2_10 +_2_36->_2_37 +_2_37->_2_38 +_2_38->_2_39 +_2_39->_2_40 +_2_40->_2_41 +_2_40->_2_6 +_2_41->_2_42 +_2_42->_2_45 +_2_42->_2_14 +_2_43->_2_45 +_2_43->_2_46 +_2_45->_2_47 +_2_46->_2_2 +} + +} diff --git a/test-shared/src/test/resources/correctness/tree/LoopDyckGrammar/twoPairs/input.dot b/test-shared/src/test/resources/correctness/tree/LoopDyckGrammar/twoPairs/input.dot new file mode 100644 index 000000000..385ff2cdb --- /dev/null +++ b/test-shared/src/test/resources/correctness/tree/LoopDyckGrammar/twoPairs/input.dot @@ -0,0 +1,8 @@ +digraph Input { + label="Two concatenated linear pairs of brackets, simple loop RSM for Dyck language" + start -> 0; + 0 -> 1 [label = "("]; + 1 -> 2 [label = ")"]; + 2 -> 3 [label = "("]; + 3 -> 4 [label = ")"]; +} \ No newline at end of file diff --git a/test-shared/src/test/resources/correctness/tree/LoopDyckGrammar/twoPairs/result.dot b/test-shared/src/test/resources/correctness/tree/LoopDyckGrammar/twoPairs/result.dot new file mode 100644 index 000000000..af1a0bd98 --- /dev/null +++ b/test-shared/src/test/resources/correctness/tree/LoopDyckGrammar/twoPairs/result.dot @@ -0,0 +1,99 @@ +digraph g { +labelloc="t" +label="" +subgraph cluster_0{ +labelloc="t" +_0_0 [label = "0 Nonterminal S, input: [0, 0]", shape = invtrapezium] +_0_1 [label = "1 Range , input: [0, 0], rsm: [S_0, S_0]", shape = ellipse] +_0_2 [label = "2 Epsilon RSM: S_0, input: [0, 0]", shape = invhouse] +_0_0->_0_1 +_0_1->_0_2 +} + +subgraph cluster_1{ +labelloc="t" +_1_0 [label = "0 Nonterminal S, input: [0, 2]", shape = invtrapezium] +_1_1 [label = "1 Range , input: [0, 2], rsm: [S_0, S_0]", shape = ellipse] +_1_2 [label = "10 Nonterminal S, input: [1, 1]", shape = invtrapezium] +_1_3 [label = "11 Range , input: [1, 1], rsm: [S_0, S_0]", shape = ellipse] +_1_4 [label = "12 Epsilon RSM: S_0, input: [1, 1]", shape = invhouse] +_1_5 [label = "2 Intermediate input: 1, rsm: S_2, input: [0, 2]", shape = plain] +_1_6 [label = "3 Range , input: [0, 1], rsm: [S_0, S_2]", shape = ellipse] +_1_7 [label = "4 Range , input: [1, 2], rsm: [S_2, S_0]", shape = ellipse] +_1_8 [label = "5 Intermediate input: 1, rsm: S_1, input: [0, 1]", shape = plain] +_1_9 [label = "6 Terminal ')', input: [1, 2]", shape = rectangle] +_1_10 [label = "7 Range , input: [0, 1], rsm: [S_0, S_1]", shape = ellipse] +_1_11 [label = "8 Range , input: [1, 1], rsm: [S_1, S_2]", shape = ellipse] +_1_12 [label = "9 Terminal '(', input: [0, 1]", shape = rectangle] +_1_0->_1_1 +_1_1->_1_5 +_1_2->_1_3 +_1_3->_1_4 +_1_5->_1_6 +_1_5->_1_7 +_1_6->_1_8 +_1_7->_1_9 +_1_8->_1_10 +_1_8->_1_11 +_1_10->_1_12 +_1_11->_1_2 +} + +subgraph cluster_2{ +labelloc="t" +_2_0 [label = "0 Nonterminal S, input: [0, 4]", shape = invtrapezium] +_2_1 [label = "1 Range , input: [0, 4], rsm: [S_0, S_0]", shape = ellipse] +_2_2 [label = "10 Nonterminal S, input: [3, 3]", shape = invtrapezium] +_2_3 [label = "11 Range , input: [0, 2], rsm: [S_0, S_0]", shape = ellipse] +_2_4 [label = "12 Range , input: [2, 3], rsm: [S_0, S_1]", shape = ellipse] +_2_5 [label = "13 Range , input: [3, 3], rsm: [S_0, S_0]", shape = ellipse] +_2_6 [label = "14 Intermediate input: 1, rsm: S_2, input: [0, 2]", shape = plain] +_2_7 [label = "15 Terminal '(', input: [2, 3]", shape = rectangle] +_2_8 [label = "16 Epsilon RSM: S_0, input: [3, 3]", shape = invhouse] +_2_9 [label = "17 Range , input: [0, 1], rsm: [S_0, S_2]", shape = ellipse] +_2_10 [label = "18 Range , input: [1, 2], rsm: [S_2, S_0]", shape = ellipse] +_2_11 [label = "19 Intermediate input: 1, rsm: S_1, input: [0, 1]", shape = plain] +_2_12 [label = "2 Intermediate input: 3, rsm: S_2, input: [0, 4]", shape = plain] +_2_13 [label = "20 Terminal ')', input: [1, 2]", shape = rectangle] +_2_14 [label = "21 Range , input: [0, 1], rsm: [S_0, S_1]", shape = ellipse] +_2_15 [label = "22 Range , input: [1, 1], rsm: [S_1, S_2]", shape = ellipse] +_2_16 [label = "23 Terminal '(', input: [0, 1]", shape = rectangle] +_2_17 [label = "24 Nonterminal S, input: [1, 1]", shape = invtrapezium] +_2_18 [label = "25 Range , input: [1, 1], rsm: [S_0, S_0]", shape = ellipse] +_2_19 [label = "26 Epsilon RSM: S_0, input: [1, 1]", shape = invhouse] +_2_20 [label = "3 Range , input: [0, 3], rsm: [S_0, S_2]", shape = ellipse] +_2_21 [label = "4 Range , input: [3, 4], rsm: [S_2, S_0]", shape = ellipse] +_2_22 [label = "5 Intermediate input: 3, rsm: S_1, input: [0, 3]", shape = plain] +_2_23 [label = "6 Terminal ')', input: [3, 4]", shape = rectangle] +_2_24 [label = "7 Range , input: [0, 3], rsm: [S_0, S_1]", shape = ellipse] +_2_25 [label = "8 Range , input: [3, 3], rsm: [S_1, S_2]", shape = ellipse] +_2_26 [label = "9 Intermediate input: 2, rsm: S_0, input: [0, 3]", shape = plain] +_2_0->_2_1 +_2_1->_2_12 +_2_2->_2_5 +_2_3->_2_6 +_2_4->_2_7 +_2_5->_2_8 +_2_6->_2_9 +_2_6->_2_10 +_2_9->_2_11 +_2_10->_2_13 +_2_11->_2_14 +_2_11->_2_15 +_2_12->_2_20 +_2_12->_2_21 +_2_14->_2_16 +_2_15->_2_17 +_2_17->_2_18 +_2_18->_2_19 +_2_20->_2_22 +_2_21->_2_23 +_2_22->_2_24 +_2_22->_2_25 +_2_24->_2_26 +_2_25->_2_2 +_2_26->_2_3 +_2_26->_2_4 +} + +} diff --git a/test-shared/src/test/resources/correctness/tree/SALangGrammar/linear/input.dot b/test-shared/src/test/resources/correctness/tree/SALangGrammar/linear/input.dot new file mode 100644 index 000000000..8a497fee0 --- /dev/null +++ b/test-shared/src/test/resources/correctness/tree/SALangGrammar/linear/input.dot @@ -0,0 +1,6 @@ +digraph Input { + start -> 0; + 0 -> 1 [label = "a"]; + 1 -> 2 [label = "b"]; + 2 -> 3 [label = "c"]; +} \ No newline at end of file diff --git a/test-shared/src/test/resources/correctness/tree/SALangGrammar/linear/result.dot b/test-shared/src/test/resources/correctness/tree/SALangGrammar/linear/result.dot new file mode 100644 index 000000000..5a50eaf21 --- /dev/null +++ b/test-shared/src/test/resources/correctness/tree/SALangGrammar/linear/result.dot @@ -0,0 +1,41 @@ +digraph g { +labelloc="t" +label="" +subgraph cluster_0{ +labelloc="t" +_0_0 [label = "0 Nonterminal S, input: [0, 3]", shape = invtrapezium] +_0_1 [label = "1 Range , input: [0, 3], rsm: [S_0, S_3]", shape = ellipse] +_0_2 [label = "10 Range , input: [1, 2], rsm: [S_2, S_1]", shape = ellipse] +_0_3 [label = "11 Intermediate input: 1, rsm: A_1, input: [0, 2]", shape = plain] +_0_4 [label = "12 Terminal 'a', input: [0, 1]", shape = rectangle] +_0_5 [label = "13 Terminal 'b', input: [1, 2]", shape = rectangle] +_0_6 [label = "14 Range , input: [0, 1], rsm: [A_0, A_1]", shape = ellipse] +_0_7 [label = "15 Range , input: [1, 2], rsm: [A_1, A_2]", shape = ellipse] +_0_8 [label = "2 Intermediate input: 2, rsm: S_1, input: [0, 3]", shape = plain] +_0_9 [label = "3 Range , input: [0, 2], rsm: [S_0, S_1]", shape = ellipse] +_0_10 [label = "4 Range , input: [2, 3], rsm: [S_1, S_3]", shape = ellipse] +_0_11 [label = "5 Nonterminal A, input: [0, 2]", shape = invtrapezium] +_0_12 [label = "6 Intermediate input: 1, rsm: S_2, input: [0, 2]", shape = plain] +_0_13 [label = "7 Terminal 'c', input: [2, 3]", shape = rectangle] +_0_14 [label = "8 Range , input: [0, 2], rsm: [A_0, A_2]", shape = ellipse] +_0_15 [label = "9 Range , input: [0, 1], rsm: [S_0, S_2]", shape = ellipse] +_0_0->_0_1 +_0_1->_0_8 +_0_2->_0_5 +_0_3->_0_6 +_0_3->_0_7 +_0_6->_0_4 +_0_7->_0_5 +_0_8->_0_9 +_0_8->_0_10 +_0_9->_0_11 +_0_9->_0_12 +_0_10->_0_13 +_0_11->_0_14 +_0_12->_0_15 +_0_12->_0_2 +_0_14->_0_3 +_0_15->_0_4 +} + +} diff --git a/test-shared/src/test/resources/correctness/tree/SimplifiedDyckGrammar/linear/input.dot b/test-shared/src/test/resources/correctness/tree/SimplifiedDyckGrammar/linear/input.dot new file mode 100644 index 000000000..8b489406c --- /dev/null +++ b/test-shared/src/test/resources/correctness/tree/SimplifiedDyckGrammar/linear/input.dot @@ -0,0 +1,5 @@ +digraph Input { + start -> 0; + 0 -> 1 [label = "("]; + 1 -> 2 [label = ")"]; +} \ No newline at end of file diff --git a/test-shared/src/test/resources/correctness/tree/SimplifiedDyckGrammar/linear/result.dot b/test-shared/src/test/resources/correctness/tree/SimplifiedDyckGrammar/linear/result.dot new file mode 100644 index 000000000..15222f7ce --- /dev/null +++ b/test-shared/src/test/resources/correctness/tree/SimplifiedDyckGrammar/linear/result.dot @@ -0,0 +1,42 @@ +digraph g { +labelloc="t" +label="" +subgraph cluster_0{ +labelloc="t" +_0_0 [label = "0 Nonterminal S, input: [0, 0]", shape = invtrapezium] +_0_1 [label = "1 Range , input: [0, 0], rsm: [S_0, S_0]", shape = ellipse] +_0_2 [label = "2 Epsilon RSM: S_0, input: [0, 0]", shape = invhouse] +_0_0->_0_1 +_0_1->_0_2 +} + +subgraph cluster_1{ +labelloc="t" +_1_0 [label = "0 Nonterminal S, input: [0, 2]", shape = invtrapezium] +_1_1 [label = "1 Range , input: [0, 2], rsm: [S_0, S_3]", shape = ellipse] +_1_2 [label = "10 Nonterminal S, input: [1, 1]", shape = invtrapezium] +_1_3 [label = "11 Range , input: [1, 1], rsm: [S_0, S_0]", shape = ellipse] +_1_4 [label = "12 Epsilon RSM: S_0, input: [1, 1]", shape = invhouse] +_1_5 [label = "2 Intermediate input: 1, rsm: S_2, input: [0, 2]", shape = plain] +_1_6 [label = "3 Range , input: [0, 1], rsm: [S_0, S_2]", shape = ellipse] +_1_7 [label = "4 Range , input: [1, 2], rsm: [S_2, S_3]", shape = ellipse] +_1_8 [label = "5 Intermediate input: 1, rsm: S_1, input: [0, 1]", shape = plain] +_1_9 [label = "6 Terminal ')', input: [1, 2]", shape = rectangle] +_1_10 [label = "7 Range , input: [0, 1], rsm: [S_0, S_1]", shape = ellipse] +_1_11 [label = "8 Range , input: [1, 1], rsm: [S_1, S_2]", shape = ellipse] +_1_12 [label = "9 Terminal '(', input: [0, 1]", shape = rectangle] +_1_0->_1_1 +_1_1->_1_5 +_1_2->_1_3 +_1_3->_1_4 +_1_5->_1_6 +_1_5->_1_7 +_1_6->_1_8 +_1_7->_1_9 +_1_8->_1_10 +_1_8->_1_11 +_1_10->_1_12 +_1_11->_1_2 +} + +} diff --git a/test-shared/src/test/resources/correctness/tree/StrangeDyckGrammar/linear/input.dot b/test-shared/src/test/resources/correctness/tree/StrangeDyckGrammar/linear/input.dot new file mode 100644 index 000000000..2e11c7190 --- /dev/null +++ b/test-shared/src/test/resources/correctness/tree/StrangeDyckGrammar/linear/input.dot @@ -0,0 +1,6 @@ +digraph Input { + start -> 0; + 0 -> 1 [label = "("]; + 1 -> 2 [label = "a"]; + 2 -> 3 [label = ")"]; +} \ No newline at end of file diff --git a/test-shared/src/test/resources/correctness/tree/StrangeDyckGrammar/linear/result.dot b/test-shared/src/test/resources/correctness/tree/StrangeDyckGrammar/linear/result.dot new file mode 100644 index 000000000..8d3b00501 --- /dev/null +++ b/test-shared/src/test/resources/correctness/tree/StrangeDyckGrammar/linear/result.dot @@ -0,0 +1,33 @@ +digraph g { +labelloc="t" +label="" +subgraph cluster_0{ +labelloc="t" +_0_0 [label = "0 Nonterminal S, input: [0, 3]", shape = invtrapezium] +_0_1 [label = "1 Range , input: [0, 3], rsm: [S_0, S_2]", shape = ellipse] +_0_2 [label = "10 Nonterminal S, input: [1, 2]", shape = invtrapezium] +_0_3 [label = "11 Range , input: [1, 2], rsm: [S_0, S_2]", shape = ellipse] +_0_4 [label = "12 Terminal 'a', input: [1, 2]", shape = rectangle] +_0_5 [label = "2 Intermediate input: 2, rsm: S_3, input: [0, 3]", shape = plain] +_0_6 [label = "3 Range , input: [0, 2], rsm: [S_0, S_3]", shape = ellipse] +_0_7 [label = "4 Range , input: [2, 3], rsm: [S_3, S_2]", shape = ellipse] +_0_8 [label = "5 Intermediate input: 1, rsm: S_1, input: [0, 2]", shape = plain] +_0_9 [label = "6 Terminal ')', input: [2, 3]", shape = rectangle] +_0_10 [label = "7 Range , input: [0, 1], rsm: [S_0, S_1]", shape = ellipse] +_0_11 [label = "8 Range , input: [1, 2], rsm: [S_1, S_3]", shape = ellipse] +_0_12 [label = "9 Terminal '(', input: [0, 1]", shape = rectangle] +_0_0->_0_1 +_0_1->_0_5 +_0_2->_0_3 +_0_3->_0_4 +_0_5->_0_6 +_0_5->_0_7 +_0_6->_0_8 +_0_7->_0_9 +_0_8->_0_10 +_0_8->_0_11 +_0_10->_0_12 +_0_11->_0_2 +} + +} diff --git a/test-shared/src/test/resources/correctness/tree/StrangeDyckGrammar/nothingPath/input.dot b/test-shared/src/test/resources/correctness/tree/StrangeDyckGrammar/nothingPath/input.dot new file mode 100644 index 000000000..c7cc8faa7 --- /dev/null +++ b/test-shared/src/test/resources/correctness/tree/StrangeDyckGrammar/nothingPath/input.dot @@ -0,0 +1,6 @@ +digraph Input { + start -> 0; + 0 -> 1 [label = "("]; + 4 -> 2 [label = "a"]; + 2 -> 3 [label = ")"]; +} \ No newline at end of file diff --git a/test-shared/src/test/resources/correctness/tree/StrangeDyckGrammar/nothingPath/result.dot b/test-shared/src/test/resources/correctness/tree/StrangeDyckGrammar/nothingPath/result.dot new file mode 100644 index 000000000..fab3d9d46 --- /dev/null +++ b/test-shared/src/test/resources/correctness/tree/StrangeDyckGrammar/nothingPath/result.dot @@ -0,0 +1,4 @@ +digraph g { +labelloc="t" +label="" +} diff --git a/test-shared/src/test/resources/grammars/a/ScanerlessGrammarDsl.kt b/test-shared/src/test/resources/grammars/a/ScanerlessGrammarDsl.kt new file mode 100644 index 000000000..cbdcb0490 --- /dev/null +++ b/test-shared/src/test/resources/grammars/a/ScanerlessGrammarDsl.kt @@ -0,0 +1,9 @@ +package grammars.a + +import org.ucfs.grammar.combinator.Grammar +import org.ucfs.grammar.combinator.regexp.Nt +import org.ucfs.rsm.symbol.Term + +class ScanerlessGrammarDsl : Grammar() { + val S by Nt(Term("a")).asStart() +} \ No newline at end of file diff --git a/test-shared/src/test/resources/grammars/a/grammar.rsm b/test-shared/src/test/resources/grammars/a/grammar.rsm new file mode 100644 index 000000000..b2a2b54ba --- /dev/null +++ b/test-shared/src/test/resources/grammars/a/grammar.rsm @@ -0,0 +1,4 @@ +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/test-shared/src/test/resources/grammars/a/oneLineErrorInputs.txt b/test-shared/src/test/resources/grammars/a/oneLineErrorInputs.txt new file mode 100644 index 000000000..0f05b8e16 --- /dev/null +++ b/test-shared/src/test/resources/grammars/a/oneLineErrorInputs.txt @@ -0,0 +1,4 @@ + +a a +a a a +a a a a \ No newline at end of file diff --git a/test-shared/src/test/resources/grammars/a/oneLineInputs.txt b/test-shared/src/test/resources/grammars/a/oneLineInputs.txt new file mode 100644 index 000000000..2e65efe2a --- /dev/null +++ b/test-shared/src/test/resources/grammars/a/oneLineInputs.txt @@ -0,0 +1 @@ +a \ No newline at end of file diff --git a/test-shared/src/test/resources/grammars/aBStar/ScanerlessGrammarDsl.kt b/test-shared/src/test/resources/grammars/aBStar/ScanerlessGrammarDsl.kt new file mode 100644 index 000000000..d2b31d29b --- /dev/null +++ b/test-shared/src/test/resources/grammars/aBStar/ScanerlessGrammarDsl.kt @@ -0,0 +1,9 @@ +package grammars.aBStar + +import org.ucfs.grammar.combinator.Grammar +import org.ucfs.grammar.combinator.extension.StringExtension.many +import org.ucfs.grammar.combinator.regexp.Nt + +class ScanerlessGrammarDsl : Grammar() { + val S by Nt(many("ab")).asStart() +} \ No newline at end of file diff --git a/test-shared/src/test/resources/grammars/aBStar/grammar.rsm b/test-shared/src/test/resources/grammars/aBStar/grammar.rsm new file mode 100644 index 000000000..78a071513 --- /dev/null +++ b/test-shared/src/test/resources/grammars/aBStar/grammar.rsm @@ -0,0 +1,3 @@ +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("ab")) \ No newline at end of file diff --git a/test-shared/src/test/resources/grammars/aBStar/oneLineErrorInputs.txt b/test-shared/src/test/resources/grammars/aBStar/oneLineErrorInputs.txt new file mode 100644 index 000000000..47db6bc2c --- /dev/null +++ b/test-shared/src/test/resources/grammars/aBStar/oneLineErrorInputs.txt @@ -0,0 +1,7 @@ +ba ab +ab dc ac +ba ba ca +ba ab ad +c a a a b a +b a +c a b \ No newline at end of file diff --git a/test-shared/src/test/resources/grammars/aBStar/oneLineInputs.txt b/test-shared/src/test/resources/grammars/aBStar/oneLineInputs.txt new file mode 100644 index 000000000..43352e4f5 --- /dev/null +++ b/test-shared/src/test/resources/grammars/aBStar/oneLineInputs.txt @@ -0,0 +1,6 @@ + +ab +ab ab +ab ab ab +ab ab ab ab +ab ab ab ab ab \ No newline at end of file diff --git a/test-shared/src/test/resources/grammars/aStar/ScanerlessGrammarDsl.kt b/test-shared/src/test/resources/grammars/aStar/ScanerlessGrammarDsl.kt new file mode 100644 index 000000000..d90138d27 --- /dev/null +++ b/test-shared/src/test/resources/grammars/aStar/ScanerlessGrammarDsl.kt @@ -0,0 +1,9 @@ +package grammars.aStar + +import org.ucfs.grammar.combinator.Grammar +import org.ucfs.grammar.combinator.extension.StringExtension.many +import org.ucfs.grammar.combinator.regexp.Nt + +class ScanerlessGrammarDsl : Grammar() { + val S by Nt(many("a")).asStart() +} \ No newline at end of file diff --git a/test-shared/src/test/resources/grammars/aStar/grammar.rsm b/test-shared/src/test/resources/grammars/aStar/grammar.rsm new file mode 100644 index 000000000..d706df3a2 --- /dev/null +++ b/test-shared/src/test/resources/grammars/aStar/grammar.rsm @@ -0,0 +1,3 @@ +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")) \ No newline at end of file diff --git a/test-shared/src/test/resources/grammars/aStar/oneLineErrorInputs.txt b/test-shared/src/test/resources/grammars/aStar/oneLineErrorInputs.txt new file mode 100644 index 000000000..90b4056db --- /dev/null +++ b/test-shared/src/test/resources/grammars/aStar/oneLineErrorInputs.txt @@ -0,0 +1,8 @@ +aa +c b a +a b c +b b a +cd a +c a a a b a +b a +c a b \ No newline at end of file diff --git a/test-shared/src/test/resources/grammars/aStar/oneLineInputs.txt b/test-shared/src/test/resources/grammars/aStar/oneLineInputs.txt new file mode 100644 index 000000000..fc487aa39 --- /dev/null +++ b/test-shared/src/test/resources/grammars/aStar/oneLineInputs.txt @@ -0,0 +1,8 @@ + +a +a a +a a a +a a a a +a a a a a +a a a a a a +a a a a a a a \ No newline at end of file diff --git a/test-shared/src/test/resources/grammars/ab/ScanerlessGrammarDsl.kt b/test-shared/src/test/resources/grammars/ab/ScanerlessGrammarDsl.kt new file mode 100644 index 000000000..c58ef9e75 --- /dev/null +++ b/test-shared/src/test/resources/grammars/ab/ScanerlessGrammarDsl.kt @@ -0,0 +1,9 @@ +package grammars.ab + +import org.ucfs.grammar.combinator.Grammar +import org.ucfs.grammar.combinator.extension.StringExtension.times +import org.ucfs.grammar.combinator.regexp.Nt + +class ScanerlessGrammarDsl : Grammar() { + val S by Nt("a" * "b").asStart() +} \ No newline at end of file diff --git a/test-shared/src/test/resources/grammars/ab/grammar.rsm b/test-shared/src/test/resources/grammars/ab/grammar.rsm new file mode 100644 index 000000000..c5611e4a6 --- /dev/null +++ b/test-shared/src/test/resources/grammars/ab/grammar.rsm @@ -0,0 +1,7 @@ +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=true) + +TerminalEdge(tail=0,head=1,terminal=Terminal("a")) +TerminalEdge(tail=1,head=2,terminal=Terminal("b")) diff --git a/test-shared/src/test/resources/grammars/ab/oneLineErrorInputs.txt b/test-shared/src/test/resources/grammars/ab/oneLineErrorInputs.txt new file mode 100644 index 000000000..67962cf0c --- /dev/null +++ b/test-shared/src/test/resources/grammars/ab/oneLineErrorInputs.txt @@ -0,0 +1,8 @@ + +a +b +a a b +a b b +a a b b +b a +a b a b \ No newline at end of file diff --git a/test-shared/src/test/resources/grammars/ab/oneLineInputs.txt b/test-shared/src/test/resources/grammars/ab/oneLineInputs.txt new file mode 100644 index 000000000..9eb1507c0 --- /dev/null +++ b/test-shared/src/test/resources/grammars/ab/oneLineInputs.txt @@ -0,0 +1 @@ +a b \ No newline at end of file diff --git a/test-shared/src/test/resources/grammars/abc/ScanerlessGrammarDsl.kt b/test-shared/src/test/resources/grammars/abc/ScanerlessGrammarDsl.kt new file mode 100644 index 000000000..89e5fc4cc --- /dev/null +++ b/test-shared/src/test/resources/grammars/abc/ScanerlessGrammarDsl.kt @@ -0,0 +1,12 @@ +package grammars.abc + +import org.ucfs.grammar.combinator.Grammar +import org.ucfs.grammar.combinator.extension.StringExtension.times +import org.ucfs.grammar.combinator.regexp.* +import org.ucfs.rsm.symbol.Term + +class ScanerlessGrammarDsl: Grammar() { + val A by Nt("a" * "b") + val B by Nt(Term("b")) + val S by Nt("a" * B * "c" or A * "c").asStart() +} \ No newline at end of file diff --git a/test-shared/src/test/resources/grammars/abc/grammar.rsm b/test-shared/src/test/resources/grammars/abc/grammar.rsm new file mode 100644 index 000000000..68127c9d4 --- /dev/null +++ b/test-shared/src/test/resources/grammars/abc/grammar.rsm @@ -0,0 +1,20 @@ +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=3,nonterminal=Nonterminal("S"),isStart=false,isFinal=true) +State(id=4,nonterminal=Nonterminal("S"),isStart=false,isFinal=false) +State(id=5,nonterminal=Nonterminal("S"),isStart=false,isFinal=true) +State(id=6,nonterminal=Nonterminal("A"),isStart=true,isFinal=false) +State(id=7,nonterminal=Nonterminal("A"),isStart=false,isFinal=false) +State(id=8,nonterminal=Nonterminal("A"),isStart=false,isFinal=true) +State(id=9,nonterminal=Nonterminal("B"),isStart=true,isFinal=false) +State(id=10,nonterminal=Nonterminal("B"),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/test-shared/src/test/resources/grammars/abc/oneLineErrorInputs.txt b/test-shared/src/test/resources/grammars/abc/oneLineErrorInputs.txt new file mode 100644 index 000000000..a3dc519f1 --- /dev/null +++ b/test-shared/src/test/resources/grammars/abc/oneLineErrorInputs.txt @@ -0,0 +1,10 @@ + +a +b +c +a b +a c +b c +a b b +a c c +c b a \ No newline at end of file diff --git a/test-shared/src/test/resources/grammars/abc/oneLineInputs.txt b/test-shared/src/test/resources/grammars/abc/oneLineInputs.txt new file mode 100644 index 000000000..ed2c580a0 --- /dev/null +++ b/test-shared/src/test/resources/grammars/abc/oneLineInputs.txt @@ -0,0 +1 @@ +a b c \ No newline at end of file diff --git a/test-shared/src/test/resources/grammars/ambiguous/ScanerlessGrammarDsl.kt b/test-shared/src/test/resources/grammars/ambiguous/ScanerlessGrammarDsl.kt new file mode 100644 index 000000000..f1a5994af --- /dev/null +++ b/test-shared/src/test/resources/grammars/ambiguous/ScanerlessGrammarDsl.kt @@ -0,0 +1,13 @@ +package grammars.ambiguous + +import org.ucfs.grammar.combinator.Grammar +import org.ucfs.grammar.combinator.extension.StringExtension.or +import org.ucfs.grammar.combinator.regexp.* + +class ScanerlessGrammarDsl: Grammar() { + val S by Nt().asStart() + + init { + S /= "a" or S or S * S or S * S * S + } +} \ No newline at end of file diff --git a/test-shared/src/test/resources/grammars/ambiguous/grammar.rsm b/test-shared/src/test/resources/grammars/ambiguous/grammar.rsm new file mode 100644 index 000000000..e4aa851e3 --- /dev/null +++ b/test-shared/src/test/resources/grammars/ambiguous/grammar.rsm @@ -0,0 +1,10 @@ +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) +State(id=2,nonterminal=Nonterminal("S"),isStart=false,isFinal=true) +State(id=3,nonterminal=Nonterminal("S"),isStart=false,isFinal=true) + +TerminalEdge(tail=0,head=3,terminal=Terminal("a")) +NonterminalEdge(tail=0,head=1,nonterminal=Nonterminal("S")) +NonterminalEdge(tail=1,head=2,nonterminal=Nonterminal("S")) +NonterminalEdge(tail=2,head=3,nonterminal=Nonterminal("S")) \ No newline at end of file diff --git a/test-shared/src/test/resources/grammars/ambiguous/oneLineErrorInputs.txt b/test-shared/src/test/resources/grammars/ambiguous/oneLineErrorInputs.txt new file mode 100644 index 000000000..b7b823922 --- /dev/null +++ b/test-shared/src/test/resources/grammars/ambiguous/oneLineErrorInputs.txt @@ -0,0 +1,6 @@ + +a b a +a b b +a c a +a cd a +a aa a \ No newline at end of file diff --git a/test-shared/src/test/resources/grammars/ambiguous/oneLineInputs.txt b/test-shared/src/test/resources/grammars/ambiguous/oneLineInputs.txt new file mode 100644 index 000000000..42238712c --- /dev/null +++ b/test-shared/src/test/resources/grammars/ambiguous/oneLineInputs.txt @@ -0,0 +1,6 @@ +a +a a +a a a +a a a a +a a a a a +a a a a a a \ No newline at end of file diff --git a/test-shared/src/test/resources/grammars/bracket_star_x/ScanerlessGrammarDsl.kt b/test-shared/src/test/resources/grammars/bracket_star_x/ScanerlessGrammarDsl.kt new file mode 100644 index 000000000..61cd06766 --- /dev/null +++ b/test-shared/src/test/resources/grammars/bracket_star_x/ScanerlessGrammarDsl.kt @@ -0,0 +1,15 @@ +package grammars.bracket_star_x + +import org.ucfs.grammar.combinator.Grammar +import org.ucfs.grammar.combinator.extension.StringExtension.or +import org.ucfs.grammar.combinator.extension.StringExtension.times +import org.ucfs.grammar.combinator.regexp.Nt + +class ScanerlessGrammarDsl : Grammar() { + val List by Nt().asStart() + val Elem by Nt("x" or List) + + init { + List /= "[" * Elem + } +} \ No newline at end of file diff --git a/test-shared/src/test/resources/grammars/bracket_star_x/grammar.rsm b/test-shared/src/test/resources/grammars/bracket_star_x/grammar.rsm new file mode 100644 index 000000000..680999574 --- /dev/null +++ b/test-shared/src/test/resources/grammars/bracket_star_x/grammar.rsm @@ -0,0 +1,12 @@ +StartState(id=0,nonterminal=Nonterminal("List"),isStart=true,isFinal=false) +State(id=0,nonterminal=Nonterminal("List"),isStart=true,isFinal=false) +State(id=1,nonterminal=Nonterminal("List"),isStart=false,isFinal=false) +State(id=2,nonterminal=Nonterminal("List"),isStart=false,isFinal=true) +State(id=3,nonterminal=Nonterminal("Elem"),isStart=true,isFinal=false) +State(id=4,nonterminal=Nonterminal("Elem"),isStart=false,isFinal=true) +State(id=5,nonterminal=Nonterminal("Elem"),isStart=false,isFinal=true) + +TerminalEdge(tail=0,head=1,terminal=Terminal("[")) +NonterminalEdge(tail=1,head=2,nonterminal=Nonterminal("Elem")) +TerminalEdge(tail=3,head=4,terminal=Terminal("x")) +NonterminalEdge(tail=3,head=5,nonterminal=Nonterminal("List")) \ No newline at end of file diff --git a/test-shared/src/test/resources/grammars/bracket_star_x/oneLineErrorInputs.txt b/test-shared/src/test/resources/grammars/bracket_star_x/oneLineErrorInputs.txt new file mode 100644 index 000000000..c427b164f --- /dev/null +++ b/test-shared/src/test/resources/grammars/bracket_star_x/oneLineErrorInputs.txt @@ -0,0 +1,6 @@ + +[ x x +[ x [ x +[ x [ +[ x [ x [ [ x +[ [ x [ x x [ \ No newline at end of file diff --git a/test-shared/src/test/resources/grammars/bracket_star_x/oneLineInputs.txt b/test-shared/src/test/resources/grammars/bracket_star_x/oneLineInputs.txt new file mode 100644 index 000000000..ce5240fa6 --- /dev/null +++ b/test-shared/src/test/resources/grammars/bracket_star_x/oneLineInputs.txt @@ -0,0 +1,4 @@ +[ x +[ [ x +[ [ [ x +[ [ [ [ x \ No newline at end of file diff --git a/test-shared/src/test/resources/grammars/cAPlusBStar/ScanerlessGrammarDsl.kt b/test-shared/src/test/resources/grammars/cAPlusBStar/ScanerlessGrammarDsl.kt new file mode 100644 index 000000000..b322316ec --- /dev/null +++ b/test-shared/src/test/resources/grammars/cAPlusBStar/ScanerlessGrammarDsl.kt @@ -0,0 +1,12 @@ +package grammars.cAPlusBStar + +import org.ucfs.grammar.combinator.Grammar +import org.ucfs.grammar.combinator.regexp.many +import org.ucfs.grammar.combinator.regexp.Nt +import org.ucfs.grammar.combinator.regexp.some +import org.ucfs.grammar.combinator.regexp.times +import org.ucfs.rsm.symbol.Term + +class ScanerlessGrammarDsl : Grammar() { + val S by Nt(Term("c") * some(Term("a")) * many(Term("b"))).asStart() +} \ No newline at end of file diff --git a/test-shared/src/test/resources/grammars/cAPlusBStar/grammar.rsm b/test-shared/src/test/resources/grammars/cAPlusBStar/grammar.rsm new file mode 100644 index 000000000..42891e3fb --- /dev/null +++ b/test-shared/src/test/resources/grammars/cAPlusBStar/grammar.rsm @@ -0,0 +1,11 @@ +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) +State(id=2,nonterminal=Nonterminal("S"),isStart=false,isFinal=true) +State(id=3,nonterminal=Nonterminal("S"),isStart=false,isFinal=true) + +TerminalEdge(tail=0,head=1,terminal=Terminal("c")) +TerminalEdge(tail=1,head=2,terminal=Terminal("a")) +TerminalEdge(tail=2,head=2,terminal=Terminal("a")) +TerminalEdge(tail=2,head=3,terminal=Terminal("b")) +TerminalEdge(tail=3,head=3,terminal=Terminal("b")) \ No newline at end of file diff --git a/test-shared/src/test/resources/grammars/cAPlusBStar/oneLineErrorInputs.txt b/test-shared/src/test/resources/grammars/cAPlusBStar/oneLineErrorInputs.txt new file mode 100644 index 000000000..e8076d2cb --- /dev/null +++ b/test-shared/src/test/resources/grammars/cAPlusBStar/oneLineErrorInputs.txt @@ -0,0 +1,7 @@ + +c a a a b a +a b +c c a b +c b b b +c b b a +c a b c a \ No newline at end of file diff --git a/test-shared/src/test/resources/grammars/cAPlusBStar/oneLineInputs.txt b/test-shared/src/test/resources/grammars/cAPlusBStar/oneLineInputs.txt new file mode 100644 index 000000000..160154ea2 --- /dev/null +++ b/test-shared/src/test/resources/grammars/cAPlusBStar/oneLineInputs.txt @@ -0,0 +1,6 @@ +c a b +c a a b b +c a +c a b b +c a a a a b b b +c a a a a \ No newline at end of file diff --git a/test-shared/src/test/resources/grammars/c_a_star_b_star/ScanerlessGrammarDsl.kt b/test-shared/src/test/resources/grammars/c_a_star_b_star/ScanerlessGrammarDsl.kt new file mode 100644 index 000000000..389baa6f6 --- /dev/null +++ b/test-shared/src/test/resources/grammars/c_a_star_b_star/ScanerlessGrammarDsl.kt @@ -0,0 +1,12 @@ +package grammars.c_a_star_b_star + +import org.ucfs.grammar.combinator.Grammar +import org.ucfs.grammar.combinator.extension.StringExtension.many +import org.ucfs.grammar.combinator.extension.StringExtension.times +import org.ucfs.grammar.combinator.regexp.Nt +import org.ucfs.grammar.combinator.regexp.times + + +class ScanerlessGrammarDsl : Grammar() { + val S by Nt("c" * many("a") * many("b")).asStart() +} \ No newline at end of file diff --git a/test-shared/src/test/resources/grammars/c_a_star_b_star/grammar.rsm b/test-shared/src/test/resources/grammars/c_a_star_b_star/grammar.rsm new file mode 100644 index 000000000..a03e30e36 --- /dev/null +++ b/test-shared/src/test/resources/grammars/c_a_star_b_star/grammar.rsm @@ -0,0 +1,12 @@ +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) +State(id=2,nonterminal=Nonterminal("S"),isStart=false,isFinal=true) +State(id=3,nonterminal=Nonterminal("S"),isStart=false,isFinal=true) + +TerminalEdge(tail=0,head=1,terminal=Terminal("c")) +TerminalEdge(tail=1,head=2,terminal=Terminal("a")) +TerminalEdge(tail=2,head=2,terminal=Terminal("a")) +TerminalEdge(tail=1,head=3,terminal=Terminal("b")) +TerminalEdge(tail=2,head=3,terminal=Terminal("b")) +TerminalEdge(tail=3,head=3,terminal=Terminal("b")) \ No newline at end of file diff --git a/test-shared/src/test/resources/grammars/c_a_star_b_star/oneLineErrorInputs.txt b/test-shared/src/test/resources/grammars/c_a_star_b_star/oneLineErrorInputs.txt new file mode 100644 index 000000000..8bfbfe2be --- /dev/null +++ b/test-shared/src/test/resources/grammars/c_a_star_b_star/oneLineErrorInputs.txt @@ -0,0 +1,6 @@ + +a b +c a b b a a +c b b a a a +a a c a a b +b a c a a c b \ No newline at end of file diff --git a/test-shared/src/test/resources/grammars/c_a_star_b_star/oneLineInputs.txt b/test-shared/src/test/resources/grammars/c_a_star_b_star/oneLineInputs.txt new file mode 100644 index 000000000..fdb34940f --- /dev/null +++ b/test-shared/src/test/resources/grammars/c_a_star_b_star/oneLineInputs.txt @@ -0,0 +1,8 @@ +c +c b +c a a b +c a a a b b +c a b b b +c b b +c a a a +c a a b b b b b \ No newline at end of file diff --git a/test-shared/src/test/resources/grammars/dyck/ScanerlessGrammarDsl.kt b/test-shared/src/test/resources/grammars/dyck/ScanerlessGrammarDsl.kt new file mode 100644 index 000000000..31ec62d11 --- /dev/null +++ b/test-shared/src/test/resources/grammars/dyck/ScanerlessGrammarDsl.kt @@ -0,0 +1,13 @@ +package grammars.dyck + +import org.ucfs.grammar.combinator.Grammar +import org.ucfs.grammar.combinator.extension.StringExtension.times +import org.ucfs.grammar.combinator.regexp.* + +class ScanerlessGrammarDsl: Grammar() { + val S by Nt().asStart() + + init { + S /= Epsilon or "(" * S * ")" * S + } +} \ No newline at end of file diff --git a/test-shared/src/test/resources/grammars/dyck/grammar.rsm b/test-shared/src/test/resources/grammars/dyck/grammar.rsm new file mode 100644 index 000000000..26f196c63 --- /dev/null +++ b/test-shared/src/test/resources/grammars/dyck/grammar.rsm @@ -0,0 +1,10 @@ +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/test-shared/src/test/resources/grammars/dyck/oneLineErrorInputs.txt b/test-shared/src/test/resources/grammars/dyck/oneLineErrorInputs.txt new file mode 100644 index 000000000..27743dfbc --- /dev/null +++ b/test-shared/src/test/resources/grammars/dyck/oneLineErrorInputs.txt @@ -0,0 +1,7 @@ +( +) +( ( ) +( ) ) +( ( ) +) ( ) ( +) ) ) ( ( ( \ No newline at end of file diff --git a/test-shared/src/test/resources/grammars/dyck/oneLineInputs.txt b/test-shared/src/test/resources/grammars/dyck/oneLineInputs.txt new file mode 100644 index 000000000..5b2413505 --- /dev/null +++ b/test-shared/src/test/resources/grammars/dyck/oneLineInputs.txt @@ -0,0 +1,6 @@ + +( ) +( ( ) ) +( ) ( ) +( ( ) ) ( ) +( ( ( ( ) ) ) ) diff --git a/test-shared/src/test/resources/grammars/g1/ScanerlessGrammarDsl.kt b/test-shared/src/test/resources/grammars/g1/ScanerlessGrammarDsl.kt new file mode 100644 index 000000000..81c88b793 --- /dev/null +++ b/test-shared/src/test/resources/grammars/g1/ScanerlessGrammarDsl.kt @@ -0,0 +1,16 @@ +package grammars.g1 + +import org.ucfs.grammar.combinator.Grammar +import org.ucfs.grammar.combinator.extension.StringExtension.times +import org.ucfs.grammar.combinator.regexp.Nt +import org.ucfs.grammar.combinator.regexp.Option +import org.ucfs.grammar.combinator.regexp.or + +class ScanerlessGrammarDsl : Grammar() { + val S by Nt().asStart() + + init { + S /= "subClassOf_r" * Option(S) * "subClassOf" or + "type_r" * Option(S) * "type" + } +} \ No newline at end of file diff --git a/test-shared/src/test/resources/grammars/g1/grammar.rsm b/test-shared/src/test/resources/grammars/g1/grammar.rsm new file mode 100644 index 000000000..fb0ca6316 --- /dev/null +++ b/test-shared/src/test/resources/grammars/g1/grammar.rsm @@ -0,0 +1,15 @@ +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=3,nonterminal=Nonterminal("S"),isStart=false,isFinal=true) +State(id=4,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/test-shared/src/test/resources/grammars/g1/oneLineErrorInputs.txt b/test-shared/src/test/resources/grammars/g1/oneLineErrorInputs.txt new file mode 100644 index 000000000..b9f5d3e19 --- /dev/null +++ b/test-shared/src/test/resources/grammars/g1/oneLineErrorInputs.txt @@ -0,0 +1,7 @@ + +subClassOf +subClassOf_r +subClassOf_r type_r type +subClassOf_r type subClassOf +type_r subClassOf type subClassOf_r +subClassOf type subClassOf type_r subClassOf_r \ No newline at end of file diff --git a/test-shared/src/test/resources/grammars/g1/oneLineInputs.txt b/test-shared/src/test/resources/grammars/g1/oneLineInputs.txt new file mode 100644 index 000000000..68627f07f --- /dev/null +++ b/test-shared/src/test/resources/grammars/g1/oneLineInputs.txt @@ -0,0 +1,5 @@ +subClassOf_r subClassOf +subClassOf_r type_r type subClassOf +type_r subClassOf_r subClassOf type +subClassOf_r subClassOf_r subClassOf subClassOf +subClassOf_r subClassOf_r type_r subClassOf_r subClassOf type subClassOf subClassOf \ No newline at end of file diff --git a/test-shared/src/test/resources/grammars/g2/ScanerlessGrammarDsl.kt b/test-shared/src/test/resources/grammars/g2/ScanerlessGrammarDsl.kt new file mode 100644 index 000000000..6c95899c3 --- /dev/null +++ b/test-shared/src/test/resources/grammars/g2/ScanerlessGrammarDsl.kt @@ -0,0 +1,14 @@ +package grammars.g2 + +import org.ucfs.grammar.combinator.Grammar +import org.ucfs.grammar.combinator.extension.StringExtension.or +import org.ucfs.grammar.combinator.extension.StringExtension.times +import org.ucfs.grammar.combinator.regexp.Nt + +class ScanerlessGrammarDsl : Grammar() { + val S by Nt().asStart() + + init { + S /= "subClassOf" or "subClassOf_r" * S * "subClassOf" + } +} \ No newline at end of file diff --git a/test-shared/src/test/resources/grammars/g2/grammar.rsm b/test-shared/src/test/resources/grammars/g2/grammar.rsm new file mode 100644 index 000000000..cd798bae5 --- /dev/null +++ b/test-shared/src/test/resources/grammars/g2/grammar.rsm @@ -0,0 +1,9 @@ +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=3,nonterminal=Nonterminal("S"),isStart=false,isFinal=true) +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/test-shared/src/test/resources/grammars/g2/oneLineErrorInputs.txt b/test-shared/src/test/resources/grammars/g2/oneLineErrorInputs.txt new file mode 100644 index 000000000..0f584a71d --- /dev/null +++ b/test-shared/src/test/resources/grammars/g2/oneLineErrorInputs.txt @@ -0,0 +1,5 @@ + +subClassOf_r +subClassOf_r subClassOf subClassOf_r +subClassOf subClassOf +subClassOf_r subClassOf_r subClassOf_r \ No newline at end of file diff --git a/test-shared/src/test/resources/grammars/g2/oneLineInputs.txt b/test-shared/src/test/resources/grammars/g2/oneLineInputs.txt new file mode 100644 index 000000000..27209909c --- /dev/null +++ b/test-shared/src/test/resources/grammars/g2/oneLineInputs.txt @@ -0,0 +1,3 @@ +subClassOf +subClassOf_r subClassOf subClassOf +subClassOf_r subClassOf_r subClassOf subClassOf subClassOf \ No newline at end of file diff --git a/test-shared/src/test/resources/grammars/geo/ScanerlessGrammarDsl.kt b/test-shared/src/test/resources/grammars/geo/ScanerlessGrammarDsl.kt new file mode 100644 index 000000000..081d96493 --- /dev/null +++ b/test-shared/src/test/resources/grammars/geo/ScanerlessGrammarDsl.kt @@ -0,0 +1,14 @@ +package grammars.geo + +import org.ucfs.grammar.combinator.Grammar +import org.ucfs.grammar.combinator.extension.StringExtension.times +import org.ucfs.grammar.combinator.regexp.Nt +import org.ucfs.grammar.combinator.regexp.Option + +class ScanerlessGrammarDsl : Grammar() { + val S by Nt().asStart() + + init { + S /= "broaderTransitive" * Option(S) * "broaderTransitive_r" + } +} \ No newline at end of file diff --git a/test-shared/src/test/resources/grammars/geo/grammar.rsm b/test-shared/src/test/resources/grammars/geo/grammar.rsm new file mode 100644 index 000000000..44d46b963 --- /dev/null +++ b/test-shared/src/test/resources/grammars/geo/grammar.rsm @@ -0,0 +1,9 @@ +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=3,nonterminal=Nonterminal("S"),isStart=false,isFinal=true) +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/test-shared/src/test/resources/grammars/geo/oneLineErrorInputs.txt b/test-shared/src/test/resources/grammars/geo/oneLineErrorInputs.txt new file mode 100644 index 000000000..87b23e64e --- /dev/null +++ b/test-shared/src/test/resources/grammars/geo/oneLineErrorInputs.txt @@ -0,0 +1,6 @@ + +broaderTransitive +broaderTransitive_r +broaderTransitive_r broaderTransitive_r +broaderTransitive_r broaderTransitive +broaderTransitive broaderTransitive broaderTransitive_r \ No newline at end of file diff --git a/test-shared/src/test/resources/grammars/geo/oneLineInputs.txt b/test-shared/src/test/resources/grammars/geo/oneLineInputs.txt new file mode 100644 index 000000000..bb0f8f0b9 --- /dev/null +++ b/test-shared/src/test/resources/grammars/geo/oneLineInputs.txt @@ -0,0 +1,3 @@ +broaderTransitive broaderTransitive_r +broaderTransitive broaderTransitive broaderTransitive_r broaderTransitive_r +broaderTransitive broaderTransitive broaderTransitive broaderTransitive_r broaderTransitive_r broaderTransitive_r \ No newline at end of file diff --git a/test-shared/src/test/resources/grammars/java8/GrammarDsll.kt b/test-shared/src/test/resources/grammars/java8/GrammarDsll.kt new file mode 100644 index 000000000..8218fcd95 --- /dev/null +++ b/test-shared/src/test/resources/grammars/java8/GrammarDsll.kt @@ -0,0 +1,545 @@ +package grammars.java8 +import org.ucfs.grammar.combinator.Grammar +import org.ucfs.grammar.combinator.regexp.* + +class GrammarDsl : Grammar() { + var CompilationUnit by Nt() + var Identifier by Nt() + var Literal by Nt() + var Type by Nt() + var PrimitiveType by Nt() + var ReferenceType by Nt() + var Annotation by Nt() + var NumericType by Nt() + var IntegralType by Nt() + var FloatingPointType by Nt() + var ClassOrInterfaceType by Nt() + var TypeVariable by Nt() + var ArrayType by Nt() + var ClassType by Nt() + var InterfaceType by Nt() + var TypeArguments by Nt() + var Dims by Nt() + var TypeParameter by Nt() + var TypeParameterModifier by Nt() + var TypeBound by Nt() + var AdditionalBound by Nt() + var TypeArgumentList by Nt() + var TypeArgument by Nt() + var Wildcard by Nt() + var WildcardBounds by Nt() + var TypeName by Nt() + var PackageOrTypeName by Nt() + var ExpressionName by Nt() + var AmbiguousName by Nt() + var MethodName by Nt() + var PackageName by Nt() + var Result by Nt() + var PackageDeclaration by Nt() + var ImportDeclaration by Nt() + var TypeDeclaration by Nt() + var PackageModifier by Nt() + var SingleTypeImportDeclaration by Nt() + var TypeImportOnDemandDeclaration by Nt() + var SingleStaticImportDeclaration by Nt() + var StaticImportOnDemandDeclaration by Nt() + var ClassDeclaration by Nt() + var InterfaceDeclaration by Nt() + var Throws by Nt() + var NormalClassDeclaration by Nt() + var EnumDeclaration by Nt() + var ClassModifier by Nt() + var TypeParameters by Nt() + var Superclass by Nt() + var Superinterfaces by Nt() + var ClassBody by Nt() + var TypeParameterList by Nt() + var InterfaceTypeList by Nt() + var ClassBodyDeclaration by Nt() + var ClassMemberDeclaration by Nt() + var InstanceInitializer by Nt() + var StaticInitializer by Nt() + var ConstructorDeclaration by Nt() + var FieldDeclaration by Nt() + var MethodDeclaration by Nt() + var FieldModifier by Nt() + var UnannType by Nt() + var VariableDeclaratorList by Nt() + var VariableDeclarator by Nt() + var VariableDeclaratorId by Nt() + var VariableInitializer by Nt() + var Expression by Nt() + var ArrayInitializer by Nt() + var UnannPrimitiveType by Nt() + var UnannReferenceType by Nt() + var UnannClassOrInterfaceType by Nt() + var UnannTypeVariable by Nt() + var UnannArrayType by Nt() + var UnannClassType by Nt() + var UnannInterfaceType by Nt() + var MethodModifier by Nt() + var MethodHeader by Nt() + var MethodBody by Nt() + var MethodDeclarator by Nt() + var FormalParameterList by Nt() + var ReceiverParameter by Nt() + var FormalParameters by Nt() + var LastFormalParameter by Nt() + var FormalParameter by Nt() + var VariableModifier by Nt() + var ExceptionTypeList by Nt() + var ExceptionType by Nt() + var Block by Nt() + var ConstructorModifier by Nt() + var ConstructorDeclarator by Nt() + var ConstructorBody by Nt() + var SimpleTypeName by Nt() + var ExplicitConstructorInvocation by Nt() + var EnumBody by Nt() + var EnumConstantList by Nt() + var EnumConstant by Nt() + var EnumConstantModifier by Nt() + var EnumBodyDeclarations by Nt() + var BlockStatements by Nt() + var ArgumentList by Nt() + var Primary by Nt() + var NormalInterfaceDeclaration by Nt() + var InterfaceModifier by Nt() + var ExtendsInterfaces by Nt() + var InterfaceBody by Nt() + var InterfaceMemberDeclaration by Nt() + var ConstantDeclaration by Nt() + var ConstantModifier by Nt() + var AnnotationTypeDeclaration by Nt() + var AnnotationTypeBody by Nt() + var AnnotationTypeMemberDeclaration by Nt() + var AnnotationTypeElementDeclaration by Nt() + var DefaultValue by Nt() + var NormalAnnotation by Nt() + var ElementValuePairList by Nt() + var ElementValuePair by Nt() + var ElementValue by Nt() + var ElementValueArrayInitializer by Nt() + var ElementValueList by Nt() + var MarkerAnnotation by Nt() + var SingleElementAnnotation by Nt() + var InterfaceMethodDeclaration by Nt() + var AnnotationTypeElementModifier by Nt() + var ConditionalExpression by Nt() + var VariableInitializerList by Nt() + var BlockStatement by Nt() + var LocalVariableDeclarationStatement by Nt() + var LocalVariableDeclaration by Nt() + var Statement by Nt() + var StatementNoShortIf by Nt() + var StatementWithoutTrailingSubstatement by Nt() + var EmptyStatement by Nt() + var LabeledStatement by Nt() + var LabeledStatementNoShortIf by Nt() + var ExpressionStatement by Nt() + var StatementExpression by Nt() + var IfThenStatement by Nt() + var IfThenElseStatement by Nt() + var IfThenElseStatementNoShortIf by Nt() + var AssertStatement by Nt() + var SwitchStatement by Nt() + var SwitchBlock by Nt() + var SwitchBlockStatementGroup by Nt() + var SwitchLabels by Nt() + var SwitchLabel by Nt() + var EnumConstantName by Nt() + var WhileStatement by Nt() + var WhileStatementNoShortIf by Nt() + var DoStatement by Nt() + var InterfaceMethodModifier by Nt() + var ForStatement by Nt() + var ForStatementNoShortIf by Nt() + var BasicForStatement by Nt() + var BasicForStatementNoShortIf by Nt() + var ForInit by Nt() + var ForUpdate by Nt() + var StatementExpressionList by Nt() + var EnhancedForStatement by Nt() + var EnhancedForStatementNoShortIf by Nt() + var BreakStatement by Nt() + var ContinueStatement by Nt() + var ReturnStatement by Nt() + var ThrowStatement by Nt() + var SynchronizedStatement by Nt() + var TryStatement by Nt() + var Catches by Nt() + var CatchClause by Nt() + var CatchFormalParameter by Nt() + var CatchType by Nt() + var Finally by Nt() + var TryWithResourcesStatement by Nt() + var ResourceSpecification by Nt() + var ResourceList by Nt() + var Resource by Nt() + var PrimaryNoNewArray by Nt() + var ClassLiteral by Nt() + var classOrInterfaceTypeToInstantiate by Nt() + var UnqualifiedClassInstanceCreationExpression by Nt() + var ClassInstanceCreationExpression by Nt() + var FieldAccess by Nt() + var TypeArgumentsOrDiamond by Nt() + var ArrayAccess by Nt() + var MethodInvocation by Nt() + var MethodReference by Nt() + var ArrayCreationExpression by Nt() + var DimExprs by Nt() + var DimExpr by Nt() + var LambdaExpression by Nt() + var LambdaParameters by Nt() + var InferredFormalParameterList by Nt() + var LambdaBody by Nt() + var AssignmentExpression by Nt() + var Assignment by Nt() + var LeftHandSide by Nt() + var AssignmentOperator by Nt() + var ConditionalOrExpression by Nt() + var ConditionalAndExpression by Nt() + var InclusiveOrExpression by Nt() + var ExclusiveOrExpression by Nt() + var AndExpression by Nt() + var EqualityExpression by Nt() + var RelationalExpression by Nt() + var ShiftExpression by Nt() + var AdditiveExpression by Nt() + var MultiplicativeExpression by Nt() + var PreIncrementExpression by Nt() + var PreDecrementExpression by Nt() + var UnaryExpressionNotPlusMinus by Nt() + var UnaryExpression by Nt() + var PostfixExpression by Nt() + var PostIncrementExpression by Nt() + var PostDecrementExpression by Nt() + var CastExpression by Nt() + var ConstantExpression by Nt() + + init { + Identifier = Token.ID + + Literal = Token.INTEGERLIT or Token.FLOATINGLIT or Token.BOOLEANLIT or + Token.CHARLIT or Token.STRINGLIT or Token.NULLLIT + + /** + * Productions from §4 (Types, Values, and Variables) + */ + Type = PrimitiveType or ReferenceType + PrimitiveType = Many(Annotation) * NumericType or Many(Annotation) * Token.BOOLEAN + NumericType = IntegralType or FloatingPointType + IntegralType = Token.BYTE or Token.SHORT or Token.INT or Token.LONG or Token.CHAR + FloatingPointType = Token.FLOAT or Token.DOUBLE + ReferenceType = ClassOrInterfaceType or TypeVariable or ArrayType + ClassOrInterfaceType = ClassType or InterfaceType + ClassType = Many(Annotation) * Identifier * Option(TypeArguments) or + ClassOrInterfaceType * Token.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) * Token.BRACKETLEFT * Token.BRACKETRIGHT) + TypeParameter = Many(TypeParameterModifier) * Identifier * Option(TypeBound) + TypeParameterModifier = Annotation + TypeBound = Token.EXTENDS * TypeVariable or Token.EXTENDS * ClassOrInterfaceType * Many(AdditionalBound) + AdditionalBound = Token.ANDBIT * InterfaceType + TypeArguments = Token.LT * TypeArgumentList * Token.GT + TypeArgumentList = TypeArgument * Many(Token.COMMA * TypeArgument) + TypeArgument = ReferenceType or Wildcard + Wildcard = Many(Annotation) * Token.QUESTIONMARK * Option(WildcardBounds) + WildcardBounds = Token.EXTENDS * ReferenceType or Token.SUPER * ReferenceType + + /** + * Productions from §6 (Names) + */ + + TypeName = Identifier or PackageOrTypeName * Token.DOT * Identifier + PackageOrTypeName = Identifier or PackageOrTypeName * Token.DOT * Identifier + ExpressionName = Identifier or AmbiguousName * Token.DOT * Identifier + MethodName = Identifier + PackageName = Identifier or PackageName * Token.DOT * Identifier + AmbiguousName = Identifier or AmbiguousName * Token.DOT * Identifier + + /** + * Productions from §7 (Packages) + */ + + CompilationUnit = Option(PackageDeclaration) * Many(ImportDeclaration) * Many(TypeDeclaration) + PackageDeclaration = Many(PackageModifier) * Token.PACKAGE * Identifier * Many(Token.DOT * Identifier) * Token.SEMICOLON + PackageModifier = Annotation + ImportDeclaration = SingleTypeImportDeclaration or TypeImportOnDemandDeclaration or + SingleStaticImportDeclaration or StaticImportOnDemandDeclaration + SingleTypeImportDeclaration = Token.IMPORT * TypeName * Token.SEMICOLON + TypeImportOnDemandDeclaration = Token.IMPORT * PackageOrTypeName * Token.DOT * Token.STAR * Token.SEMICOLON + SingleStaticImportDeclaration = Token.IMPORT * Token.STATIC * TypeName * Token.DOT * Identifier * Token.SEMICOLON + StaticImportOnDemandDeclaration = Token.IMPORT * Token.STATIC * TypeName * Token.DOT * Token.STAR * Token.SEMICOLON + TypeDeclaration = ClassDeclaration or InterfaceDeclaration or Token.SEMICOLON + + /** + * Productions from §8 (Classes) + */ + + ClassDeclaration = NormalClassDeclaration or EnumDeclaration + NormalClassDeclaration = Many(ClassModifier) * Token.CLASS * Identifier * + Option(TypeParameters) * Option(Superclass) * Option(Superinterfaces) * ClassBody + ClassModifier = Annotation or Token.PUBLIC or Token.PROTECTED or Token.PRIVATE or + Token.ABSTRACT or Token.STATIC or Token.FINAL or Token.STRICTFP + TypeParameters = Token.LT * TypeParameterList * Token.GT + TypeParameterList = TypeParameter * Many(Token.COMMA * TypeParameter) + Superclass = Token.EXTENDS * ClassType + Superinterfaces = Token.IMPLEMENTS * InterfaceTypeList + InterfaceTypeList = InterfaceType * Many(Token.COMMA * InterfaceType) + ClassBody = Token.CURLYLEFT * Many(ClassBodyDeclaration) * Token.CURLYRIGHT + ClassBodyDeclaration = ClassMemberDeclaration or InstanceInitializer or StaticInitializer or ConstructorDeclaration + ClassMemberDeclaration = FieldDeclaration or MethodDeclaration or ClassDeclaration or InterfaceDeclaration or Token.SEMICOLON + FieldDeclaration = Many(FieldModifier) * UnannType * VariableDeclaratorList * Token.SEMICOLON + FieldModifier = Annotation or Token.PUBLIC or Token.PROTECTED or Token.PRIVATE or Token.STATIC or + Token.FINAL or Token.TRANSIENT or Token.VOLATILE + VariableDeclaratorList = VariableDeclarator * Many(Token.COMMA * VariableDeclarator) + VariableDeclarator = VariableDeclaratorId * Option(Token.ASSIGN * VariableInitializer) + VariableDeclaratorId = Identifier * Option(Dims) + VariableInitializer = Expression or ArrayInitializer + UnannType = UnannPrimitiveType or UnannReferenceType + UnannPrimitiveType = NumericType or Token.BOOLEAN + UnannReferenceType = UnannClassOrInterfaceType or UnannTypeVariable or UnannArrayType + UnannClassOrInterfaceType = UnannClassType or UnannInterfaceType + UnannClassType = Identifier * Option(TypeArguments) or + UnannClassOrInterfaceType * Token.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 Token.PUBLIC or Token.PROTECTED or Token.PRIVATE or Token.ABSTRACT or + Token.STATIC or Token.FINAL or Token.SYNCHRONIZED or Token.NATIVE or Token.STRICTFP + MethodHeader = Result * MethodDeclarator * Option(Throws) or + TypeParameters * Many(Annotation) * Result * MethodDeclarator * Option(Throws) + Result = UnannType or Token.VOID + MethodDeclarator = Identifier * Token.PARENTHLEFT * Option(FormalParameterList) * Token.PARENTHRIGHT * Option(Dims) + FormalParameterList = ReceiverParameter or FormalParameters * Token.COMMA * LastFormalParameter or + LastFormalParameter + FormalParameters = FormalParameter * Many(Token.COMMA * FormalParameter) or + ReceiverParameter * Many(Token.COMMA * FormalParameter) + FormalParameter = Many(VariableModifier) * UnannType * VariableDeclaratorId + VariableModifier = Annotation or Token.FINAL + LastFormalParameter = Many(VariableModifier) * UnannType * Many(Annotation) * Token.ELLIPSIS * VariableDeclaratorId or FormalParameter + ReceiverParameter = Many(Annotation) * UnannType * Option(Identifier * Token.DOT) * Token.THIS + Throws = Token.THROWS * ExceptionTypeList + ExceptionTypeList = ExceptionType * Many(Token.COMMA * ExceptionType) + ExceptionType = ClassType or TypeVariable + MethodBody = Block or Token.SEMICOLON + InstanceInitializer = Block + StaticInitializer = Token.STATIC * Block + ConstructorDeclaration = Many(ConstructorModifier) * ConstructorDeclarator * Option(Throws) * ConstructorBody + ConstructorModifier = Annotation or Token.PUBLIC or Token.PROTECTED or Token.PRIVATE + ConstructorDeclarator = Option(TypeParameters) * SimpleTypeName * Token.PARENTHLEFT * Option(FormalParameterList) * Token.PARENTHRIGHT + SimpleTypeName = Identifier + ConstructorBody = Token.CURLYLEFT * Option(ExplicitConstructorInvocation) * Option(BlockStatements) * Token.CURLYRIGHT + ExplicitConstructorInvocation = Option(TypeArguments) * Token.THIS * Token.PARENTHLEFT * Option(ArgumentList) * Token.PARENTHRIGHT * Token.SEMICOLON or + Option(TypeArguments) * Token.SUPER * Token.PARENTHLEFT * Option(ArgumentList) * Token.PARENTHRIGHT * Token.SEMICOLON or + ExpressionName * Token.DOT * Option(TypeArguments) * Token.SUPER * Token.PARENTHLEFT * Option(ArgumentList) * Token.PARENTHRIGHT * Token.SEMICOLON or + Primary * Token.DOT * Option(TypeArguments) * Token.SUPER * Token.PARENTHLEFT * Option(ArgumentList) * Token.PARENTHRIGHT * Token.SEMICOLON + EnumDeclaration = Many(ClassModifier) * Token.ENUM * Identifier * Option(Superinterfaces) * EnumBody + EnumBody = Token.CURLYLEFT * Option(EnumConstantList) * Option(Token.COMMA) * Option(EnumBodyDeclarations) * Token.CURLYRIGHT + EnumConstantList = EnumConstant * Many(Token.COMMA * EnumConstant) + EnumConstant = Many(EnumConstantModifier) * Identifier * Option(Token.PARENTHLEFT * Option(ArgumentList) * Token.PARENTHRIGHT * Option(ClassBody)) + EnumConstantModifier = Annotation + EnumBodyDeclarations = Token.SEMICOLON * Many(ClassBodyDeclaration) + + /** + * Productions from §9 (Interfaces) + */ + + InterfaceDeclaration = NormalInterfaceDeclaration or AnnotationTypeDeclaration + NormalInterfaceDeclaration = + Many(InterfaceModifier) * Token.INTERFACE * Identifier * Option(TypeParameters) * Option(ExtendsInterfaces) * InterfaceBody + InterfaceModifier = Annotation or Token.PUBLIC or Token.PROTECTED or Token.PRIVATE or + Token.ABSTRACT or Token.STATIC or Token.STRICTFP + ExtendsInterfaces = Token.EXTENDS * InterfaceTypeList + InterfaceBody = Token.CURLYLEFT * Many(InterfaceMemberDeclaration) * Token.CURLYRIGHT + InterfaceMemberDeclaration = ConstantDeclaration or InterfaceMethodDeclaration or ClassDeclaration or InterfaceDeclaration or Token.SEMICOLON + ConstantDeclaration = Many(ConstantModifier) * UnannType * VariableDeclaratorList * Token.SEMICOLON + ConstantModifier = Annotation or Token.PUBLIC or Token.STATIC or Token.FINAL + InterfaceMethodDeclaration = Many(InterfaceMethodModifier) * MethodHeader * MethodBody + InterfaceMethodModifier = Annotation or Token.PUBLIC or Token.ABSTRACT or Token.DEFAULT or Token.STATIC or Token.STRICTFP + AnnotationTypeDeclaration = Many(InterfaceModifier) * Token.AT * Token.INTERFACE * Identifier * AnnotationTypeBody + AnnotationTypeBody = Token.CURLYLEFT * Many(AnnotationTypeMemberDeclaration) * Token.CURLYRIGHT + AnnotationTypeMemberDeclaration = AnnotationTypeElementDeclaration or ConstantDeclaration or ClassDeclaration or InterfaceDeclaration or Token.SEMICOLON + AnnotationTypeElementDeclaration = + Many(AnnotationTypeElementModifier) * UnannType * Identifier * Token.PARENTHLEFT * Token.PARENTHRIGHT * Option(Dims) * Option(DefaultValue) * Token.SEMICOLON + AnnotationTypeElementModifier = Annotation or Token.PUBLIC or Token.ABSTRACT + DefaultValue = Token.DEFAULT * ElementValue + Annotation = NormalAnnotation or MarkerAnnotation or SingleElementAnnotation + NormalAnnotation = Token.AT * TypeName * Token.PARENTHLEFT * Option(ElementValuePairList) * Token.PARENTHRIGHT + ElementValuePairList = ElementValuePair * Many(Token.COMMA * ElementValuePair) + ElementValuePair = Identifier * Token.ASSIGN * ElementValue + ElementValue = ConditionalExpression or ElementValueArrayInitializer or Annotation + ElementValueArrayInitializer = Token.CURLYLEFT * Option(ElementValueList) * Option(Token.COMMA) * Token.CURLYRIGHT + ElementValueList = ElementValue * Many(Token.COMMA * ElementValue) + MarkerAnnotation = Token.AT * TypeName + SingleElementAnnotation = Token.AT * TypeName * Token.PARENTHLEFT * ElementValue * Token.PARENTHRIGHT + + /** + * Productions from §10 (Arrays) + */ + + ArrayInitializer = Token.CURLYLEFT * Option(VariableInitializerList) * Option(Token.COMMA) * Token.CURLYRIGHT + VariableInitializerList = VariableInitializer * Many(Token.COMMA * VariableInitializer) + + /** + * Productions from §14 (Blocks and Statements) + */ + + Block = Token.CURLYLEFT * Option(BlockStatements) * Token.CURLYRIGHT + BlockStatements = BlockStatement * Many(BlockStatement) + BlockStatement = LocalVariableDeclarationStatement or ClassDeclaration or Statement + LocalVariableDeclarationStatement = LocalVariableDeclaration * Token.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 = Token.SEMICOLON + LabeledStatement = Identifier * Token.COLON * Statement + LabeledStatementNoShortIf = Identifier * Token.COLON * StatementNoShortIf + ExpressionStatement = StatementExpression * Token.SEMICOLON + StatementExpression = Assignment or PreIncrementExpression or PreDecrementExpression or PostIncrementExpression or + PostDecrementExpression or MethodInvocation or ClassInstanceCreationExpression + IfThenStatement = Token.IF * Token.PARENTHLEFT * Expression * Token.PARENTHRIGHT * Statement + IfThenElseStatement = Token.IF * Token.PARENTHLEFT * Expression * Token.PARENTHRIGHT * StatementNoShortIf * Token.ELSE * Statement + IfThenElseStatementNoShortIf = + Token.IF * Token.PARENTHLEFT * Expression * Token.PARENTHRIGHT * StatementNoShortIf * Token.ELSE * StatementNoShortIf + AssertStatement = Token.ASSERT * Expression * Token.SEMICOLON or + Token.ASSERT * Expression * Token.COLON * Expression * Token.SEMICOLON + SwitchStatement = Token.SWITCH * Token.PARENTHLEFT * Expression * Token.PARENTHRIGHT * SwitchBlock + SwitchBlock = Token.CURLYLEFT * Many(SwitchBlockStatementGroup) * Many(SwitchLabel) * Token.CURLYRIGHT + SwitchBlockStatementGroup = SwitchLabels * BlockStatements + SwitchLabels = Some(SwitchLabel) + SwitchLabel = Token.CASE * ConstantExpression * Token.COLON or + Token.CASE * EnumConstantName * Token.COLON or Token.DEFAULT * Token.COLON + EnumConstantName = Identifier + WhileStatement = Token.WHILE * Token.PARENTHLEFT * Expression * Token.PARENTHRIGHT * Statement + WhileStatementNoShortIf = Token.WHILE * Token.PARENTHLEFT * Expression * Token.PARENTHRIGHT * StatementNoShortIf + DoStatement = Token.DO * Statement * Token.WHILE * Token.PARENTHLEFT * Expression * Token.PARENTHRIGHT * Token.SEMICOLON + ForStatement = BasicForStatement or EnhancedForStatement + ForStatementNoShortIf = BasicForStatementNoShortIf or EnhancedForStatementNoShortIf + BasicForStatement = Token.FOR * Token.PARENTHLEFT * Option(ForInit) * Token.SEMICOLON * Option(Expression) * Token.SEMICOLON * Option(ForUpdate) * Token.PARENTHRIGHT * Statement + BasicForStatementNoShortIf = Token.FOR * Token.PARENTHLEFT * Option(ForInit) * Token.SEMICOLON * Option(Expression) * Token.SEMICOLON * Option(ForUpdate) * Token.PARENTHRIGHT * StatementNoShortIf + ForInit = StatementExpressionList or LocalVariableDeclaration + ForUpdate = StatementExpressionList + StatementExpressionList = StatementExpression * Many(Token.COMMA * StatementExpression) + EnhancedForStatement = Token.FOR * Token.PARENTHLEFT * Many(VariableModifier) * UnannType * VariableDeclaratorId * Token.COLON * Expression * Token.PARENTHRIGHT * Statement + EnhancedForStatementNoShortIf = Token.FOR * Token.PARENTHLEFT * Many(VariableModifier) * UnannType * VariableDeclaratorId * Token.COLON * Expression * Token.PARENTHRIGHT * StatementNoShortIf + BreakStatement = Token.BREAK * Option(Identifier) * Token.SEMICOLON + ContinueStatement = Token.CONTINUE * Option(Identifier) * Token.SEMICOLON + ReturnStatement = Token.RETURN * Option(Expression) * Token.SEMICOLON + ThrowStatement = Token.THROW * Expression * Token.SEMICOLON + SynchronizedStatement = Token.SYNCHRONIZED * Token.PARENTHLEFT * Expression * Token.PARENTHRIGHT * Block + TryStatement = Token.TRY * Block * Catches or Token.TRY * Block * Option(Catches) * Finally or TryWithResourcesStatement + Catches = Some(CatchClause) + CatchClause = Token.CATCH * Token.PARENTHLEFT * CatchFormalParameter * Token.PARENTHRIGHT * Block + CatchFormalParameter = Many(VariableModifier) * CatchType * VariableDeclaratorId + CatchType = UnannClassType * Many(Token.ORBIT * ClassType) + Finally = Token.FINALLY * Block + TryWithResourcesStatement = Token.TRY * ResourceSpecification * Block * Option(Catches) * Option(Finally) + ResourceSpecification = Token.PARENTHLEFT * ResourceList * Option(Token.SEMICOLON) * Token.PARENTHRIGHT + ResourceList = Resource * Many(Token.COMMA * Resource) + Resource = Many(VariableModifier) * UnannType * VariableDeclaratorId * Token.ASSIGN * Expression + + /** + * Productions from §15 (Expressions) + */ + + Primary = PrimaryNoNewArray or ArrayCreationExpression + PrimaryNoNewArray = Literal or ClassLiteral or Token.THIS or TypeName * Token.DOT * Token.THIS or + Token.PARENTHLEFT * Expression * Token.PARENTHRIGHT or ClassInstanceCreationExpression or FieldAccess or + ArrayAccess or MethodInvocation or MethodReference + ClassLiteral = TypeName * Many(Token.BRACKETLEFT * Token.BRACKETRIGHT) * Token.DOT * Token.CLASS or + NumericType * Many(Token.BRACKETLEFT * Token.BRACKETRIGHT) * Token.DOT * Token.CLASS or + Token.BOOLEAN * Many(Token.BRACKETLEFT * Token.BRACKETRIGHT) * Token.DOT * Token.CLASS or + Token.VOID * Token.DOT * Token.CLASS + ClassInstanceCreationExpression = UnqualifiedClassInstanceCreationExpression or + ExpressionName * Token.DOT * UnqualifiedClassInstanceCreationExpression or + Primary * Token.DOT * UnqualifiedClassInstanceCreationExpression + UnqualifiedClassInstanceCreationExpression = + Token.NEW * Option(TypeArguments) * classOrInterfaceTypeToInstantiate * Token.PARENTHLEFT * Option(ArgumentList) * Token.PARENTHRIGHT * Option(ClassBody) + classOrInterfaceTypeToInstantiate = Many(Annotation) * Identifier * Many(Token.DOT * Many(Annotation) * Identifier) * Option(TypeArgumentsOrDiamond) + TypeArgumentsOrDiamond = TypeArguments or Token.LT * Token.GT + FieldAccess = Primary * Token.DOT * Identifier or Token.SUPER * Token.DOT * Identifier or + TypeName * Token.DOT * Token.SUPER * Token.DOT * Identifier + ArrayAccess = ExpressionName * Token.BRACKETLEFT * Expression * Token.BRACKETRIGHT or + PrimaryNoNewArray * Token.BRACKETLEFT * Expression * Token.BRACKETRIGHT + MethodInvocation = MethodName * Token.PARENTHLEFT * Option(ArgumentList) * Token.PARENTHRIGHT or + TypeName * Token.DOT * Option(TypeArguments) * Identifier * Token.PARENTHLEFT * Option(ArgumentList) * Token.PARENTHRIGHT or + ExpressionName * Token.DOT * Option(TypeArguments) * Identifier * Token.PARENTHLEFT * Option(ArgumentList) * Token.PARENTHRIGHT or + Primary * Token.DOT * Option(TypeArguments) * Identifier * Token.PARENTHLEFT * Option(ArgumentList) * Token.PARENTHRIGHT or + Token.SUPER * Token.DOT * Option(TypeArguments) * Identifier * Token.PARENTHLEFT * Option(ArgumentList) * Token.PARENTHRIGHT or + TypeName * Token.DOT * Token.SUPER * Token.DOT * Option(TypeArguments) * Identifier * Token.PARENTHLEFT * Option(ArgumentList) * Token.PARENTHRIGHT + ArgumentList = Expression * Many(Token.COMMA * Expression) + MethodReference = ExpressionName * Token.DOUBLECOLON * Option(TypeArguments) * Identifier or + ReferenceType * Token.DOUBLECOLON * Option(TypeArguments) * Identifier or + Primary * Token.DOUBLECOLON * Option(TypeArguments) * Identifier or + Token.SUPER * Token.DOUBLECOLON * Option(TypeArguments) * Identifier or + TypeName * Token.DOT * Token.SUPER * Token.DOUBLECOLON * Option(TypeArguments) * Identifier or + ClassType * Token.DOUBLECOLON * Option(TypeArguments) * Token.NEW or + ArrayType * Token.DOUBLECOLON * Token.NEW + ArrayCreationExpression = Token.NEW * PrimitiveType * DimExprs * Option(Dims) or + Token.NEW * ClassOrInterfaceType * DimExprs * Option(Dims) or + Token.NEW * PrimitiveType * Dims * ArrayInitializer or + Token.NEW * ClassOrInterfaceType * Dims * ArrayInitializer + DimExprs = Some(DimExpr) + DimExpr = Many(Annotation) * Token.BRACKETLEFT * Expression * Token.BRACKETRIGHT + Expression = LambdaExpression or AssignmentExpression + LambdaExpression = LambdaParameters * Token.ARROW * LambdaBody + LambdaParameters = Identifier or Token.PARENTHLEFT * Option(FormalParameterList) * Token.PARENTHRIGHT or + Token.PARENTHLEFT * InferredFormalParameterList * Token.PARENTHRIGHT + InferredFormalParameterList = Identifier * Many(Token.COMMA * Identifier) + LambdaBody = Expression or Block + AssignmentExpression = ConditionalExpression or Assignment + Assignment = LeftHandSide * AssignmentOperator * Expression + LeftHandSide = ExpressionName or FieldAccess or ArrayAccess + AssignmentOperator = Token.ASSIGN or Token.STARASSIGN or Token.SLASHASSIGN or Token.PERCENTASSIGN or Token.PLUSASSIGN or Token.MINUSASSIGN or + Token.SHIFTLEFTASSIGN or Token.SHIFTRIGHTASSIGN or Token.USRIGHTSHIFTASSIGN or Token.ANDASSIGN or Token.XORASSIGN or Token.ORASSIGN + ConditionalExpression = ConditionalOrExpression or + ConditionalOrExpression * Token.QUESTIONMARK * Expression * Token.COLON * ConditionalExpression or + ConditionalOrExpression * Token.QUESTIONMARK * Expression * Token.COLON * LambdaExpression + ConditionalOrExpression = ConditionalAndExpression or + ConditionalOrExpression * Token.OR * ConditionalAndExpression + ConditionalAndExpression = InclusiveOrExpression or + ConditionalAndExpression * Token.AND * InclusiveOrExpression + InclusiveOrExpression = ExclusiveOrExpression or + InclusiveOrExpression * Token.ORBIT * ExclusiveOrExpression + ExclusiveOrExpression = AndExpression or ExclusiveOrExpression * Token.XORBIT * AndExpression + AndExpression = EqualityExpression or AndExpression * Token.ANDBIT * EqualityExpression + EqualityExpression = RelationalExpression or EqualityExpression * Token.EQ * RelationalExpression or + EqualityExpression * Token.NOTEQ * RelationalExpression + RelationalExpression = ShiftExpression or RelationalExpression * Token.LT * ShiftExpression or + RelationalExpression * Token.GT * ShiftExpression or RelationalExpression * Token.LESSEQ * ShiftExpression or + RelationalExpression * Token.GREATEQ * ShiftExpression or RelationalExpression * Token.INSTANCEOF * ReferenceType + ShiftExpression = AdditiveExpression or ShiftExpression * Token.LT * Token.LT * AdditiveExpression or + ShiftExpression * Token.GT * Token.GT * AdditiveExpression or + ShiftExpression * Token.GT * Token.GT * Token.GT * AdditiveExpression + AdditiveExpression = MultiplicativeExpression or AdditiveExpression * Token.PLUS * MultiplicativeExpression or + AdditiveExpression * Token.MINUS * MultiplicativeExpression + MultiplicativeExpression = UnaryExpression or MultiplicativeExpression * Token.STAR * UnaryExpression or + MultiplicativeExpression * Token.SLASH * UnaryExpression or + MultiplicativeExpression * Token.PERCENT * UnaryExpression + UnaryExpression = PreIncrementExpression or PreDecrementExpression or Token.PLUS * UnaryExpression or + Token.MINUS * UnaryExpression or UnaryExpressionNotPlusMinus + PreIncrementExpression = Token.PLUSPLUS * UnaryExpression + PreDecrementExpression = Token.MINUSMINUS * UnaryExpression + UnaryExpressionNotPlusMinus = PostfixExpression or Token.TILDA * UnaryExpression or Token.EXCLAMATIONMARK * UnaryExpression or + CastExpression + PostfixExpression = Primary or ExpressionName or PostIncrementExpression or PostDecrementExpression + PostIncrementExpression = PostfixExpression * Token.PLUSPLUS + PostDecrementExpression = PostfixExpression * Token.MINUSMINUS + CastExpression = Token.PARENTHLEFT * PrimitiveType * Token.PARENTHRIGHT * UnaryExpression or + Token.PARENTHLEFT * ReferenceType * Many(AdditionalBound) * Token.PARENTHRIGHT * UnaryExpressionNotPlusMinus or + Token.PARENTHLEFT * ReferenceType * Many(AdditionalBound) * Token.PARENTHRIGHT * LambdaExpression + ConstantExpression = Expression + + setStart(CompilationUnit) + } +} \ No newline at end of file diff --git a/test-shared/src/test/resources/grammars/java8/Java.x b/test-shared/src/test/resources/grammars/java8/Java.x new file mode 100644 index 000000000..628668957 --- /dev/null +++ b/test-shared/src/test/resources/grammars/java8/Java.x @@ -0,0 +1,167 @@ +package org.ucfs.lexer; + +import java.io.*; + +%% + +%public +%class JavaLexer +%type JavaToken +%unicode + +Identifier = [:jletter:] [:jletterdigit:]* +IntegerLiteral = {DecimalIntegerLiteral} | {HexIntegerLiteral} | {OctalIntegerLiteral} | {BinaryIntegerLiteral} + +DecimalIntegerLiteral = {DecimalNumeral} [lL]? +HexIntegerLiteral = {HexNumeral} [lL]? +OctalIntegerLiteral = {OctalNumeral} [lL]? +BinaryIntegerLiteral = {BinaryNumeral} [lL]? + +DecimalNumeral = 0 | [1-9] {Digits}? | [1-9] "_"+ {Digits} +Digits = [0-9] | [0-9] (([0-9] | "_")+)? [0-9] + +HexNumeral = "0x" {HexDigits} | "0X" {HexDigits} +HexDigits = [0-9a-fA-F] ((([0-9a-fA-F] | "_")+)? [0-9a-fA-F])? + +OctalNumeral = 0 ("_"+)? {OctalDigits} +OctalDigits = [0-7] ((([0-7] | "_")+)? [0-7])? + +BinaryNumeral = 0 [bB] {BinaryDigits} +BinaryDigits = [0-1] ((([0-1] | "_")+)? [0-1])? + +FloatingPointLiteral = {DecimalFloatingPointLiteral} | {HexadecimalFloatingPointLiteral} +DecimalFloatingPointLiteral = [0-9] "." [0-9]? {ExponentPart}? [fFdD]? | "." [0-9] {ExponentPart}? [fFdD]? | [0-9] {ExponentPart} [fFdD] | [0-9] {ExponentPart}? [fFdD] +ExponentPart = [eE] [\+\-]? {Digits} +HexadecimalFloatingPointLiteral = {HexSignificand} {BinaryExponent} [fFdD]? +HexSignificand = {HexNumeral} "."? | 0 [xX] {HexDigits}? "." {HexDigits} +BinaryExponent = [pP] [\+\-]? {Digits} + +BooleanLiteral = "false" | "true" +NullLiteral = "null" + +InputCharacter = \\ "u"+ [0-9a-fA-F] [0-9a-fA-F] [0-9a-fA-F] [0-9a-fA-F] | [^\r\n\"\\] + +EscapeSequence = \\ [btnfr\"\'\\] | \\ ([0-7] | [0-7] [0-7] | [0-3][0-7][0-7]) +LineTerminator = \r | \n | \r\n + +CharacterLiteral = \' [^\r\n\'\\] \' | \' {EscapeSequence} \' + +StringLiteral = \" {StringCharacter}* \" +StringCharacter = {InputCharacter} | {EscapeSequence} +WhiteSpace = {LineTerminator} | [\ \t\f] + +Comment = {TraditionalComment} | {DocumentationComment} +TraditionalComment = "/*" [^*] ~"*/" | "/*" "*"+ "/" +DocumentationComment = "/**" {CommentContent} "*"+ "/" +CommentContent = ( [^*] | \*+ [^/*] )* + +%% + +"boolean" { return JavaToken.BOOLEAN; } +"byte" { return JavaToken.BYTE; } +"short" { return JavaToken.SHORT; } +"int" { return JavaToken.INT; } +"long" { return JavaToken.LONG; } +"char" { return JavaToken.CHAR; } +"float" { return JavaToken.FLOAT; } +"double" { return JavaToken.DOUBLE; } +"." { return JavaToken.DOT; } +"[" { return JavaToken.BRACKETLEFT; } +"]" { return JavaToken.BRACKETRIGHT; } +"(" { return JavaToken.PARENTHLEFT; } +")" { return JavaToken.PARENTHRIGHT; } +"{" { return JavaToken.CURLYLEFT; } +"}" { return JavaToken.CURLYRIGHT; } +"extends" { return JavaToken.EXTENDS; } +"&" { return JavaToken.ANDBIT; } +"<" { return JavaToken.LT; } +">" { return JavaToken.GT; } +";" { return JavaToken.SEMICOLON; } +":" { return JavaToken.COLON; } +"::" { return JavaToken.DOUBLECOLON; } +"..." { return JavaToken.ELLIPSIS; } +"," { return JavaToken.COMMA; } +"?" { return JavaToken.QUESTIONMARK; } +"super" { return JavaToken.SUPER; } +"package" { return JavaToken.PACKAGE; } +"import" { return JavaToken.IMPORT; } +"static" { return JavaToken.STATIC; } +"*" { return JavaToken.STAR; } +"+" { return JavaToken.PLUS; } +"-" { return JavaToken.MINUS; } +"%" { return JavaToken.PERCENT; } +"/" { return JavaToken.SLASH; } +"++" { return JavaToken.PLUSPLUS; } +"--" { return JavaToken.MINUSMINUS; } +"~" { return JavaToken.TILDA; } +"!" { return JavaToken.EXCLAMATIONMARK; } +"class" { return JavaToken.CLASS; } +"public" { return JavaToken.PUBLIC; } +"protected" { return JavaToken.PROTECTED; } +"private" { return JavaToken.PRIVATE; } +"abstract" { return JavaToken.ABSTRACT; } +"final" { return JavaToken.FINAL; } +"const" { return JavaToken.FINAL; } +"strictfp" { return JavaToken.STRICTFP; } +"implements" { return JavaToken.IMPLEMENTS; } +"transient" { return JavaToken.TRANSIENT; } +"volatile" { return JavaToken.VOLATILE; } +"=" { return JavaToken.ASSIGN; } +"*=" { return JavaToken.STARASSIGN; } +"/=" { return JavaToken.SLASHASSIGN; } +"+=" { return JavaToken.PLUSASSIGN; } +"-=" { return JavaToken.MINUSASSIGN; } +"%=" { return JavaToken.PERCENTASSIGN; } +"^=" { return JavaToken.XORASSIGN; } +"<<=" { return JavaToken.SHIFTLEFTASSIGN; } +">>=" { return JavaToken.SHIFTRIGHTASSIGN; } +">>>=" { return JavaToken.USRIGHTSHIFTASSIGN; } +"&=" { return JavaToken.ANDASSIGN; } +"|=" { return JavaToken.ORASSIGN; } +"||" { return JavaToken.OR; } +"&&" { return JavaToken.AND; } +"^" { return JavaToken.XORBIT; } +"==" { return JavaToken.EQ; } +"!=" { return JavaToken.NOTEQ; } +"<=" { return JavaToken.LESSEQ; } +">=" { return JavaToken.GREATEQ; } +"instanceof" { return JavaToken.INSTANCEOF; } +"synchronized" { return JavaToken.SYNCHRONIZED; } +"native" { return JavaToken.NATIVE; } +"void" { return JavaToken.VOID; } +"this" { return JavaToken.THIS; } +"throws" { return JavaToken.THROWS; } +"enum" { return JavaToken.ENUM; } +"interface" { return JavaToken.INTERFACE; } +"@" { return JavaToken.AT; } +"default" { return JavaToken.DEFAULT; } +"assert" { return JavaToken.ASSERT; } +"switch" { return JavaToken.SWITCH; } +"case" { return JavaToken.CASE; } +"while" { return JavaToken.WHILE; } +"for" { return JavaToken.FOR; } +"if" { return JavaToken.IF; } +"else" { return JavaToken.ELSE; } +"do" { return JavaToken.DO; } +"break" { return JavaToken.BREAK; } +"continue" { return JavaToken.CONTINUE; } +"return" { return JavaToken.RETURN; } +"throw" { return JavaToken.THROW; } +"try" { return JavaToken.TRY; } +"catch" { return JavaToken.CATCH; } +"finally" { return JavaToken.FINALLY; } +"|" { return JavaToken.ORBIT; } +"new" { return JavaToken.NEW; } +"->" { return JavaToken.ARROW; } + +{LineTerminator} {} +{Comment} {} +{WhiteSpace} {} +{CharacterLiteral} { return JavaToken.CHARLIT; } +{NullLiteral} { return JavaToken.NULLLIT; } +{StringLiteral} { return JavaToken.STRINGLIT; } +{FloatingPointLiteral} { return JavaToken.FLOATINGLIT; } +{BooleanLiteral} { return JavaToken.BOOLEANLIT; } +{IntegerLiteral} { return JavaToken.INTEGERLIT; } +{Identifier} { return JavaToken.ID; } +<> { return JavaToken.EOF; } \ No newline at end of file diff --git a/test-shared/src/test/resources/grammars/java8/Lexer.kt b/test-shared/src/test/resources/grammars/java8/Lexer.kt new file mode 100644 index 000000000..2acc16bad --- /dev/null +++ b/test-shared/src/test/resources/grammars/java8/Lexer.kt @@ -0,0 +1,1838 @@ +// DO NOT EDIT +// Generated by JFlex 1.8.2 http://jflex.de/ +// source: Java.x +package grammars.java8 + +import java.io.IOException +import java.io.Reader + +// See https://github.com/jflex-de/jflex/issues/222 +class Lexer +/** + * Creates a new scanner + * + * @param in the java.io.Reader to read input from. + */( + /** Input device. */ + private var zzReader: Reader? +) { + /** Current state of the DFA. */ + private var zzState = 0 + + /** Current lexical state. */ + private var zzLexicalState = YYINITIAL + + /** + * This buffer contains the current text to be matched and is the source of the [.yytext] + * string. + */ + private var zzBuffer = CharArray(ZZ_BUFFERSIZE) + + /** Text position at the last accepting state. */ + private var zzMarkedPos = 0 + + /** Current text position in the buffer. */ + private var zzCurrentPos = 0 + + /** Marks the beginning of the [.yytext] string in the buffer. */ + private var zzStartRead = 0 + + /** Marks the last character in the buffer, that has been read from input. */ + private var zzEndRead = 0 + + /** + * Whether the scanner is at the end of file. + * @see .yyatEOF + */ + private var zzAtEOF = false + + /** + * The number of occupied positions in [.zzBuffer] beyond [.zzEndRead]. + * + * + * When a lead/high surrogate has been read from the input stream into the final + * [.zzBuffer] position, this will have a value of 1; otherwise, it will have a value of 0. + */ + private var zzFinalHighSurrogate = 0 + + /** Number of newlines encountered up to the start of the matched text. */ + @Suppress("unused") + private var yyline = 0 + + /** Number of characters from the last newline up to the start of the matched text. */ + @Suppress("unused") + private var yycolumn = 0 + + /** Number of characters up to the start of the matched text. */ + @Suppress("unused") + private var yychar: Long = 0 + + /** Whether the scanner is currently at the beginning of a line. */ + @Suppress("unused") + private var zzAtBOL = true + + /** Whether the user-EOF-code has already been executed. */ + @Suppress("unused") + private var zzEOFDone = false + + + /** + * Refills the input buffer. + * + * @return `false` iff there was new input. + * @exception IOException if any I/O-Error occurs + */ + @Throws(IOException::class) + private fun zzRefill(): Boolean { + /* first: make room (if you can) */ + + if (zzStartRead > 0) { + zzEndRead += zzFinalHighSurrogate + zzFinalHighSurrogate = 0 + System.arraycopy( + zzBuffer, zzStartRead, + zzBuffer, 0, + zzEndRead - zzStartRead + ) + + /* translate stored positions */ + zzEndRead -= zzStartRead + zzCurrentPos -= zzStartRead + zzMarkedPos -= zzStartRead + zzStartRead = 0 + } + + /* is the buffer big enough? */ + if (zzCurrentPos >= zzBuffer.size - zzFinalHighSurrogate) { + /* if not: blow it up */ + val newBuffer = CharArray(zzBuffer.size * 2) + System.arraycopy(zzBuffer, 0, newBuffer, 0, zzBuffer.size) + zzBuffer = newBuffer + zzEndRead += zzFinalHighSurrogate + zzFinalHighSurrogate = 0 + } + + /* fill the buffer with new input */ + val requested = zzBuffer.size - zzEndRead + val numRead = zzReader!!.read(zzBuffer, zzEndRead, requested) + + /* not supposed to occur according to specification of java.io.Reader */ + if (numRead == 0) { + throw IOException( + "Reader returned 0 characters. See JFlex examples/zero-reader for a workaround." + ) + } + if (numRead > 0) { + zzEndRead += numRead + if (Character.isHighSurrogate(zzBuffer[zzEndRead - 1])) { + if (numRead == requested) { // We requested too few chars to encode a full Unicode character + --zzEndRead + zzFinalHighSurrogate = 1 + } else { // There is room in the buffer for at least one more char + val c = zzReader!!.read() // Expecting to read a paired low surrogate char + if (c == -1) { + return true + } else { + zzBuffer[zzEndRead++] = c.toChar() + } + } + } + /* potentially more input available */ + return false + } + + /* numRead < 0 ==> end of stream */ + return true + } + + + /** + * Closes the input reader. + * + * @throws IOException if the reader could not be closed. + */ + @Throws(IOException::class) + fun yyclose() { + zzAtEOF = true // indicate end of file + zzEndRead = zzStartRead // invalidate buffer + + if (zzReader != null) { + zzReader!!.close() + } + } + + + /** + * Resets the scanner to read from a new input stream. + * + * + * Does not close the old reader. + * + * + * All internal variables are reset, the old input stream **cannot** be reused (internal + * buffer is discarded and lost). Lexical state is set to `ZZ_INITIAL`. + * + * + * Internal scan buffer is resized down to its initial length, if it has grown. + * + * @param reader The new input stream. + */ + fun yyreset(reader: Reader?) { + zzReader = reader + zzEOFDone = false + yyResetPosition() + zzLexicalState = YYINITIAL + if (zzBuffer.size > ZZ_BUFFERSIZE) { + zzBuffer = CharArray(ZZ_BUFFERSIZE) + } + } + + /** + * Resets the input position. + */ + private fun yyResetPosition() { + zzAtBOL = true + zzAtEOF = false + zzCurrentPos = 0 + zzMarkedPos = 0 + zzStartRead = 0 + zzEndRead = 0 + zzFinalHighSurrogate = 0 + yyline = 0 + yycolumn = 0 + yychar = 0L + } + + + /** + * Returns whether the scanner has reached the end of the reader it reads from. + * + * @return whether the scanner has reached EOF. + */ + fun yyatEOF(): Boolean { + return zzAtEOF + } + + + /** + * Returns the current lexical state. + * + * @return the current lexical state. + */ + fun yystate(): Int { + return zzLexicalState + } + + + /** + * Enters a new lexical state. + * + * @param newState the new lexical state + */ + fun yybegin(newState: Int) { + zzLexicalState = newState + } + + + /** + * Returns the text matched by the current regular expression. + * + * @return the matched text. + */ + fun yytext(): String { + return String(zzBuffer, zzStartRead, zzMarkedPos - zzStartRead) + } + + + /** + * Returns the character at the given position from the matched text. + * + * + * It is equivalent to `yytext().charAt(pos)`, but faster. + * + * @param position the position of the character to fetch. A value from 0 to `yylength()-1`. + * + * @return the character at `position`. + */ + fun yycharat(position: Int): Char { + return zzBuffer[zzStartRead + position] + } + + + /** + * How many characters were matched. + * + * @return the length of the matched text region. + */ + fun yylength(): Int { + return zzMarkedPos - zzStartRead + } + + + /** + * Pushes the specified amount of characters back into the input stream. + * + * + * They will be read again by then next call of the scanning method. + * + * @param number the number of characters to be read again. This number must not be greater than + * [.yylength]. + */ + fun yypushback(number: Int) { + if (number > yylength()) zzScanError(ZZ_PUSHBACK_2BIG) + + zzMarkedPos -= number + } + + + /** + * Resumes scanning until the next regular expression is matched, the end of input is encountered + * or an I/O-Error occurs. + * + * @return the next token. + * @exception IOException if any I/O-Error occurs. + */ + @Throws(IOException::class) + fun yylex(): Token { + var zzInput: Int = 0 + var zzAction: Int + + // cached fields: + var zzCurrentPosL: Int + var zzMarkedPosL: Int + var zzEndReadL = zzEndRead + var zzBufferL = zzBuffer + + val zzTransL = ZZ_TRANS + val zzRowMapL = ZZ_ROWMAP + val zzAttrL = ZZ_ATTRIBUTE + + while (true) { + zzMarkedPosL = zzMarkedPos + + zzAction = -1 + + zzStartRead = zzMarkedPosL + zzCurrentPos = zzStartRead + zzCurrentPosL = zzCurrentPos + + zzState = ZZ_LEXSTATE[zzLexicalState] + + // set up zzAction for empty match case: + var zzAttributes = zzAttrL[zzState] + if ((zzAttributes and 1) == 1) { + zzAction = zzState + } + + + var actionFound = false + while (!actionFound) { + if (zzCurrentPosL < zzEndReadL) { + zzInput = Character.codePointAt(zzBufferL, zzCurrentPosL, zzEndReadL) + zzCurrentPosL += Character.charCount(zzInput) + } else if (zzAtEOF) { + zzInput = YYEOF + actionFound = true + } else { + // store back cached positions + zzCurrentPos = zzCurrentPosL + zzMarkedPos = zzMarkedPosL + val eof = zzRefill() + // get translated positions and possibly new buffer + zzCurrentPosL = zzCurrentPos + zzMarkedPosL = zzMarkedPos + zzBufferL = zzBuffer + zzEndReadL = zzEndRead + if (eof) { + zzInput = YYEOF + actionFound = true + } else { + zzInput = Character.codePointAt(zzBufferL, zzCurrentPosL, zzEndReadL) + zzCurrentPosL += Character.charCount(zzInput) + } + } + if (!actionFound) { + val zzNext = zzTransL[zzRowMapL[zzState] + zzCMap(zzInput)] + if (zzNext == -1) { + actionFound = true + } else { + zzState = zzNext + + zzAttributes = zzAttrL[zzState] + if ((zzAttributes and 1) == 1) { + zzAction = zzState + zzMarkedPosL = zzCurrentPosL + if ((zzAttributes and 8) == 8) { + actionFound = true + } + } + } + } + } + + + // store back cached position + zzMarkedPos = zzMarkedPosL + + if (zzInput == YYEOF && zzStartRead == zzCurrentPos) { + zzAtEOF = true + run { + return Token.EOF + } + } else { + when (if (zzAction < 0) zzAction else ZZ_ACTION[zzAction]) { + 1 -> {} + 108 -> {} + 2 -> { + return Token.EXCLAMATIONMARK + } + + 109 -> {} + 3 -> { + return Token.ID + } + + 110 -> {} + 4 -> { + return Token.PERCENT + } + + 111 -> {} + 5 -> { + return Token.ANDBIT + } + + 112 -> {} + 6 -> { + return Token.PARENTHLEFT + } + + 113 -> {} + 7 -> { + return Token.PARENTHRIGHT + } + + 114 -> {} + 8 -> { + return Token.STAR + } + + 115 -> {} + 9 -> { + return Token.PLUS + } + + 116 -> {} + 10 -> { + return Token.COMMA + } + + 117 -> {} + 11 -> { + return Token.MINUS + } + + 118 -> {} + 12 -> { + return Token.DOT + } + + 119 -> {} + 13 -> { + return Token.SLASH + } + + 120 -> {} + 14 -> { + return Token.INTEGERLIT + } + + 121 -> {} + 15 -> { + return Token.COLON + } + + 122 -> {} + 16 -> { + return Token.SEMICOLON + } + + 123 -> {} + 17 -> { + return Token.DIAMONDLEFT + } + + 124 -> {} + 18 -> { + return Token.ASSIGN + } + + 125 -> {} + 19 -> { + return Token.DIAMONDRIGHT + } + + 126 -> {} + 20 -> { + return Token.QUESTIONMARK + } + + 127 -> {} + 21 -> { + return Token.AT + } + + 128 -> {} + 22 -> { + return Token.BRACKETLEFT + } + + 129 -> {} + 23 -> { + return Token.BRACKETRIGHT + } + + 130 -> {} + 24 -> { + return Token.XORBIT + } + + 131 -> {} + 25 -> { + return Token.CURLYLEFT + } + + 132 -> {} + 26 -> { + return Token.ORBIT + } + + 133 -> {} + 27 -> { + return Token.CURLYRIGHT + } + + 134 -> {} + 28 -> { + return Token.TILDA + } + + 135 -> {} + 29 -> { + return Token.NOTEQ + } + + 136 -> {} + 30 -> { + return Token.STRINGLIT + } + + 137 -> {} + 31 -> { + return Token.PERCENTASSIGN + } + + 138 -> {} + 32 -> { + return Token.AND + } + + 139 -> {} + 33 -> { + return Token.ANDASSIGN + } + + 140 -> {} + 34 -> { + return Token.STARASSIGN + } + + 141 -> {} + 35 -> { + return Token.PLUSPLUS + } + + 142 -> {} + 36 -> { + return Token.PLUSASSIGN + } + + 143 -> {} + 37 -> { + return Token.MINUSMINUS + } + + 144 -> {} + 38 -> { + return Token.MINUSASSIGN + } + + 145 -> {} + 39 -> { + return Token.ARROW + } + + 146 -> {} + 40 -> { + return Token.FLOATINGLIT + } + + 147 -> {} + 41 -> { + return Token.SLASHASSIGN + } + + 148 -> {} + 42 -> { + return Token.DOUBLECOLON + } + + 149 -> {} + 43 -> { + return Token.LEFTSHIFT + } + + 150 -> {} + 44 -> { + return Token.LESSEQ + } + + 151 -> {} + 45 -> { + return Token.DIAMOND + } + + 152 -> {} + 46 -> { + return Token.EQ + } + + 153 -> {} + 47 -> { + return Token.GREATEQ + } + + 154 -> {} + 48 -> { + return Token.RIGHTSHIT + } + + 155 -> {} + 49 -> { + return Token.XORASSIGN + } + + 156 -> {} + 50 -> { + return Token.DO + } + + 157 -> {} + 51 -> { + return Token.IF + } + + 158 -> {} + 52 -> { + return Token.ORASSIGN + } + + 159 -> {} + 53 -> { + return Token.OR + } + + 160 -> {} + 54 -> { + return Token.CHARLIT + } + + 161 -> {} + 55 -> { + return Token.ELLIPSIS + } + + 162 -> {} + 56 -> { + return Token.SHIFTLEFTASSIGN + } + + 163 -> {} + 57 -> { + return Token.SHIFTRIGHTASSIGN + } + + 164 -> {} + 58 -> { + return Token.USRIGHTSHIFT + } + + 165 -> {} + 59 -> { + return Token.FOR + } + + 166 -> {} + 60 -> { + return Token.INT + } + + 167 -> {} + 61 -> { + return Token.NEW + } + + 168 -> {} + 62 -> { + return Token.TRY + } + + 169 -> {} + 63 -> { + return Token.USRIGHTSHIFTASSIGN + } + + 170 -> {} + 64 -> { + return Token.BYTE + } + + 171 -> {} + 65 -> { + return Token.CASE + } + + 172 -> {} + 66 -> { + return Token.CHAR + } + + 173 -> {} + 67 -> { + return Token.ELSE + } + + 174 -> {} + 68 -> { + return Token.ENUM + } + + 175 -> {} + 69 -> { + return Token.LONG + } + + 176 -> {} + 70 -> { + return Token.NULLLIT + } + + 177 -> {} + 71 -> { + return Token.THIS + } + + 178 -> {} + 72 -> { + return Token.BOOLEANLIT + } + + 179 -> {} + 73 -> { + return Token.VOID + } + + 180 -> {} + 74 -> { + return Token.BREAK + } + + 181 -> {} + 75 -> { + return Token.CATCH + } + + 182 -> {} + 76 -> { + return Token.CLASS + } + + 183 -> {} + 77 -> { + return Token.FINAL + } + + 184 -> {} + 78 -> { + return Token.FLOAT + } + + 185 -> {} + 79 -> { + return Token.SHORT + } + + 186 -> {} + 80 -> { + return Token.SUPER + } + + 187 -> {} + 81 -> { + return Token.THROW + } + + 188 -> {} + 82 -> { + return Token.WHILE + } + + 189 -> {} + 83 -> { + return Token.ASSERT + } + + 190 -> {} + 84 -> { + return Token.DOUBLE + } + + 191 -> {} + 85 -> { + return Token.IMPORT + } + + 192 -> {} + 86 -> { + return Token.NATIVE + } + + 193 -> {} + 87 -> { + return Token.PUBLIC + } + + 194 -> {} + 88 -> { + return Token.RETURN + } + + 195 -> {} + 89 -> { + return Token.STATIC + } + + 196 -> {} + 90 -> { + return Token.SWITCH + } + + 197 -> {} + 91 -> { + return Token.THROWS + } + + 198 -> {} + 92 -> { + return Token.BOOLEAN + } + + 199 -> {} + 93 -> { + return Token.DEFAULT + } + + 200 -> {} + 94 -> { + return Token.EXTENDS + } + + 201 -> {} + 95 -> { + return Token.FINALLY + } + + 202 -> {} + 96 -> { + return Token.PACKAGE + } + + 203 -> {} + 97 -> { + return Token.PRIVATE + } + + 204 -> {} + 98 -> { + return Token.ABSTRACT + } + + 205 -> {} + 99 -> { + return Token.CONTINUE + } + + 206 -> {} + 100 -> { + return Token.STRICTFP + } + + 207 -> {} + 101 -> { + return Token.VOLATILE + } + + 208 -> {} + 102 -> { + return Token.INTERFACE + } + + 209 -> {} + 103 -> { + return Token.PROTECTED + } + + 210 -> {} + 104 -> { + return Token.TRANSIENT + } + + 211 -> {} + 105 -> { + return Token.IMPLEMENTS + } + + 212 -> {} + 106 -> { + return Token.INSTANCEOF + } + + 213 -> {} + 107 -> { + return Token.SYNCHRONIZED + } + + 214 -> {} + else -> zzScanError(ZZ_NO_MATCH) + } + } + } + } + + + companion object { + /** This character denotes the end of file. */ + const val YYEOF: Int = -1 + + /** Initial size of the lookahead buffer. */ + private const val ZZ_BUFFERSIZE = 16384 + + // Lexical states. + const val YYINITIAL: Int = 0 + + /** + * ZZ_LEXSTATE[l] is the state in the DFA for the lexical state l + * ZZ_LEXSTATE[l+1] is the state in the DFA for the lexical state l + * at the beginning of a line + * l is of the form l = 2*k, k a non negative integer + */ + private val ZZ_LEXSTATE = intArrayOf( + 0, 0 + ) + + /** + * Top-level table for translating characters to character classes + */ + private val ZZ_CMAP_TOP = zzUnpackcmap_top() + + private const val ZZ_CMAP_TOP_PACKED_0 = + "\u0001\u0000\u0001\u0100\u0001\u0200\u0001\u0300\u0001\u0400\u0001\u0500\u0001\u0600\u0001\u0700" + + "\u0001\u0800\u0001\u0900\u0001\u0a00\u0001\u0b00\u0001\u0c00\u0001\u0d00\u0001\u0e00\u0001\u0f00" + + "\u0001\u1000\u0001\u0100\u0001\u1100\u0001\u1200\u0001\u1300\u0001\u0100\u0001\u1400\u0001\u1500" + + "\u0001\u1600\u0001\u1700\u0001\u1800\u0001\u1900\u0001\u1a00\u0001\u1b00\u0001\u0100\u0001\u1c00" + + "\u0001\u1d00\u0001\u1e00\u000a\u1f00\u0001\u2000\u0001\u2100\u0001\u2200\u0001\u1f00\u0001\u2300" + + "\u0001\u2400\u0002\u1f00\u0019\u0100\u0001\u2500\u0056\u0100\u0001\u2600\u0001\u0100\u0001\u2700" + + "\u0001\u2800\u0001\u2900\u0001\u2a00\u0001\u2b00\u0001\u2c00\u002b\u0100\u0001\u2d00\u0021\u1f00" + + "\u0001\u0100\u0001\u2e00\u0001\u2f00\u0001\u0100\u0001\u3000\u0001\u3100\u0001\u3200\u0001\u3300" + + "\u0001\u3400\u0001\u3500\u0001\u3600\u0001\u3700\u0001\u3800\u0001\u0100\u0001\u3900\u0001\u3a00" + + "\u0001\u3b00\u0001\u3c00\u0001\u3d00\u0001\u3e00\u0001\u3f00\u0001\u4000\u0001\u4100\u0001\u4200" + + "\u0001\u4300\u0001\u4400\u0001\u4500\u0001\u4600\u0001\u4700\u0001\u4800\u0001\u4900\u0001\u4a00" + + "\u0001\u4b00\u0001\u4c00\u0001\u1f00\u0001\u4d00\u0001\u4e00\u0001\u4f00\u0001\u5000\u0003\u0100" + + "\u0001\u5100\u0001\u5200\u0001\u5300\u0009\u1f00\u0001\u5400\u0004\u0100\u0001\u5500\u000f\u1f00" + + "\u0002\u0100\u0001\u5600\u0021\u1f00\u0002\u0100\u0001\u5700\u0001\u5800\u0002\u1f00\u0001\u5900" + + "\u0001\u5a00\u0017\u0100\u0001\u5b00\u0004\u0100\u0001\u5c00\u0001\u5d00\u0021\u1f00\u0001\u5e00" + + "\u0001\u0100\u0001\u5f00\u0001\u6000\u0009\u1f00\u0001\u6100\u0012\u1f00\u0001\u6200\u0001\u1f00" + + "\u0001\u6300\u0001\u6400\u0001\u1f00\u0001\u6500\u0001\u6600\u0001\u6700\u0001\u6800\u0002\u1f00" + + "\u0001\u6900\u0004\u1f00\u0001\u6a00\u0001\u6b00\u0001\u6c00\u0001\u6d00\u0001\u1f00\u0001\u6e00" + + "\u0002\u1f00\u0001\u6f00\u0001\u7000\u0001\u7100\u0002\u1f00\u0001\u7200\u0001\u1f00\u0001\u7300" + + "\u000c\u1f00\u0001\u7400\u0004\u1f00\u00a6\u0100\u0001\u7500\u0010\u0100\u0001\u7600\u0001\u7700" + + "\u0015\u0100\u0001\u7800\u001c\u0100\u0001\u7900\u000c\u1f00\u0002\u0100\u0001\u7a00\u0005\u1f00" + + "\u0013\u0100\u0001\u7b00\u000f\u0100\u0001\u7c00\u0adc\u1f00\u0001\u7d00\u0001\u7e00\u02fe\u1f00" + + private fun zzUnpackcmap_top(): IntArray { + val result = IntArray(4352) + var offset = 0 + offset = zzUnpackcmap_top(ZZ_CMAP_TOP_PACKED_0, offset, result) + return result + } + + private fun zzUnpackcmap_top(packed: String, offset: Int, result: IntArray): Int { + var i = 0 /* index in packed string */ + var j = offset /* index in unpacked array */ + val l = packed.length + while (i < l) { + var count = packed[i++].code + val value = packed[i++].code + do result[j++] = value while (--count > 0) + } + return j + } + + + /** + * Second-level tables for translating characters to character classes + */ + private val ZZ_CMAP_BLOCKS = zzUnpackcmap_blocks() + + private const val ZZ_CMAP_BLOCKS_PACKED_0 = + "\u0009\u0000\u0001\u0001\u0001\u0002\u0001\u0003\u0001\u0001\u0001\u0004\u000e\u0000\u0004\u0003" + + "\u0001\u0001\u0001\u0005\u0001\u0006\u0001\u0003\u0001\u0007\u0001\u0008\u0001\u0009\u0001\u000a" + + "\u0001\u000b\u0001\u000c\u0001\u000d\u0001\u000e\u0001\u000f\u0001\u0010\u0001\u0011\u0001\u0012" + + "\u0001\u0013\u0001\u0014\u0002\u0015\u0004\u0016\u0002\u0017\u0001\u0018\u0001\u0019\u0001\u001a" + + "\u0001\u001b\u0001\u001c\u0001\u001d\u0001\u001e\u0001\u001f\u0001\u0020\u0001\u001f\u0001\u0021" + + "\u0001\u0022\u0001\u0021\u0005\u0007\u0001\u0023\u0003\u0007\u0001\u0024\u0007\u0007\u0001\u0025" + + "\u0002\u0007\u0001\u0026\u0001\u0027\u0001\u0028\u0001\u0029\u0001\u002a\u0001\u0003\u0001\u002b" + + "\u0001\u002c\u0001\u002d\u0001\u002e\u0001\u002f\u0001\u0030\u0001\u0031\u0001\u0032\u0001\u0033" + + "\u0001\u0007\u0001\u0034\u0001\u0035\u0001\u0036\u0001\u0037\u0001\u0038\u0001\u0039\u0001\u0007" + + "\u0001\u003a\u0001\u003b\u0001\u003c\u0001\u003d\u0001\u003e\u0001\u003f\u0001\u0040\u0001\u0041" + + "\u0001\u0042\u0001\u0043\u0001\u0044\u0001\u0045\u0001\u0046\u0021\u0000\u0002\u0003\u0004\u0007" + + "\u0004\u0003\u0001\u0007\u0002\u0003\u0001\u0000\u0007\u0003\u0001\u0007\u0004\u0003\u0001\u0007" + + "\u0005\u0003\u0017\u0007\u0001\u0003\u001f\u0007\u0001\u0003\u01ca\u0007\u0004\u0003\u000c\u0007" + + "\u000e\u0003\u0005\u0007\u0007\u0003\u0001\u0007\u0001\u0003\u0001\u0007\u0011\u0003\u0070\u0000" + + "\u0005\u0007\u0001\u0003\u0002\u0007\u0002\u0003\u0004\u0007\u0001\u0003\u0001\u0007\u0006\u0003" + + "\u0001\u0007\u0001\u0003\u0003\u0007\u0001\u0003\u0001\u0007\u0001\u0003\u0014\u0007\u0001\u0003" + + "\u0053\u0007\u0001\u0003\u008b\u0007\u0001\u0003\u0005\u0000\u0002\u0003\u00a6\u0007\u0001\u0003" + + "\u0026\u0007\u0002\u0003\u0001\u0007\u0006\u0003\u0029\u0007\u0006\u0003\u0001\u0007\u0001\u0003" + + "\u002d\u0000\u0001\u0003\u0001\u0000\u0001\u0003\u0002\u0000\u0001\u0003\u0002\u0000\u0001\u0003" + + "\u0001\u0000\u0008\u0003\u001b\u0007\u0004\u0003\u0004\u0007\u000d\u0003\u0006\u0000\u0005\u0003" + + "\u0001\u0007\u0004\u0003\u000b\u0000\u0001\u0003\u0001\u0000\u0003\u0003\u002b\u0007\u001f\u0000" + + "\u0004\u0003\u0002\u0007\u0001\u0000\u0063\u0007\u0001\u0003\u0001\u0007\u0008\u0000\u0001\u0003" + + "\u0006\u0000\u0002\u0007\u0002\u0000\u0001\u0003\u0004\u0000\u0002\u0007\u000a\u0000\u0003\u0007" + + "\u0002\u0003\u0001\u0007\u000f\u0003\u0001\u0000\u0001\u0007\u0001\u0000\u001e\u0007\u001b\u0000" + + "\u0002\u0003\u0059\u0007\u000b\u0000\u0001\u0007\u000e\u0003\u000a\u0000\u0021\u0007\u0009\u0000" + + "\u0002\u0007\u0004\u0003\u0001\u0007\u0002\u0003\u0001\u0000\u0018\u0007\u0004\u0000\u0001\u0007" + + "\u0009\u0000\u0001\u0007\u0003\u0000\u0001\u0007\u0005\u0000\u0012\u0003\u0019\u0007\u0003\u0000" + + "\u0004\u0003\u000b\u0007\u0005\u0003\u0018\u0007\u0001\u0003\u0006\u0007\u0001\u0003\u0002\u0000" + + "\u0006\u0003\u0008\u0000\u002a\u0007\u003a\u0000\u0036\u0007\u0003\u0000\u0001\u0007\u0012\u0000" + + "\u0001\u0007\u0007\u0000\u000a\u0007\u0002\u0000\u0002\u0003\u000a\u0000\u0001\u0003\u0010\u0007" + + "\u0003\u0000\u0001\u0003\u0008\u0007\u0002\u0003\u0002\u0007\u0002\u0003\u0016\u0007\u0001\u0003" + + "\u0007\u0007\u0001\u0003\u0001\u0007\u0003\u0003\u0004\u0007\u0002\u0003\u0001\u0000\u0001\u0007" + + "\u0007\u0000\u0002\u0003\u0002\u0000\u0002\u0003\u0003\u0000\u0001\u0007\u0008\u0003\u0001\u0000" + + "\u0004\u0003\u0002\u0007\u0001\u0003\u0003\u0007\u0002\u0000\u0002\u0003\u000a\u0000\u0004\u0007" + + "\u0007\u0003\u0002\u0007\u0001\u0003\u0001\u0000\u0002\u0003\u0003\u0000\u0001\u0003\u0006\u0007" + + "\u0004\u0003\u0002\u0007\u0002\u0003\u0016\u0007\u0001\u0003\u0007\u0007\u0001\u0003\u0002\u0007" + + "\u0001\u0003\u0002\u0007\u0001\u0003\u0002\u0007\u0002\u0003\u0001\u0000\u0001\u0003\u0005\u0000" + + "\u0004\u0003\u0002\u0000\u0002\u0003\u0003\u0000\u0003\u0003\u0001\u0000\u0007\u0003\u0004\u0007" + + "\u0001\u0003\u0001\u0007\u0007\u0003\u000c\u0000\u0003\u0007\u0001\u0000\u000b\u0003\u0003\u0000" + + "\u0001\u0003\u0009\u0007\u0001\u0003\u0003\u0007\u0001\u0003\u0016\u0007\u0001\u0003\u0007\u0007" + + "\u0001\u0003\u0002\u0007\u0001\u0003\u0005\u0007\u0002\u0003\u0001\u0000\u0001\u0007\u0008\u0000" + + "\u0001\u0003\u0003\u0000\u0001\u0003\u0003\u0000\u0002\u0003\u0001\u0007\u000f\u0003\u0002\u0007" + + "\u0002\u0000\u0002\u0003\u000a\u0000\u0001\u0003\u0001\u0007\u0007\u0003\u0001\u0007\u0006\u0000" + + "\u0001\u0003\u0003\u0000\u0001\u0003\u0008\u0007\u0002\u0003\u0002\u0007\u0002\u0003\u0016\u0007" + + "\u0001\u0003\u0007\u0007\u0001\u0003\u0002\u0007\u0001\u0003\u0005\u0007\u0002\u0003\u0001\u0000" + + "\u0001\u0007\u0007\u0000\u0002\u0003\u0002\u0000\u0002\u0003\u0003\u0000\u0007\u0003\u0003\u0000" + + "\u0004\u0003\u0002\u0007\u0001\u0003\u0003\u0007\u0002\u0000\u0002\u0003\u000a\u0000\u0001\u0003" + + "\u0001\u0007\u0010\u0003\u0001\u0000\u0001\u0007\u0001\u0003\u0006\u0007\u0003\u0003\u0003\u0007" + + "\u0001\u0003\u0004\u0007\u0003\u0003\u0002\u0007\u0001\u0003\u0001\u0007\u0001\u0003\u0002\u0007" + + "\u0003\u0003\u0002\u0007\u0003\u0003\u0003\u0007\u0003\u0003\u000c\u0007\u0004\u0003\u0005\u0000" + + "\u0003\u0003\u0003\u0000\u0001\u0003\u0004\u0000\u0002\u0003\u0001\u0007\u0006\u0003\u0001\u0000" + + "\u000e\u0003\u000a\u0000\u0009\u0003\u0001\u0007\u0006\u0003\u0005\u0000\u0008\u0007\u0001\u0003" + + "\u0003\u0007\u0001\u0003\u0017\u0007\u0001\u0003\u0010\u0007\u0002\u0003\u0001\u0000\u0001\u0007" + + "\u0007\u0000\u0001\u0003\u0003\u0000\u0001\u0003\u0004\u0000\u0007\u0003\u0002\u0000\u0001\u0003" + + "\u0003\u0007\u0002\u0003\u0001\u0007\u0002\u0003\u0002\u0007\u0002\u0000\u0002\u0003\u000a\u0000" + + "\u0010\u0003\u0001\u0007\u0003\u0000\u0001\u0003\u0008\u0007\u0001\u0003\u0003\u0007\u0001\u0003" + + "\u0017\u0007\u0001\u0003\u000a\u0007\u0001\u0003\u0005\u0007\u0002\u0003\u0001\u0000\u0001\u0007" + + "\u0007\u0000\u0001\u0003\u0003\u0000\u0001\u0003\u0004\u0000\u0007\u0003\u0002\u0000\u0006\u0003" + + "\u0002\u0007\u0001\u0003\u0002\u0007\u0002\u0000\u0002\u0003\u000a\u0000\u0001\u0003\u0002\u0007" + + "\u0001\u0000\u000c\u0003\u0004\u0000\u0009\u0007\u0001\u0003\u0003\u0007\u0001\u0003\u0029\u0007" + + "\u0002\u0000\u0001\u0007\u0007\u0000\u0001\u0003\u0003\u0000\u0001\u0003\u0004\u0000\u0001\u0007" + + "\u0005\u0003\u0003\u0007\u0001\u0000\u0007\u0003\u0003\u0007\u0002\u0000\u0002\u0003\u000a\u0000" + + "\u000a\u0003\u0006\u0007\u0001\u0003\u0003\u0000\u0001\u0003\u0012\u0007\u0003\u0003\u0018\u0007" + + "\u0001\u0003\u0009\u0007\u0001\u0003\u0001\u0007\u0002\u0003\u0007\u0007\u0003\u0003\u0001\u0000" + + "\u0004\u0003\u0006\u0000\u0001\u0003\u0001\u0000\u0001\u0003\u0008\u0000\u0006\u0003\u000a\u0000" + + "\u0002\u0003\u0002\u0000\u000d\u0003\u0030\u0007\u0001\u0000\u0002\u0007\u0007\u0000\u0004\u0003" + + "\u0008\u0007\u0008\u0000\u0001\u0003\u000a\u0000\u0027\u0003\u0002\u0007\u0001\u0003\u0001\u0007" + + "\u0001\u0003\u0005\u0007\u0001\u0003\u0018\u0007\u0001\u0003\u0001\u0007\u0001\u0003\u000a\u0007" + + "\u0001\u0000\u0002\u0007\u0009\u0000\u0001\u0007\u0002\u0003\u0005\u0007\u0001\u0003\u0001\u0007" + + "\u0001\u0003\u0007\u0000\u0001\u0003\u000a\u0000\u0002\u0003\u0004\u0007\u0020\u0003\u0001\u0007" + + "\u0017\u0003\u0002\u0000\u0006\u0003\u000a\u0000\u000b\u0003\u0001\u0000\u0001\u0003\u0001\u0000" + + "\u0001\u0003\u0001\u0000\u0004\u0003\u0002\u0000\u0008\u0007\u0001\u0003\u0024\u0007\u0004\u0003" + + "\u0014\u0000\u0001\u0003\u0002\u0000\u0005\u0007\u000b\u0000\u0001\u0003\u0024\u0000\u0009\u0003" + + "\u0001\u0000\u0039\u0003\u002b\u0007\u0014\u0000\u0001\u0007\u000a\u0000\u0006\u0003\u0006\u0007" + + "\u0004\u0000\u0004\u0007\u0003\u0000\u0001\u0007\u0003\u0000\u0002\u0007\u0007\u0000\u0003\u0007" + + "\u0004\u0000\u000d\u0007\u000c\u0000\u0001\u0007\u000f\u0000\u0002\u0003\u0026\u0007\u0001\u0003" + + "\u0001\u0007\u0005\u0003\u0001\u0007\u0002\u0003\u002b\u0007\u0001\u0003\u004d\u0007\u0001\u0003" + + "\u0004\u0007\u0002\u0003\u0007\u0007\u0001\u0003\u0001\u0007\u0001\u0003\u0004\u0007\u0002\u0003" + + "\u0029\u0007\u0001\u0003\u0004\u0007\u0002\u0003\u0021\u0007\u0001\u0003\u0004\u0007\u0002\u0003" + + "\u0007\u0007\u0001\u0003\u0001\u0007\u0001\u0003\u0004\u0007\u0002\u0003\u000f\u0007\u0001\u0003" + + "\u0039\u0007\u0001\u0003\u0004\u0007\u0002\u0003\u0043\u0007\u0002\u0003\u0003\u0000\u0020\u0003" + + "\u0010\u0007\u0010\u0003\u0056\u0007\u0002\u0003\u0006\u0007\u0003\u0003\u016c\u0007\u0002\u0003" + + "\u0011\u0007\u0001\u0003\u001a\u0007\u0005\u0003\u004b\u0007\u0003\u0003\u000b\u0007\u0007\u0003" + + "\u0012\u0007\u0004\u0000\u0009\u0003\u0013\u0007\u0003\u0000\u000b\u0003\u0012\u0007\u0002\u0000" + + "\u000c\u0003\u000d\u0007\u0001\u0003\u0003\u0007\u0001\u0003\u0002\u0000\u000c\u0003\u0034\u0007" + + "\u0020\u0000\u0003\u0003\u0001\u0007\u0003\u0003\u0002\u0007\u0001\u0000\u0002\u0003\u000a\u0000" + + "\u0021\u0003\u000f\u0000\u0006\u0003\u0059\u0007\u0007\u0003\u0005\u0007\u0002\u0000\u0022\u0007" + + "\u0001\u0000\u0001\u0007\u0005\u0003\u0046\u0007\u000a\u0003\u001f\u0007\u0001\u0003\u000c\u0000" + + "\u0004\u0003\u000c\u0000\u000a\u0003\u000a\u0000\u001e\u0007\u0002\u0003\u0005\u0007\u000b\u0003" + + "\u002c\u0007\u0004\u0003\u001a\u0007\u0006\u0003\u000a\u0000\u0026\u0003\u0017\u0007\u0005\u0000" + + "\u0004\u0003\u0035\u0007\u000a\u0000\u0001\u0003\u001d\u0000\u0002\u0003\u000b\u0000\u0006\u0003" + + "\u000a\u0000\u000d\u0003\u0001\u0007\u0008\u0003\u000e\u0000\u0001\u0003\u0010\u0000\u0031\u0003" + + "\u0005\u0000\u002f\u0007\u0011\u0000\u0008\u0007\u0003\u0003\u000a\u0000\u0011\u0003\u0009\u0000" + + "\u000c\u0003\u0003\u0000\u001e\u0007\u000d\u0000\u0002\u0007\u000a\u0000\u002c\u0007\u000e\u0000" + + "\u000c\u0003\u0024\u0007\u0014\u0000\u0008\u0003\u000a\u0000\u0003\u0003\u0003\u0007\u000a\u0000" + + "\u0024\u0007\u0002\u0003\u0009\u0007\u0007\u0003\u002b\u0007\u0002\u0003\u0003\u0007\u0010\u0003" + + "\u0003\u0000\u0001\u0003\u0015\u0000\u0004\u0007\u0001\u0000\u0006\u0007\u0001\u0000\u0002\u0007" + + "\u0003\u0000\u0001\u0007\u0005\u0003\u00c0\u0007\u0040\u0000\u0016\u0007\u0002\u0003\u0006\u0007" + + "\u0002\u0003\u0026\u0007\u0002\u0003\u0006\u0007\u0002\u0003\u0008\u0007\u0001\u0003\u0001\u0007" + + "\u0001\u0003\u0001\u0007\u0001\u0003\u0001\u0007\u0001\u0003\u001f\u0007\u0002\u0003\u0035\u0007" + + "\u0001\u0003\u0007\u0007\u0001\u0003\u0001\u0007\u0003\u0003\u0003\u0007\u0001\u0003\u0007\u0007" + + "\u0003\u0003\u0004\u0007\u0002\u0003\u0006\u0007\u0004\u0003\u000d\u0007\u0005\u0003\u0003\u0007" + + "\u0001\u0003\u0007\u0007\u000e\u0003\u0005\u0000\u001a\u0003\u0005\u0000\u0010\u0003\u0002\u0007" + + "\u0013\u0003\u0001\u0007\u000b\u0003\u0005\u0000\u0001\u0003\u000a\u0000\u0001\u0003\u0001\u0007" + + "\u000d\u0003\u0001\u0007\u0010\u0003\u000d\u0007\u0003\u0003\u0021\u0007\u000f\u0003\u000d\u0000" + + "\u0004\u0003\u0001\u0000\u0003\u0003\u000c\u0000\u0011\u0003\u0001\u0007\u0004\u0003\u0001\u0007" + + "\u0002\u0003\u000a\u0007\u0001\u0003\u0001\u0007\u0003\u0003\u0005\u0007\u0006\u0003\u0001\u0007" + + "\u0001\u0003\u0001\u0007\u0001\u0003\u0001\u0007\u0001\u0003\u0004\u0007\u0001\u0003\u000b\u0007" + + "\u0002\u0003\u0004\u0007\u0005\u0003\u0005\u0007\u0004\u0003\u0001\u0007\u0011\u0003\u0029\u0007" + + "\u0177\u0003\u00e5\u0007\u0006\u0003\u0004\u0007\u0003\u0000\u0002\u0007\u000c\u0003\u0026\u0007" + + "\u0001\u0003\u0001\u0007\u0005\u0003\u0001\u0007\u0002\u0003\u0038\u0007\u0007\u0003\u0001\u0007" + + "\u000f\u0003\u0001\u0000\u0017\u0007\u0009\u0003\u0007\u0007\u0001\u0003\u0007\u0007\u0001\u0003" + + "\u0007\u0007\u0001\u0003\u0007\u0007\u0001\u0003\u0007\u0007\u0001\u0003\u0007\u0007\u0001\u0003" + + "\u0007\u0007\u0001\u0003\u0007\u0007\u0001\u0003\u0020\u0000\u002f\u0003\u0001\u0007\u00d5\u0003" + + "\u0003\u0007\u0019\u0003\u0009\u0007\u0006\u0000\u0001\u0003\u0005\u0007\u0002\u0003\u0005\u0007" + + "\u0004\u0003\u0056\u0007\u0002\u0003\u0002\u0000\u0002\u0003\u0003\u0007\u0001\u0003\u005a\u0007" + + "\u0001\u0003\u0004\u0007\u0005\u0003\u002b\u0007\u0001\u0003\u005e\u0007\u0011\u0003\u0020\u0007" + + "\u0030\u0003\u00d0\u0007\u0040\u0003\u008d\u0007\u0043\u0003\u002e\u0007\u0002\u0003\u000d\u0007" + + "\u0003\u0003\u0010\u0007\u000a\u0000\u0002\u0007\u0014\u0003\u002f\u0007\u0001\u0000\u0004\u0003" + + "\u000a\u0000\u0001\u0003\u001f\u0007\u0002\u0000\u0050\u0007\u0002\u0000\u0025\u0003\u0009\u0007" + + "\u0002\u0003\u0067\u0007\u0002\u0003\u0040\u0007\u0005\u0003\u0002\u0007\u0001\u0003\u0001\u0007" + + "\u0001\u0003\u0005\u0007\u0018\u0003\u0010\u0007\u0001\u0000\u0003\u0007\u0001\u0000\u0004\u0007" + + "\u0001\u0000\u0017\u0007\u0005\u0000\u0004\u0003\u0001\u0000\u000b\u0003\u0001\u0007\u0007\u0003" + + "\u0034\u0007\u000c\u0003\u0002\u0000\u0032\u0007\u0012\u0000\u000a\u0003\u000a\u0000\u0006\u0003" + + "\u0012\u0000\u0006\u0007\u0003\u0003\u0001\u0007\u0001\u0003\u0002\u0007\u000b\u0000\u001c\u0007" + + "\u0008\u0000\u0002\u0003\u0017\u0007\u000d\u0000\u000c\u0003\u001d\u0007\u0003\u0003\u0004\u0000" + + "\u002f\u0007\u000e\u0000\u000e\u0003\u0001\u0007\u000a\u0000\u0006\u0003\u0005\u0007\u0001\u0000" + + "\u000a\u0007\u000a\u0000\u0005\u0007\u0001\u0003\u0029\u0007\u000e\u0000\u0009\u0003\u0003\u0007" + + "\u0001\u0000\u0008\u0007\u0002\u0000\u0002\u0003\u000a\u0000\u0006\u0003\u0017\u0007\u0003\u0003" + + "\u0001\u0007\u0003\u0000\u0032\u0007\u0001\u0000\u0001\u0007\u0003\u0000\u0002\u0007\u0002\u0000" + + "\u0005\u0007\u0002\u0000\u0001\u0007\u0001\u0000\u0001\u0007\u0018\u0003\u0003\u0007\u0002\u0003" + + "\u000b\u0007\u0005\u0000\u0002\u0003\u0003\u0007\u0002\u0000\u000a\u0003\u0006\u0007\u0002\u0003" + + "\u0006\u0007\u0002\u0003\u0006\u0007\u0009\u0003\u0007\u0007\u0001\u0003\u0007\u0007\u0001\u0003" + + "\u002b\u0007\u0001\u0003\u000e\u0007\u0006\u0003\u0073\u0007\u0008\u0000\u0001\u0003\u0002\u0000" + + "\u0002\u0003\u000a\u0000\u0006\u0003\u00a4\u0007\u000c\u0003\u0017\u0007\u0004\u0003\u0031\u0007" + + "\u0004\u0003\u006e\u0007\u0002\u0003\u006a\u0007\u0026\u0003\u0007\u0007\u000c\u0003\u0005\u0007" + + "\u0005\u0003\u0001\u0007\u0001\u0000\u000a\u0007\u0001\u0003\u000d\u0007\u0001\u0003\u0005\u0007" + + "\u0001\u0003\u0001\u0007\u0001\u0003\u0002\u0007\u0001\u0003\u0002\u0007\u0001\u0003\u006c\u0007" + + "\u0021\u0003\u006b\u0007\u0012\u0003\u0040\u0007\u0002\u0003\u0036\u0007\u0028\u0003\u000d\u0007" + + "\u0003\u0003\u0010\u0000\u0010\u0003\u0010\u0000\u0003\u0003\u0002\u0007\u0018\u0003\u0003\u0007" + + "\u0019\u0003\u0001\u0007\u0006\u0003\u0005\u0007\u0001\u0003\u0087\u0007\u0002\u0003\u0001\u0000" + + "\u0004\u0003\u0001\u0007\u000b\u0003\u000a\u0000\u0007\u0003\u001a\u0007\u0004\u0003\u0001\u0007" + + "\u0001\u0003\u001a\u0007\u000b\u0003\u0059\u0007\u0003\u0003\u0006\u0007\u0002\u0003\u0006\u0007" + + "\u0002\u0003\u0006\u0007\u0002\u0003\u0003\u0007\u0003\u0003\u0002\u0007\u0003\u0003\u0002\u0007" + + "\u0012\u0003\u0003\u0000\u0004\u0003\u000c\u0007\u0001\u0003\u001a\u0007\u0001\u0003\u0013\u0007" + + "\u0001\u0003\u0002\u0007\u0001\u0003\u000f\u0007\u0002\u0003\u000e\u0007\u0022\u0003\u007b\u0007" + + "\u0045\u0003\u0035\u0007\u0088\u0003\u0001\u0000\u0082\u0003\u001d\u0007\u0003\u0003\u0031\u0007" + + "\u000f\u0003\u0001\u0000\u001f\u0003\u0020\u0007\u000d\u0003\u001e\u0007\u0005\u0003\u0026\u0007" + + "\u0005\u0000\u0005\u0003\u001e\u0007\u0002\u0003\u0024\u0007\u0004\u0003\u0008\u0007\u0001\u0003" + + "\u0005\u0007\u002a\u0003\u009e\u0007\u0002\u0003\u000a\u0000\u0006\u0003\u0024\u0007\u0004\u0003" + + "\u0024\u0007\u0004\u0003\u0028\u0007\u0008\u0003\u0034\u0007\u000c\u0003\u000b\u0007\u0001\u0003" + + "\u000f\u0007\u0001\u0003\u0007\u0007\u0001\u0003\u0002\u0007\u0001\u0003\u000b\u0007\u0001\u0003" + + "\u000f\u0007\u0001\u0003\u0007\u0007\u0001\u0003\u0002\u0007\u0043\u0003\u0037\u0007\u0009\u0003" + + "\u0016\u0007\u000a\u0003\u0008\u0007\u0018\u0003\u0006\u0007\u0001\u0003\u002a\u0007\u0001\u0003" + + "\u0009\u0007\u0045\u0003\u0006\u0007\u0002\u0003\u0001\u0007\u0001\u0003\u002c\u0007\u0001\u0003" + + "\u0002\u0007\u0003\u0003\u0001\u0007\u0002\u0003\u0017\u0007\u000a\u0003\u0017\u0007\u0009\u0003" + + "\u001f\u0007\u0041\u0003\u0013\u0007\u0001\u0003\u0002\u0007\u000a\u0003\u0016\u0007\u000a\u0003" + + "\u001a\u0007\u0046\u0003\u0038\u0007\u0006\u0003\u0002\u0007\u0040\u0003\u0001\u0007\u0003\u0000" + + "\u0001\u0003\u0002\u0000\u0005\u0003\u0004\u0000\u0004\u0007\u0001\u0003\u0003\u0007\u0001\u0003" + + "\u001d\u0007\u0002\u0003\u0003\u0000\u0004\u0003\u0001\u0000\u0020\u0003\u001d\u0007\u0003\u0003" + + "\u001d\u0007\u0023\u0003\u0008\u0007\u0001\u0003\u001c\u0007\u0002\u0000\u0019\u0003\u0036\u0007" + + "\u000a\u0003\u0016\u0007\u000a\u0003\u0013\u0007\u000d\u0003\u0012\u0007\u006e\u0003\u0049\u0007" + + "\u0037\u0003\u0033\u0007\u000d\u0003\u0033\u0007\u000d\u0003\u0024\u0007\u0004\u0000\u0008\u0003" + + "\u000a\u0000\u0146\u0003\u002a\u0007\u0001\u0003\u0002\u0000\u0003\u0003\u0002\u0007\u004b\u0003" + + "\u0003\u0000\u001d\u0007\u000a\u0003\u0001\u0007\u0008\u0003\u0016\u0007\u000b\u0000\u001f\u0003" + + "\u0012\u0007\u0004\u0000\u002a\u0003\u0015\u0007\u001b\u0003\u0017\u0007\u0009\u0003\u0003\u0000" + + "\u0035\u0007\u000f\u0000\u001f\u0003\u000b\u0000\u0002\u0007\u0002\u0000\u0001\u0007\u0009\u0003" + + "\u0004\u0000\u002d\u0007\u000b\u0000\u0002\u0003\u0001\u0000\u0004\u0003\u0001\u0000\u000a\u0003" + + "\u0001\u0000\u0002\u0003\u0019\u0007\u0007\u0003\u000a\u0000\u0006\u0003\u0003\u0000\u0024\u0007" + + "\u000e\u0000\u0001\u0003\u000a\u0000\u0004\u0003\u0001\u0007\u0002\u0000\u0001\u0007\u0008\u0003" + + "\u0023\u0007\u0001\u0000\u0002\u0003\u0001\u0007\u0009\u0003\u0003\u0000\u0030\u0007\u000e\u0000" + + "\u0004\u0007\u0004\u0003\u0004\u0000\u0001\u0003\u000c\u0000\u0001\u0007\u0001\u0003\u0001\u0007" + + "\u0023\u0003\u0012\u0007\u0001\u0003\u0019\u0007\u000c\u0000\u0006\u0003\u0001\u0000\u0002\u0007" + + "\u0001\u0000\u003e\u0003\u0007\u0007\u0001\u0003\u0001\u0007\u0001\u0003\u0004\u0007\u0001\u0003" + + "\u000f\u0007\u0001\u0003\u000a\u0007\u0007\u0003\u002f\u0007\u000c\u0000\u0005\u0003\u000a\u0000" + + "\u0006\u0003\u0004\u0000\u0001\u0003\u0008\u0007\u0002\u0003\u0002\u0007\u0002\u0003\u0016\u0007" + + "\u0001\u0003\u0007\u0007\u0001\u0003\u0002\u0007\u0001\u0003\u0005\u0007\u0001\u0003\u0002\u0000" + + "\u0001\u0007\u0007\u0000\u0002\u0003\u0002\u0000\u0002\u0003\u0003\u0000\u0002\u0003\u0001\u0007" + + "\u0006\u0003\u0001\u0000\u0005\u0003\u0005\u0007\u0002\u0000\u0002\u0003\u0007\u0000\u0003\u0003" + + "\u0005\u0000\u008b\u0003\u0035\u0007\u0012\u0000\u0004\u0007\u0005\u0003\u000a\u0000\u0004\u0003" + + "\u0001\u0000\u0003\u0007\u001e\u0003\u0030\u0007\u0014\u0000\u0002\u0007\u0001\u0003\u0001\u0007" + + "\u0008\u0003\u000a\u0000\u00a6\u0003\u002f\u0007\u0007\u0000\u0002\u0003\u0009\u0000\u0017\u0003" + + "\u0004\u0007\u0002\u0000\u0022\u0003\u0030\u0007\u0011\u0000\u0003\u0003\u0001\u0007\u000b\u0003" + + "\u000a\u0000\u0026\u0003\u002b\u0007\u000d\u0000\u0001\u0007\u0007\u0003\u000a\u0000\u0036\u0003" + + "\u001b\u0007\u0002\u0003\u000f\u0000\u0004\u0003\u000a\u0000\u0006\u0003\u0007\u0007\u00b9\u0003" + + "\u002c\u0007\u000f\u0000\u0065\u0003\u0040\u0007\u000a\u0000\u0015\u0003\u0008\u0007\u0002\u0003" + + "\u0001\u0007\u0002\u0003\u0008\u0007\u0001\u0003\u0002\u0007\u0001\u0003\u0018\u0007\u0006\u0000" + + "\u0001\u0003\u0002\u0000\u0002\u0003\u0004\u0000\u0001\u0007\u0001\u0000\u0001\u0007\u0002\u0000" + + "\u000c\u0003\u000a\u0000\u0046\u0003\u0008\u0007\u0002\u0003\u0027\u0007\u0007\u0000\u0002\u0003" + + "\u0007\u0000\u0001\u0007\u0001\u0003\u0001\u0007\u0001\u0000\u001b\u0003\u0001\u0007\u000a\u0000" + + "\u0028\u0007\u0007\u0000\u0001\u0007\u0004\u0000\u0008\u0003\u0001\u0000\u0008\u0003\u0001\u0007" + + "\u000b\u0000\u002e\u0007\u0010\u0000\u0003\u0003\u0001\u0007\u0012\u0003\u0049\u0007\u0007\u0003" + + "\u0009\u0007\u0001\u0003\u0025\u0007\u0008\u0000\u0001\u0003\u0008\u0000\u0001\u0007\u000f\u0003" + + "\u000a\u0000\u0018\u0003\u001e\u0007\u0002\u0003\u0016\u0000\u0001\u0003\u000e\u0000\u0049\u0003" + + "\u0007\u0007\u0001\u0003\u0002\u0007\u0001\u0003\u0026\u0007\u0006\u0000\u0003\u0003\u0001\u0000" + + "\u0001\u0003\u0002\u0000\u0001\u0003\u0007\u0000\u0001\u0007\u0001\u0000\u0008\u0003\u000a\u0000" + + "\u0006\u0003\u0006\u0007\u0001\u0003\u0002\u0007\u0001\u0003\u0020\u0007\u0005\u0000\u0001\u0003" + + "\u0002\u0000\u0001\u0003\u0005\u0000\u0001\u0007\u0007\u0003\u000a\u0000\u0136\u0003\u0013\u0007" + + "\u0004\u0000\u0009\u0003\u0002\u0000\u0001\u0007\u0001\u0000\u000d\u0007\u0001\u0003\u0022\u0007" + + "\u0007\u0000\u0003\u0003\u0005\u0000\u000d\u0003\u000a\u0000\u0056\u0003\u0001\u0007\u002c\u0003" + + "\u0004\u0007\u001f\u0003\u009a\u0007\u0066\u0003\u006f\u0007\u0011\u0003\u00c4\u0007\u014c\u0003" + + "\u0061\u0007\u000f\u0003\u0030\u0007\u0011\u0000\u0006\u0007\u000f\u0000\u00aa\u0003\u0047\u0007" + + "\u00b9\u0003\u0039\u0007\u0007\u0003\u001f\u0007\u0001\u0003\u000a\u0000\u0006\u0003\u004f\u0007" + + "\u0001\u0003\u000a\u0000\u0006\u0003\u001e\u0007\u0002\u0003\u0005\u0000\u000b\u0003\u0030\u0007" + + "\u0007\u0000\u0009\u0003\u0004\u0007\u000c\u0003\u000a\u0000\u0009\u0003\u0015\u0007\u0005\u0003" + + "\u0013\u0007\u00b0\u0003\u0040\u0007\u0080\u0003\u004b\u0007\u0004\u0003\u0001\u0000\u0001\u0007" + + "\u0037\u0000\u0007\u0003\u0004\u0000\u000d\u0007\u0040\u0003\u0002\u0007\u0001\u0003\u0001\u0007" + + "\u0001\u0000\u000b\u0003\u0002\u0000\u000e\u0003\u00f8\u0007\u0008\u0003\u00d6\u0007\u002a\u0003" + + "\u0009\u0007\u01e7\u0003\u0004\u0007\u0001\u0003\u0007\u0007\u0001\u0003\u0002\u0007\u0001\u0003" + + "\u0023\u0007\u000f\u0003\u0001\u0007\u001d\u0003\u0003\u0007\u0002\u0003\u0001\u0007\u000e\u0003" + + "\u0004\u0007\u0008\u0003\u018c\u0007\u0004\u0003\u006b\u0007\u0005\u0003\u000d\u0007\u0003\u0003" + + "\u0009\u0007\u0007\u0003\u000a\u0007\u0003\u0003\u0002\u0000\u0001\u0003\u0004\u0000\u005c\u0003" + + "\u002e\u0000\u0002\u0003\u0017\u0000\u011e\u0003\u0005\u0000\u0003\u0003\u0016\u0000\u0002\u0003" + + "\u0007\u0000\u001e\u0003\u0004\u0000\u0094\u0003\u0003\u0000\u00bb\u0003\u0055\u0007\u0001\u0003" + + "\u0047\u0007\u0001\u0003\u0002\u0007\u0002\u0003\u0001\u0007\u0002\u0003\u0002\u0007\u0002\u0003" + + "\u0004\u0007\u0001\u0003\u000c\u0007\u0001\u0003\u0001\u0007\u0001\u0003\u0007\u0007\u0001\u0003" + + "\u0041\u0007\u0001\u0003\u0004\u0007\u0002\u0003\u0008\u0007\u0001\u0003\u0007\u0007\u0001\u0003" + + "\u001c\u0007\u0001\u0003\u0004\u0007\u0001\u0003\u0005\u0007\u0001\u0003\u0001\u0007\u0003\u0003" + + "\u0007\u0007\u0001\u0003\u0154\u0007\u0002\u0003\u0019\u0007\u0001\u0003\u0019\u0007\u0001\u0003" + + "\u001f\u0007\u0001\u0003\u0019\u0007\u0001\u0003\u001f\u0007\u0001\u0003\u0019\u0007\u0001\u0003" + + "\u001f\u0007\u0001\u0003\u0019\u0007\u0001\u0003\u001f\u0007\u0001\u0003\u0019\u0007\u0001\u0003" + + "\u0008\u0007\u0002\u0003\u0069\u0000\u0004\u0003\u0032\u0000\u0008\u0003\u0001\u0000\u000e\u0003" + + "\u0001\u0000\u0016\u0003\u0005\u0000\u0001\u0003\u000f\u0000\u0050\u0003\u001f\u0007\u0006\u0003" + + "\u0006\u0007\u00d5\u0003\u0007\u0000\u0001\u0003\u0011\u0000\u0002\u0003\u0007\u0000\u0001\u0003" + + "\u0002\u0000\u0001\u0003\u0005\u0000\u0005\u0003\u003e\u0007\u0021\u0003\u0001\u0000\u0070\u0003" + + "\u002d\u0007\u0003\u0003\u0007\u0000\u0007\u0007\u0002\u0003\u000a\u0000\u0004\u0003\u0001\u0007" + + "\u0141\u0003\u001e\u0007\u0001\u0000\u0011\u0003\u002c\u0007\u000e\u0000\u0005\u0003\u0001\u0007" + + "\u00d0\u0003\u001c\u0007\u000e\u0000\u00e6\u0003\u0007\u0007\u0001\u0003\u0004\u0007\u0001\u0003" + + "\u0002\u0007\u0001\u0003\u000f\u0007\u0001\u0003\u00c5\u0007\u000b\u0003\u0007\u0000\u0029\u0003" + + "\u0044\u0007\u0007\u0000\u0001\u0007\u0004\u0003\u000a\u0000\u0156\u0003\u0001\u0007\u004f\u0003" + + "\u0004\u0007\u0001\u0003\u001b\u0007\u0001\u0003\u0002\u0007\u0001\u0003\u0001\u0007\u0002\u0003" + + "\u0001\u0007\u0001\u0003\u000a\u0007\u0001\u0003\u0004\u0007\u0001\u0003\u0001\u0007\u0001\u0003" + + "\u0001\u0007\u0006\u0003\u0001\u0007\u0004\u0003\u0001\u0007\u0001\u0003\u0001\u0007\u0001\u0003" + + "\u0001\u0007\u0001\u0003\u0003\u0007\u0001\u0003\u0002\u0007\u0001\u0003\u0001\u0007\u0002\u0003" + + "\u0001\u0007\u0001\u0003\u0001\u0007\u0001\u0003\u0001\u0007\u0001\u0003\u0001\u0007\u0001\u0003" + + "\u0001\u0007\u0001\u0003\u0002\u0007\u0001\u0003\u0001\u0007\u0002\u0003\u0004\u0007\u0001\u0003" + + "\u0007\u0007\u0001\u0003\u0004\u0007\u0001\u0003\u0004\u0007\u0001\u0003\u0001\u0007\u0001\u0003" + + "\u000a\u0007\u0001\u0003\u0011\u0007\u0005\u0003\u0003\u0007\u0001\u0003\u0005\u0007\u0001\u0003" + + "\u0011\u0007\u0134\u0003\u000a\u0000\u0006\u0003\u00e0\u0007\u0020\u0003\u003a\u0007\u0006\u0003" + + "\u00de\u0007\u0002\u0003\u0182\u0007\u000e\u0003\u0131\u0007\u001f\u0003\u001e\u0007\u00e2\u0003" + + "\u004b\u0007\u0005\u0003\u0160\u0007\u0051\u0003\u0001\u0000\u001e\u0003\u0060\u0000\u0080\u0003" + + "\u00f0\u0000\u0010\u0003" + + private fun zzUnpackcmap_blocks(): IntArray { + val result = IntArray(32512) + var offset = 0 + offset = zzUnpackcmap_blocks(ZZ_CMAP_BLOCKS_PACKED_0, offset, result) + return result + } + + private fun zzUnpackcmap_blocks(packed: String, offset: Int, result: IntArray): Int { + var i = 0 /* index in packed string */ + var j = offset /* index in unpacked array */ + val l = packed.length + while (i < l) { + var count = packed[i++].code + val value = packed[i++].code + do result[j++] = value while (--count > 0) + } + return j + } + + /** + * Translates DFA states to action switch labels. + */ + private val ZZ_ACTION = zzUnpackAction() + + private const val ZZ_ACTION_PACKED_0 = + "\u0001\u0000\u0002\u0001\u0001\u0002\u0001\u0000\u0001\u0003\u0001\u0004\u0001\u0005\u0001\u0000" + + "\u0001\u0006\u0001\u0007\u0001\u0008\u0001\u0009\u0001\u000a\u0001\u000b\u0001\u000c\u0001\u000d" + + "\u0002\u000e\u0001\u000f\u0001\u0010\u0001\u0011\u0001\u0012\u0001\u0013\u0001\u0014\u0001\u0015" + + "\u0001\u0016\u0001\u0017\u0001\u0018\u000f\u0003\u0001\u0019\u0001\u001a\u0001\u001b\u0001\u001c" + + "\u0001\u001d\u0001\u001e\u0001\u0000\u0001\u001f\u0001\u0020\u0001\u0021\u0002\u0000\u0001\u0022" + + "\u0001\u0023\u0001\u0024\u0001\u0025\u0001\u0026\u0001\u0027\u0001\u0000\u0001\u0028\u0001\u0000" + + "\u0001\u0001\u0001\u0029\u0001\u0028\u0001\u000e\u0001\u0000\u0001\u0028\u0001\u0000\u0001\u000e" + + "\u0002\u0000\u0001\u000e\u0001\u0000\u0001\u002a\u0001\u002b\u0001\u002c\u0001\u002d\u0001\u002e" + + "\u0001\u002f\u0001\u0030\u0001\u0031\u000a\u0003\u0001\u0032\u0007\u0003\u0001\u0033\u0013\u0003" + + "\u0001\u0034\u0001\u0035\u0001\u0000\u0001\u0036\u0002\u0000\u0001\u0037\u0003\u0000\u0001\u000e" + + "\u0003\u0000\u0001\u000e\u0001\u0038\u0001\u0039\u0001\u003a\u0012\u0003\u0001\u003b\u0002\u0003" + + "\u0001\u003c\u0002\u0003\u0001\u003d\u0010\u0003\u0001\u003e\u0003\u0003\u0002\u0000\u0001\u0028" + + "\u0001\u0000\u0001\u0001\u0005\u0000\u0001\u003f\u0004\u0003\u0001\u0040\u0001\u0041\u0001\u0003" + + "\u0001\u0042\u0004\u0003\u0001\u0043\u0001\u0044\u0007\u0003\u0001\u0045\u0001\u0003\u0001\u0046" + + "\u000b\u0003\u0001\u0047\u0002\u0003\u0001\u0048\u0001\u0049\u0002\u0003\u0003\u0000\u0003\u0003" + + "\u0001\u004a\u0001\u004b\u0001\u004c\u0004\u0003\u0001\u004d\u0001\u004e\u000a\u0003\u0001\u004f" + + "\u0002\u0003\u0001\u0050\u0002\u0003\u0001\u0051\u0002\u0003\u0001\u0052\u0001\u0000\u0001\u0003" + + "\u0001\u0053\u0003\u0003\u0001\u0054\u0003\u0003\u0001\u0055\u0002\u0003\u0001\u0056\u0003\u0003" + + "\u0001\u0057\u0001\u0058\u0001\u0059\u0001\u0003\u0001\u005a\u0001\u0003\u0001\u005b\u0003\u0003" + + "\u0001\u005c\u0001\u0003\u0001\u005d\u0001\u005e\u0001\u005f\u0003\u0003\u0001\u0060\u0001\u0061" + + "\u0005\u0003\u0001\u0062\u0001\u0063\u0004\u0003\u0001\u0064\u0002\u0003\u0001\u0065\u0002\u0003" + + "\u0001\u0066\u0001\u0067\u0001\u0003\u0001\u0068\u0001\u0069\u0001\u006a\u0002\u0003\u0001\u006b" + + private fun zzUnpackAction(): IntArray { + val result = IntArray(337) + var offset = 0 + offset = zzUnpackAction(ZZ_ACTION_PACKED_0, offset, result) + return result + } + + private fun zzUnpackAction(packed: String, offset: Int, result: IntArray): Int { + var i = 0 /* index in packed string */ + var j = offset /* index in unpacked array */ + val l = packed.length + while (i < l) { + var count = packed[i++].code + val value = packed[i++].code + do result[j++] = value while (--count > 0) + } + return j + } + + + /** + * Translates a state to a row index in the transition table + */ + private val ZZ_ROWMAP = zzUnpackRowMap() + + private const val ZZ_ROWMAP_PACKED_0 = + "\u0000\u0000\u0000\u0047\u0000\u008e\u0000\u00d5\u0000\u011c\u0000\u0163\u0000\u01aa\u0000\u01f1" + + "\u0000\u0238\u0000\u0047\u0000\u0047\u0000\u027f\u0000\u02c6\u0000\u0047\u0000\u030d\u0000\u0354" + + "\u0000\u039b\u0000\u03e2\u0000\u0429\u0000\u0470\u0000\u0047\u0000\u04b7\u0000\u04fe\u0000\u0545" + + "\u0000\u0047\u0000\u0047\u0000\u0047\u0000\u0047\u0000\u058c\u0000\u05d3\u0000\u061a\u0000\u0661" + + "\u0000\u06a8\u0000\u06ef\u0000\u0736\u0000\u077d\u0000\u07c4\u0000\u080b\u0000\u0852\u0000\u0899" + + "\u0000\u08e0\u0000\u0927\u0000\u096e\u0000\u09b5\u0000\u0047\u0000\u09fc\u0000\u0047\u0000\u0047" + + "\u0000\u0047\u0000\u0047\u0000\u0a43\u0000\u0047\u0000\u0047\u0000\u0047\u0000\u0a8a\u0000\u0ad1" + + "\u0000\u0047\u0000\u0047\u0000\u0047\u0000\u0047\u0000\u0047\u0000\u0047\u0000\u0b18\u0000\u0b5f" + + "\u0000\u0ba6\u0000\u0bed\u0000\u0047\u0000\u0c34\u0000\u0c7b\u0000\u0cc2\u0000\u0047\u0000\u0d09" + + "\u0000\u0047\u0000\u0d50\u0000\u0d97\u0000\u0dde\u0000\u0e25\u0000\u0047\u0000\u0e6c\u0000\u0047" + + "\u0000\u0047\u0000\u0047\u0000\u0047\u0000\u0eb3\u0000\u0047\u0000\u0efa\u0000\u0f41\u0000\u0f88" + + "\u0000\u0fcf\u0000\u1016\u0000\u105d\u0000\u10a4\u0000\u10eb\u0000\u1132\u0000\u1179\u0000\u11c0" + + "\u0000\u1207\u0000\u124e\u0000\u1295\u0000\u12dc\u0000\u1323\u0000\u136a\u0000\u13b1\u0000\u0163" + + "\u0000\u13f8\u0000\u143f\u0000\u1486\u0000\u14cd\u0000\u1514\u0000\u155b\u0000\u15a2\u0000\u15e9" + + "\u0000\u1630\u0000\u1677\u0000\u16be\u0000\u1705\u0000\u174c\u0000\u1793\u0000\u17da\u0000\u1821" + + "\u0000\u1868\u0000\u18af\u0000\u18f6\u0000\u0047\u0000\u0047\u0000\u193d\u0000\u0047\u0000\u1984" + + "\u0000\u19cb\u0000\u0047\u0000\u1a12\u0000\u1a59\u0000\u1aa0\u0000\u1ae7\u0000\u1b2e\u0000\u1b75" + + "\u0000\u1bbc\u0000\u1c03\u0000\u0047\u0000\u0047\u0000\u1c4a\u0000\u1c91\u0000\u1cd8\u0000\u1d1f" + + "\u0000\u1d66\u0000\u1dad\u0000\u1df4\u0000\u1e3b\u0000\u1e82\u0000\u1ec9\u0000\u1f10\u0000\u1f57" + + "\u0000\u1f9e\u0000\u1fe5\u0000\u202c\u0000\u2073\u0000\u20ba\u0000\u2101\u0000\u2148\u0000\u0163" + + "\u0000\u218f\u0000\u21d6\u0000\u221d\u0000\u2264\u0000\u22ab\u0000\u0163\u0000\u22f2\u0000\u2339" + + "\u0000\u2380\u0000\u23c7\u0000\u240e\u0000\u2455\u0000\u249c\u0000\u24e3\u0000\u252a\u0000\u2571" + + "\u0000\u25b8\u0000\u25ff\u0000\u2646\u0000\u268d\u0000\u26d4\u0000\u271b\u0000\u0163\u0000\u2762" + + "\u0000\u27a9\u0000\u27f0\u0000\u2837\u0000\u287e\u0000\u28c5\u0000\u290c\u0000\u1a59\u0000\u2953" + + "\u0000\u299a\u0000\u29e1\u0000\u2a28\u0000\u2a6f\u0000\u0047\u0000\u2ab6\u0000\u2afd\u0000\u2b44" + + "\u0000\u2b8b\u0000\u0163\u0000\u0163\u0000\u2bd2\u0000\u0163\u0000\u2c19\u0000\u2c60\u0000\u2ca7" + + "\u0000\u2cee\u0000\u0163\u0000\u0163\u0000\u2d35\u0000\u2d7c\u0000\u2dc3\u0000\u2e0a\u0000\u2e51" + + "\u0000\u2e98\u0000\u2edf\u0000\u0163\u0000\u2f26\u0000\u0163\u0000\u2f6d\u0000\u2fb4\u0000\u2ffb" + + "\u0000\u3042\u0000\u3089\u0000\u30d0\u0000\u3117\u0000\u315e\u0000\u31a5\u0000\u31ec\u0000\u3233" + + "\u0000\u0163\u0000\u327a\u0000\u32c1\u0000\u0163\u0000\u0163\u0000\u3308\u0000\u334f\u0000\u3396" + + "\u0000\u33dd\u0000\u3424\u0000\u346b\u0000\u34b2\u0000\u34f9\u0000\u0163\u0000\u0163\u0000\u0163" + + "\u0000\u3540\u0000\u3587\u0000\u35ce\u0000\u3615\u0000\u365c\u0000\u0163\u0000\u36a3\u0000\u36ea" + + "\u0000\u3731\u0000\u3778\u0000\u37bf\u0000\u3806\u0000\u384d\u0000\u3894\u0000\u38db\u0000\u3922" + + "\u0000\u0163\u0000\u3969\u0000\u39b0\u0000\u0163\u0000\u39f7\u0000\u3a3e\u0000\u3a85\u0000\u3acc" + + "\u0000\u3b13\u0000\u0163\u0000\u3b5a\u0000\u3ba1\u0000\u0163\u0000\u3be8\u0000\u3c2f\u0000\u3c76" + + "\u0000\u0163\u0000\u3cbd\u0000\u3d04\u0000\u3d4b\u0000\u0163\u0000\u3d92\u0000\u3dd9\u0000\u0163" + + "\u0000\u3e20\u0000\u3e67\u0000\u3eae\u0000\u0163\u0000\u0163\u0000\u0163\u0000\u3ef5\u0000\u0163" + + "\u0000\u3f3c\u0000\u0163\u0000\u3f83\u0000\u3fca\u0000\u4011\u0000\u0163\u0000\u4058\u0000\u0163" + + "\u0000\u0163\u0000\u0163\u0000\u409f\u0000\u40e6\u0000\u412d\u0000\u0163\u0000\u0163\u0000\u4174" + + "\u0000\u41bb\u0000\u4202\u0000\u4249\u0000\u4290\u0000\u0163\u0000\u0163\u0000\u42d7\u0000\u431e" + + "\u0000\u4365\u0000\u43ac\u0000\u0163\u0000\u43f3\u0000\u443a\u0000\u0163\u0000\u4481\u0000\u44c8" + + "\u0000\u0163\u0000\u0163\u0000\u450f\u0000\u0163\u0000\u0163\u0000\u0163\u0000\u4556\u0000\u459d" + + "\u0000\u0163" + + private fun zzUnpackRowMap(): IntArray { + val result = IntArray(337) + var offset = 0 + offset = zzUnpackRowMap(ZZ_ROWMAP_PACKED_0, offset, result) + return result + } + + private fun zzUnpackRowMap(packed: String, offset: Int, result: IntArray): Int { + var i = 0 /* index in packed string */ + var j = offset /* index in unpacked array */ + val l = packed.length + while (i < l) { + val high = packed[i++].code shl 16 + result[j++] = high or packed[i++].code + } + return j + } + + /** + * The transition table of the DFA + */ + private val ZZ_TRANS = zzUnpackTrans() + + private const val ZZ_TRANS_PACKED_0 = + "\u0001\u0000\u0002\u0002\u0001\u0000\u0001\u0003\u0001\u0004\u0001\u0005\u0001\u0006\u0001\u0007" + + "\u0001\u0008\u0001\u0009\u0001\u000a\u0001\u000b\u0001\u000c\u0001\u000d\u0001\u000e\u0001\u000f" + + "\u0001\u0010\u0001\u0011\u0001\u0012\u0004\u0013\u0001\u0014\u0001\u0015\u0001\u0016\u0001\u0017" + + "\u0001\u0018\u0001\u0019\u0001\u001a\u0007\u0006\u0001\u001b\u0001\u0000\u0001\u001c\u0001\u001d" + + "\u0001\u0006\u0001\u001e\u0001\u001f\u0001\u0020\u0001\u0021\u0001\u0022\u0001\u0023\u0002\u0006" + + "\u0001\u0024\u0001\u0006\u0001\u0025\u0001\u0006\u0001\u0026\u0001\u0006\u0001\u0027\u0001\u0028" + + "\u0001\u0029\u0001\u002a\u0001\u0006\u0001\u002b\u0001\u002c\u0003\u0006\u0001\u002d\u0001\u002e" + + "\u0001\u002f\u0001\u0030\u0049\u0000\u0001\u0002\u005f\u0000\u0001\u0031\u002b\u0000\u0002\u0005" + + "\u0001\u0000\u0001\u0005\u0001\u0000\u0001\u0005\u0001\u0032\u0020\u0005\u0001\u0033\u001f\u0005" + + "\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000" + + "\u0019\u0006\u001f\u0000\u0001\u0034\u0034\u0000\u0001\u0035\u0011\u0000\u0001\u0036\u002b\u0000" + + "\u0002\u0037\u0001\u0000\u0001\u0037\u0001\u0000\u0005\u0037\u0001\u0000\u001c\u0037\u0001\u0038" + + "\u001f\u0037\u001b\u0000\u0001\u0039\u0039\u0000\u0001\u003a\u000c\u0000\u0001\u003b\u003b\u0000" + + "\u0001\u003c\u000a\u0000\u0001\u003d\u0001\u003e\u003b\u0000\u0001\u003f\u0001\u0000\u0005\u0040" + + "\u003c\u0000\u0001\u0041\u0004\u0000\u0001\u0042\u0008\u0000\u0001\u0043\u003c\u0000\u0001\u0044" + + "\u0001\u0000\u0004\u0045\u0009\u0000\u0001\u0046\u0001\u0047\u0001\u0048\u0001\u0049\u0001\u0000" + + "\u0001\u004a\u0004\u0000\u0001\u004b\u0001\u0000\u0001\u0046\u0001\u0000\u0001\u0047\u0001\u0048" + + "\u0001\u0047\u0004\u0000\u0001\u0049\u000a\u0000\u0001\u004a\u0017\u0000\u0001\u0044\u0001\u0000" + + "\u0005\u004c\u0009\u0000\u0001\u0047\u0001\u0048\u0001\u0049\u0006\u0000\u0001\u004d\u0003\u0000" + + "\u0001\u0047\u0001\u0048\u0001\u0047\u0004\u0000\u0001\u0049\u0029\u0000\u0001\u004e\u0048\u0000" + + "\u0001\u004f\u0001\u0050\u0001\u0051\u0045\u0000\u0001\u0052\u0046\u0000\u0001\u0053\u0001\u0054" + + "\u0045\u0000\u0001\u0055\u002b\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006" + + "\u0007\u0000\u0007\u0006\u0004\u0000\u0002\u0006\u0001\u0056\u000e\u0006\u0001\u0057\u0007\u0006" + + "\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006" + + "\u0004\u0000\u000e\u0006\u0001\u0058\u0001\u0006\u0001\u0059\u0006\u0006\u0001\u005a\u0001\u0006" + + "\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006" + + "\u0004\u0000\u0001\u0006\u0001\u005b\u0006\u0006\u0001\u005c\u0002\u0006\u0001\u005d\u0002\u0006" + + "\u0001\u005e\u000a\u0006\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006" + + "\u0007\u0000\u0007\u0006\u0004\u0000\u0005\u0006\u0001\u005f\u0008\u0006\u0001\u0060\u000a\u0006" + + "\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006" + + "\u0004\u0000\u000b\u0006\u0001\u0061\u0001\u0006\u0001\u0062\u0008\u0006\u0001\u0063\u0002\u0006" + + "\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006" + + "\u0004\u0000\u0001\u0006\u0001\u0064\u0007\u0006\u0001\u0065\u0001\u0006\u0001\u0066\u0002\u0006" + + "\u0001\u0067\u000a\u0006\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006" + + "\u0007\u0000\u0007\u0006\u0004\u0000\u0006\u0006\u0001\u0068\u0005\u0006\u0001\u0069\u0001\u006a" + + "\u000b\u0006\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000" + + "\u0007\u0006\u0004\u0000\u000e\u0006\u0001\u006b\u000a\u0006\u0004\u0000\u0001\u0006\u0006\u0000" + + "\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000\u0001\u0006\u0001\u006c" + + "\u0003\u0006\u0001\u006d\u000d\u0006\u0001\u006e\u0005\u0006\u0004\u0000\u0001\u0006\u0006\u0000" + + "\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000\u0001\u0006\u0001\u006f" + + "\u000e\u0006\u0001\u0070\u0002\u0006\u0001\u0071\u0005\u0006\u0004\u0000\u0001\u0006\u0006\u0000" + + "\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000\u0005\u0006\u0001\u0072" + + "\u0013\u0006\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000" + + "\u0007\u0006\u0004\u0000\u0008\u0006\u0001\u0073\u0009\u0006\u0001\u0074\u0001\u0075\u0001\u0006" + + "\u0001\u0076\u0001\u0006\u0001\u0077\u0001\u0006\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006" + + "\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000\u0008\u0006\u0001\u0078\u0007\u0006" + + "\u0001\u0079\u0008\u0006\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006" + + "\u0007\u0000\u0007\u0006\u0004\u0000\u000e\u0006\u0001\u007a\u000a\u0006\u0004\u0000\u0001\u0006" + + "\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000\u0008\u0006" + + "\u0001\u007b\u0010\u0006\u001f\u0000\u0001\u007c\u0028\u0000\u0001\u007d\u0008\u0000\u0001\u0005" + + "\u0003\u0000\u0001\u0005\u0008\u0000\u0004\u0005\u0010\u0000\u0001\u0005\u0004\u0000\u0001\u0005" + + "\u0003\u0000\u0001\u0005\u0006\u0000\u0001\u0005\u0002\u0000\u0001\u0005\u0001\u0000\u0001\u0005" + + "\u0001\u007e\u0013\u0000\u0001\u007f\u0042\u0000\u0001\u0037\u0003\u0000\u0001\u0037\u0008\u0000" + + "\u0003\u0080\u0001\u0081\u0010\u0000\u0001\u0037\u0004\u0000\u0001\u0037\u0003\u0000\u0001\u0037" + + "\u0006\u0000\u0001\u0037\u0002\u0000\u0001\u0037\u0001\u0000\u0001\u0037\u001b\u0000\u0001\u0082" + + "\u0056\u0000\u0001\u0047\u0001\u0083\u000b\u0000\u0001\u0047\u0001\u0083\u0001\u0047\u0016\u0000" + + "\u000d\u0084\u0001\u0085\u0039\u0084\u0002\u0042\u0001\u0002\u0001\u0042\u0001\u0003\u0042\u0042" + + "\u0013\u0000\u0005\u0040\u0009\u0000\u0001\u0047\u0001\u0083\u000b\u0000\u0001\u0047\u0001\u0083" + + "\u0001\u0047\u0029\u0000\u0004\u0045\u000c\u0000\u0001\u0049\u0006\u0000\u0001\u004b\u000a\u0000" + + "\u0001\u0049\u0024\u0000\u0002\u0086\u0040\u0000\u0001\u0087\u0001\u0000\u0001\u0087\u0002\u0000" + + "\u0005\u0088\u0040\u0000\u0001\u0089\u0001\u0000\u0005\u008a\u0007\u0000\u0004\u008a\u0008\u0000" + + "\u0006\u008a\u0029\u0000\u0004\u0045\u0013\u0000\u0001\u004b\u002f\u0000\u0005\u004c\u000b\u0000" + + "\u0001\u0049\u0006\u0000\u0001\u004d\u000a\u0000\u0001\u0049\u0024\u0000\u0005\u004c\u0012\u0000" + + "\u0001\u004d\u0037\u0000\u0001\u008b\u0046\u0000\u0001\u008c\u0001\u008d\u002a\u0000\u0001\u0006" + + "\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000\u0011\u0006" + + "\u0001\u008e\u0007\u0006\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006" + + "\u0007\u0000\u0007\u0006\u0004\u0000\u0011\u0006\u0001\u008f\u0007\u0006\u0004\u0000\u0001\u0006" + + "\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000\u000e\u0006" + + "\u0001\u0090\u000a\u0006\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006" + + "\u0007\u0000\u0007\u0006\u0004\u0000\u0005\u0006\u0001\u0091\u0013\u0006\u0004\u0000\u0001\u0006" + + "\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000\u0012\u0006" + + "\u0001\u0092\u0006\u0006\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006" + + "\u0007\u0000\u0007\u0006\u0004\u0000\u0011\u0006\u0001\u0093\u0001\u0094\u0006\u0006\u0004\u0000" + + "\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000" + + "\u0001\u0006\u0001\u0095\u0017\u0006\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000" + + "\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000\u0001\u0006\u0001\u0096\u0017\u0006\u0004\u0000" + + "\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000" + + "\u000d\u0006\u0001\u0097\u000b\u0006\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000" + + "\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000\u0006\u0006\u0001\u0098\u0012\u0006\u0004\u0000" + + "\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000" + + "\u0013\u0006\u0001\u0099\u0005\u0006\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000" + + "\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000\u0011\u0006\u0001\u009a\u0007\u0006\u0004\u0000" + + "\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000" + + "\u0013\u0006\u0001\u009b\u0005\u0006\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000" + + "\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000\u0012\u0006\u0001\u009c\u0006\u0006\u0004\u0000" + + "\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000" + + "\u000b\u0006\u0001\u009d\u000d\u0006\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000" + + "\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000\u000d\u0006\u0001\u009e\u000b\u0006\u0004\u0000" + + "\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000" + + "\u000e\u0006\u0001\u009f\u000a\u0006\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000" + + "\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000\u0010\u0006\u0001\u00a0\u0008\u0006\u0004\u0000" + + "\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000" + + "\u000f\u0006\u0001\u00a1\u0009\u0006\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000" + + "\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000\u0011\u0006\u0001\u00a2\u0001\u00a3\u0006\u0006" + + "\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006" + + "\u0004\u0000\u000d\u0006\u0001\u00a4\u000b\u0006\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006" + + "\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000\u0012\u0006\u0001\u00a5\u0006\u0006" + + "\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006" + + "\u0004\u0000\u0015\u0006\u0001\u00a6\u0003\u0006\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006" + + "\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000\u000b\u0006\u0001\u00a7\u000d\u0006" + + "\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006" + + "\u0004\u0000\u0003\u0006\u0001\u00a8\u0015\u0006\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006" + + "\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000\u0009\u0006\u0001\u00a9\u0004\u0006" + + "\u0001\u00aa\u000a\u0006\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006" + + "\u0007\u0000\u0007\u0006\u0004\u0000\u0002\u0006\u0001\u00ab\u0016\u0006\u0004\u0000\u0001\u0006" + + "\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000\u0012\u0006" + + "\u0001\u00ac\u0006\u0006\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006" + + "\u0007\u0000\u0007\u0006\u0004\u0000\u000e\u0006\u0001\u00ad\u000a\u0006\u0004\u0000\u0001\u0006" + + "\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000\u0001\u0006" + + "\u0001\u00ae\u000e\u0006\u0001\u00af\u0008\u0006\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006" + + "\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000\u000f\u0006\u0001\u00b0\u0009\u0006" + + "\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006" + + "\u0004\u0000\u0009\u0006\u0001\u00b1\u000f\u0006\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006" + + "\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000\u000d\u0006\u0001\u00b2\u000b\u0006" + + "\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006" + + "\u0004\u0000\u0009\u0006\u0001\u00b3\u0006\u0006\u0001\u00b4\u0008\u0006\u0004\u0000\u0001\u0006" + + "\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000\u0001\u0006" + + "\u0001\u00b5\u0011\u0006\u0001\u00b6\u0003\u0006\u0001\u00b7\u0001\u0006\u0004\u0000\u0001\u0006" + + "\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000\u0009\u0006" + + "\u0001\u00b8\u0001\u0006\u0001\u00b9\u000d\u0006\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006" + + "\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000\u0009\u0006\u0001\u00ba\u000f\u0006" + + "\u0017\u0000\u0005\u00bb\u0007\u0000\u0004\u00bb\u0008\u0000\u0006\u00bb\u000c\u0000\u0001\u007e" + + "\u0013\u0000\u0001\u007f\u0008\u0000\u0004\u0081\u003a\u0000\u0001\u007f\u0008\u0000\u0004\u0037" + + "\u003e\u0000\u0001\u00bc\u0001\u0000\u0001\u00bc\u0002\u0000\u0005\u00bd\u002f\u0000\u000d\u0084" + + "\u0001\u00be\u0046\u0084\u0001\u00be\u0004\u0084\u0001\u00bf\u0034\u0084\u0013\u0000\u0002\u0086" + + "\u000e\u0000\u0001\u0049\u0006\u0000\u0001\u00c0\u000a\u0000\u0001\u0049\u0024\u0000\u0005\u0088" + + "\u0042\u0000\u0005\u0088\u0009\u0000\u0001\u0047\u0008\u0000\u0001\u00c1\u0003\u0000\u0001\u0047" + + "\u0001\u0000\u0001\u0047\u0029\u0000\u0005\u00c2\u0007\u0000\u0004\u00c2\u0008\u0000\u0006\u00c2" + + "\u0027\u0000\u0001\u00c3\u0001\u0000\u0005\u008a\u0007\u0000\u0004\u008a\u0001\u0049\u0001\u0083" + + "\u0005\u0000\u0001\u00c4\u0006\u008a\u0004\u0000\u0001\u0049\u0003\u0000\u0001\u0083\u0028\u0000" + + "\u0001\u00c5\u002b\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000" + + "\u0007\u0006\u0004\u0000\u0012\u0006\u0001\u00c6\u0006\u0006\u0004\u0000\u0001\u0006\u0006\u0000" + + "\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000\u0005\u0006\u0001\u00c7" + + "\u0013\u0006\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000" + + "\u0007\u0006\u0004\u0000\u000b\u0006\u0001\u00c8\u000d\u0006\u0004\u0000\u0001\u0006\u0006\u0000" + + "\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000\u0001\u0006\u0001\u00c9" + + "\u0017\u0006\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000" + + "\u0007\u0006\u0004\u0000\u0005\u0006\u0001\u00ca\u0013\u0006\u0004\u0000\u0001\u0006\u0006\u0000" + + "\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000\u0005\u0006\u0001\u00cb" + + "\u0013\u0006\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000" + + "\u0007\u0006\u0004\u0000\u0003\u0006\u0001\u00cc\u0015\u0006\u0004\u0000\u0001\u0006\u0006\u0000" + + "\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000\u0010\u0006\u0001\u00cd" + + "\u0008\u0006\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000" + + "\u0007\u0006\u0004\u0000\u0011\u0006\u0001\u00ce\u0007\u0006\u0004\u0000\u0001\u0006\u0006\u0000" + + "\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000\u0012\u0006\u0001\u00cf" + + "\u0006\u0006\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000" + + "\u0007\u0006\u0004\u0000\u0001\u0006\u0001\u00d0\u0017\u0006\u0004\u0000\u0001\u0006\u0006\u0000" + + "\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000\u0002\u0006\u0001\u00d1" + + "\u0016\u0006\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000" + + "\u0007\u0006\u0004\u0000\u0005\u0006\u0001\u00d2\u0013\u0006\u0004\u0000\u0001\u0006\u0006\u0000" + + "\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000\u000c\u0006\u0001\u00d3" + + "\u000c\u0006\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000" + + "\u0007\u0006\u0004\u0000\u0005\u0006\u0001\u00d4\u0013\u0006\u0004\u0000\u0001\u0006\u0006\u0000" + + "\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000\u0011\u0006\u0001\u00b6" + + "\u0007\u0006\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000" + + "\u0007\u0006\u0004\u0000\u0001\u0006\u0001\u00d5\u0017\u0006\u0004\u0000\u0001\u0006\u0006\u0000" + + "\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000\u0001\u0006\u0001\u00d6" + + "\u0017\u0006\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000" + + "\u0007\u0006\u0004\u0000\u000b\u0006\u0001\u00d7\u0002\u0006\u0001\u00d8\u000a\u0006\u0004\u0000" + + "\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000" + + "\u0012\u0006\u0001\u00d9\u0006\u0006\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000" + + "\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000\u0005\u0006\u0001\u00da\u0013\u0006\u0004\u0000" + + "\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000" + + "\u0007\u0006\u0001\u00db\u0011\u0006\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000" + + "\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000\u0009\u0006\u0001\u00dc\u000f\u0006\u0004\u0000" + + "\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000" + + "\u000b\u0006\u0001\u00dd\u000d\u0006\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000" + + "\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000\u000a\u0006\u0001\u00de\u000e\u0006\u0004\u0000" + + "\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000" + + "\u0014\u0006\u0001\u00df\u0004\u0006\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000" + + "\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000\u0012\u0006\u0001\u00e0\u0006\u0006\u0004\u0000" + + "\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000" + + "\u000b\u0006\u0001\u00e1\u000d\u0006\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000" + + "\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000\u0013\u0006\u0001\u00e2\u0005\u0006\u0004\u0000" + + "\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000" + + "\u0010\u0006\u0001\u00e3\u0008\u0006\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000" + + "\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000\u0012\u0006\u0001\u00e4\u0006\u0006\u0004\u0000" + + "\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000" + + "\u0009\u0006\u0001\u00e5\u000f\u0006\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000" + + "\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000\u0005\u0006\u0001\u00e6\u0013\u0006\u0004\u0000" + + "\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000" + + "\u0012\u0006\u0001\u00e7\u0006\u0006\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000" + + "\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000\u0003\u0006\u0001\u00e8\u0015\u0006\u0004\u0000" + + "\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000" + + "\u0011\u0006\u0001\u00e9\u0007\u0006\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000" + + "\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000\u000e\u0006\u0001\u00ea\u000a\u0006\u0004\u0000" + + "\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000" + + "\u000d\u0006\u0001\u00eb\u000b\u0006\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000" + + "\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000\u0005\u0006\u0001\u00ec\u0013\u0006\u0004\u0000" + + "\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000" + + "\u0004\u0006\u0001\u00ed\u0014\u0006\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000" + + "\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000\u0001\u0006\u0001\u00ee\u0017\u0006\u0004\u0000" + + "\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000" + + "\u000b\u0006\u0001\u00ef\u000d\u0006\u0017\u0000\u0005\u00f0\u0007\u0000\u0004\u00f0\u0008\u0000" + + "\u0006\u00f0\u0029\u0000\u0005\u00bd\u0042\u0000\u0005\u00bd\u0009\u0000\u0001\u0047\u0008\u0000" + + "\u0001\u00f1\u0003\u0000\u0001\u0047\u0001\u0000\u0001\u0047\u0016\u0000\u000d\u0084\u0001\u00be" + + "\u0004\u0084\u0001\u0002\u0034\u0084\u0013\u0000\u0002\u0086\u0015\u0000\u0001\u00c0\u002f\u0000" + + "\u0005\u0088\u0012\u0000\u0001\u00c1\u002f\u0000\u0005\u00c2\u0007\u0000\u0004\u00c2\u0001\u0000" + + "\u0001\u0083\u0005\u0000\u0001\u00f2\u0006\u00c2\u0008\u0000\u0001\u0083\u0020\u0000\u0005\u00c2" + + "\u0007\u0000\u0004\u00c2\u0001\u0000\u0001\u0083\u0006\u0000\u0006\u00c2\u0008\u0000\u0001\u0083" + + "\u0020\u0000\u0005\u008a\u0007\u0000\u0004\u008a\u0007\u0000\u0001\u00c4\u0006\u008a\u0016\u0000" + + "\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000" + + "\u0010\u0006\u0001\u00f3\u0008\u0006\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000" + + "\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000\u0010\u0006\u0001\u00f4\u0008\u0006\u0004\u0000" + + "\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000" + + "\u0005\u0006\u0001\u00f5\u0013\u0006\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000" + + "\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000\u000a\u0006\u0001\u00f6\u000e\u0006\u0004\u0000" + + "\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000" + + "\u0008\u0006\u0001\u00f7\u0010\u0006\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000" + + "\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000\u0011\u0006\u0001\u00f8\u0007\u0006\u0004\u0000" + + "\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000" + + "\u0009\u0006\u0001\u00f9\u000f\u0006\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000" + + "\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000\u0013\u0006\u0001\u00fa\u0005\u0006\u0004\u0000" + + "\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000" + + "\u000b\u0006\u0001\u00fb\u000d\u0006\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000" + + "\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000\u000d\u0006\u0001\u00fc\u000b\u0006\u0004\u0000" + + "\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000" + + "\u000b\u0006\u0001\u00fd\u000d\u0006\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000" + + "\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000\u0012\u0006\u0001\u00fe\u0006\u0006\u0004\u0000" + + "\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000" + + "\u0005\u0006\u0001\u00ff\u0013\u0006\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000" + + "\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000\u0010\u0006\u0001\u0100\u0008\u0006\u0004\u0000" + + "\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000" + + "\u0001\u0006\u0001\u0101\u0017\u0006\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000" + + "\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000\u0010\u0006\u0001\u0102\u0008\u0006\u0004\u0000" + + "\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000" + + "\u0014\u0006\u0001\u0103\u0004\u0006\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000" + + "\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000\u0001\u0006\u0001\u0104\u0017\u0006\u0004\u0000" + + "\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000" + + "\u0001\u0006\u0001\u0105\u0017\u0006\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000" + + "\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000\u0005\u0006\u0001\u0106\u0013\u0006\u0004\u0000" + + "\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000" + + "\u0009\u0006\u0001\u0107\u000f\u0006\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000" + + "\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000\u0010\u0006\u0001\u0108\u0008\u0006\u0004\u0000" + + "\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000" + + "\u0012\u0006\u0001\u0109\u0006\u0006\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000" + + "\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000\u0009\u0006\u0001\u010a\u000f\u0006\u0004\u0000" + + "\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000" + + "\u0003\u0006\u0001\u010b\u0015\u0006\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000" + + "\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000\u0010\u0006\u0001\u010c\u0008\u0006\u0004\u0000" + + "\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000" + + "\u0003\u0006\u0001\u010d\u0015\u0006\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000" + + "\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000\u0008\u0006\u0001\u010e\u0010\u0006\u0004\u0000" + + "\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000" + + "\u0015\u0006\u0001\u010f\u0003\u0006\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000" + + "\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000\u0011\u0006\u0001\u0110\u0007\u0006\u0004\u0000" + + "\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000" + + "\u0012\u0006\u0001\u0111\u0006\u0006\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000" + + "\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000\u0005\u0006\u0001\u0112\u0013\u0006\u0017\u0000" + + "\u0005\u0113\u0007\u0000\u0004\u0113\u0008\u0000\u0006\u0113\u0029\u0000\u0005\u00bd\u0012\u0000" + + "\u0001\u00f1\u002f\u0000\u0005\u00c2\u0007\u0000\u0004\u00c2\u0007\u0000\u0001\u00f2\u0006\u00c2" + + "\u0016\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006" + + "\u0004\u0000\u0001\u0006\u0001\u0114\u0017\u0006\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006" + + "\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000\u0012\u0006\u0001\u0115\u0006\u0006" + + "\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006" + + "\u0004\u0000\u0001\u0006\u0001\u0116\u0017\u0006\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006" + + "\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000\u000d\u0006\u0001\u0117\u000b\u0006" + + "\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006" + + "\u0004\u0000\u000b\u0006\u0001\u0118\u000d\u0006\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006" + + "\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000\u0005\u0006\u0001\u0119\u0013\u0006" + + "\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006" + + "\u0004\u0000\u0004\u0006\u0001\u011a\u0014\u0006\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006" + + "\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000\u000b\u0006\u0001\u011b\u000d\u0006" + + "\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006" + + "\u0004\u0000\u000c\u0006\u0001\u011c\u000c\u0006\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006" + + "\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000\u0012\u0006\u0001\u011d\u0006\u0006" + + "\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006" + + "\u0004\u0000\u000d\u0006\u0001\u011e\u000b\u0006\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006" + + "\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000\u0006\u0006\u0001\u011f\u0012\u0006" + + "\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006" + + "\u0004\u0000\u0005\u0006\u0001\u0120\u0013\u0006\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006" + + "\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000\u0007\u0006\u0001\u0121\u0011\u0006" + + "\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006" + + "\u0004\u0000\u0012\u0006\u0001\u0122\u0006\u0006\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006" + + "\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000\u0003\u0006\u0001\u0123\u0015\u0006" + + "\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006" + + "\u0004\u0000\u0003\u0006\u0001\u0124\u0015\u0006\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006" + + "\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000\u000d\u0006\u0001\u0125\u000b\u0006" + + "\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006" + + "\u0004\u0000\u0003\u0006\u0001\u0126\u0015\u0006\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006" + + "\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000\u0012\u0006\u0001\u0127\u0006\u0006" + + "\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006" + + "\u0004\u0000\u0008\u0006\u0001\u0128\u0010\u0006\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006" + + "\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000\u0010\u0006\u0001\u0129\u0008\u0006" + + "\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006" + + "\u0004\u0000\u0011\u0006\u0001\u012a\u0007\u0006\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006" + + "\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000\u0009\u0006\u0001\u012b\u000f\u0006" + + "\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006" + + "\u0004\u0000\u0009\u0006\u0001\u012c\u000f\u0006\u0017\u0000\u0005\u0005\u0007\u0000\u0004\u0005" + + "\u0008\u0000\u0006\u0005\u0016\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006" + + "\u0007\u0000\u0007\u0006\u0004\u0000\u0003\u0006\u0001\u012d\u0015\u0006\u0004\u0000\u0001\u0006" + + "\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000\u000d\u0006" + + "\u0001\u012e\u000b\u0006\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006" + + "\u0007\u0000\u0007\u0006\u0004\u0000\u0013\u0006\u0001\u012f\u0005\u0006\u0004\u0000\u0001\u0006" + + "\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000\u0012\u0006" + + "\u0001\u0130\u0006\u0006\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006" + + "\u0007\u0000\u0007\u0006\u0004\u0000\u0011\u0006\u0001\u0131\u0007\u0006\u0004\u0000\u0001\u0006" + + "\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000\u0017\u0006" + + "\u0001\u0132\u0001\u0006\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006" + + "\u0007\u0000\u0007\u0006\u0004\u0000\u0005\u0006\u0001\u0133\u0013\u0006\u0004\u0000\u0001\u0006" + + "\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000\u0003\u0006" + + "\u0001\u0134\u0015\u0006\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006" + + "\u0007\u0000\u0007\u0006\u0004\u0000\u0001\u0006\u0001\u0135\u0017\u0006\u0004\u0000\u0001\u0006" + + "\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000\u0005\u0006" + + "\u0001\u0136\u0013\u0006\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006" + + "\u0007\u0000\u0007\u0006\u0004\u0000\u0005\u0006\u0001\u0137\u0013\u0006\u0004\u0000\u0001\u0006" + + "\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000\u0012\u0006" + + "\u0001\u0138\u0006\u0006\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006" + + "\u0007\u0000\u0007\u0006\u0004\u0000\u0006\u0006\u0001\u0139\u0012\u0006\u0004\u0000\u0001\u0006" + + "\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000\u000e\u0006" + + "\u0001\u013a\u000a\u0006\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006" + + "\u0007\u0000\u0007\u0006\u0004\u0000\u0005\u0006\u0001\u013b\u0013\u0006\u0004\u0000\u0001\u0006" + + "\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000\u000b\u0006" + + "\u0001\u013c\u000d\u0006\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006" + + "\u0007\u0000\u0007\u0006\u0004\u0000\u0012\u0006\u0001\u013d\u0006\u0006\u0004\u0000\u0001\u0006" + + "\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000\u0005\u0006" + + "\u0001\u013e\u0013\u0006\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006" + + "\u0007\u0000\u0007\u0006\u0004\u0000\u000d\u0006\u0001\u013f\u000b\u0006\u0004\u0000\u0001\u0006" + + "\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000\u0005\u0006" + + "\u0001\u0140\u0013\u0006\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006" + + "\u0007\u0000\u0007\u0006\u0004\u0000\u0003\u0006\u0001\u0141\u0015\u0006\u0004\u0000\u0001\u0006" + + "\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000\u0005\u0006" + + "\u0001\u0142\u0013\u0006\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006" + + "\u0007\u0000\u0007\u0006\u0004\u0000\u000f\u0006\u0001\u0143\u0009\u0006\u0004\u0000\u0001\u0006" + + "\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000\u000d\u0006" + + "\u0001\u0144\u000b\u0006\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006" + + "\u0007\u0000\u0007\u0006\u0004\u0000\u000d\u0006\u0001\u0145\u000b\u0006\u0004\u0000\u0001\u0006" + + "\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000\u0005\u0006" + + "\u0001\u0146\u0013\u0006\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006" + + "\u0007\u0000\u0007\u0006\u0004\u0000\u0012\u0006\u0001\u0147\u0006\u0006\u0004\u0000\u0001\u0006" + + "\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000\u000e\u0006" + + "\u0001\u0148\u000a\u0006\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006" + + "\u0007\u0000\u0007\u0006\u0004\u0000\u0005\u0006\u0001\u0149\u0013\u0006\u0004\u0000\u0001\u0006" + + "\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000\u0004\u0006" + + "\u0001\u014a\u0014\u0006\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006" + + "\u0007\u0000\u0007\u0006\u0004\u0000\u0009\u0006\u0001\u014b\u000f\u0006\u0004\u0000\u0001\u0006" + + "\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000\u0012\u0006" + + "\u0001\u014c\u0006\u0006\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006" + + "\u0007\u0000\u0007\u0006\u0004\u0000\u0011\u0006\u0001\u014d\u0007\u0006\u0004\u0000\u0001\u0006" + + "\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000\u0006\u0006" + + "\u0001\u014e\u0012\u0006\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006" + + "\u0007\u0000\u0007\u0006\u0004\u0000\u0018\u0006\u0001\u014f\u0004\u0000\u0001\u0006\u0006\u0000" + + "\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000\u0007\u0006\u0004\u0000\u0005\u0006\u0001\u0150" + + "\u0013\u0006\u0004\u0000\u0001\u0006\u0006\u0000\u0001\u0006\u000b\u0000\u0005\u0006\u0007\u0000" + + "\u0007\u0006\u0004\u0000\u0004\u0006\u0001\u0151\u0014\u0006\u0004\u0000" + + private fun zzUnpackTrans(): IntArray { + val result = IntArray(17892) + var offset = 0 + offset = zzUnpackTrans(ZZ_TRANS_PACKED_0, offset, result) + return result + } + + private fun zzUnpackTrans(packed: String, offset: Int, result: IntArray): Int { + var i = 0 /* index in packed string */ + var j = offset /* index in unpacked array */ + val l = packed.length + while (i < l) { + var count = packed[i++].code + var value = packed[i++].code + value-- + do result[j++] = value while (--count > 0) + } + return j + } + + + /** Error code for "Unknown internal scanner error". */ + private const val ZZ_UNKNOWN_ERROR = 0 + + /** Error code for "could not match input". */ + private const val ZZ_NO_MATCH = 1 + + /** Error code for "pushback value was too large". */ + private const val ZZ_PUSHBACK_2BIG = 2 + + /** + * Error messages for [.ZZ_UNKNOWN_ERROR], [.ZZ_NO_MATCH], and + * [.ZZ_PUSHBACK_2BIG] respectively. + */ + private val ZZ_ERROR_MSG = arrayOf( + "Unknown internal scanner error", + "Error: could not match input", + "Error: pushback value was too large" + ) + + /** + * ZZ_ATTRIBUTE[aState] contains the attributes of state `aState` + */ + private val ZZ_ATTRIBUTE = zzUnpackAttribute() + + private const val ZZ_ATTRIBUTE_PACKED_0 = + "\u0001\u0000\u0001\u0009\u0002\u0001\u0001\u0000\u0003\u0001\u0001\u0000\u0002\u0009\u0002\u0001" + + "\u0001\u0009\u0006\u0001\u0001\u0009\u0003\u0001\u0004\u0009\u0010\u0001\u0001\u0009\u0001\u0001" + + "\u0004\u0009\u0001\u0000\u0003\u0009\u0002\u0000\u0006\u0009\u0001\u0000\u0001\u0001\u0001\u0000" + + "\u0001\u0001\u0001\u0009\u0002\u0001\u0001\u0000\u0001\u0009\u0001\u0000\u0001\u0009\u0002\u0000" + + "\u0001\u0001\u0001\u0000\u0001\u0009\u0001\u0001\u0004\u0009\u0001\u0001\u0001\u0009\u0026\u0001" + + "\u0002\u0009\u0001\u0000\u0001\u0009\u0002\u0000\u0001\u0009\u0003\u0000\u0001\u0001\u0003\u0000" + + "\u0001\u0001\u0002\u0009\u002e\u0001\u0002\u0000\u0001\u0001\u0001\u0000\u0001\u0001\u0005\u0000" + + "\u0001\u0009\u002a\u0001\u0003\u0000\u0020\u0001\u0001\u0000\u003e\u0001" + + private fun zzUnpackAttribute(): IntArray { + val result = IntArray(337) + var offset = 0 + offset = zzUnpackAttribute(ZZ_ATTRIBUTE_PACKED_0, offset, result) + return result + } + + private fun zzUnpackAttribute(packed: String, offset: Int, result: IntArray): Int { + var i = 0 /* index in packed string */ + var j = offset /* index in unpacked array */ + val l = packed.length + while (i < l) { + var count = packed[i++].code + val value = packed[i++].code + do result[j++] = value while (--count > 0) + } + return j + } + + /** + * Translates raw input code points to DFA table row + */ + private fun zzCMap(input: Int): Int { + val offset = input and 255 + return if (offset == input) ZZ_CMAP_BLOCKS[offset] else ZZ_CMAP_BLOCKS[ZZ_CMAP_TOP[input shr 8] or offset] + } + + /** + * Reports an error that occurred while scanning. + * + * + * In a well-formed scanner (no or only correct usage of `yypushback(int)` and a + * match-all fallback rule) this method will only be called with things that + * "Can't Possibly Happen". + * + * + * If this method is called, something is seriously wrong (e.g. a JFlex bug producing a faulty + * scanner etc.). + * + * + * Usual syntax/scanner level error handling should be done in error fallback rules. + * + * @param errorCode the code of the error message to display. + */ + private fun zzScanError(errorCode: Int) { + var message = try { + ZZ_ERROR_MSG[errorCode] + } catch (e: ArrayIndexOutOfBoundsException) { + ZZ_ERROR_MSG[ZZ_UNKNOWN_ERROR] + } + + throw Error(message) + } + } +} \ No newline at end of file diff --git a/test-shared/src/test/resources/grammars/java8/Token.kt b/test-shared/src/test/resources/grammars/java8/Token.kt new file mode 100644 index 000000000..055fd2c7c --- /dev/null +++ b/test-shared/src/test/resources/grammars/java8/Token.kt @@ -0,0 +1,31 @@ +package grammars.java8 + +import org.ucfs.parser.generator.ParserGeneratorException +import org.ucfs.rsm.symbol.ITerminal + +enum class Token : ITerminal { + ID, EOF, INTEGERLIT, FLOATINGLIT, BOOLEANLIT, CHARLIT, STRINGLIT, NULLLIT, + BOOLEAN, BYTE, SHORT, INT, LONG, CHAR, FLOAT, DOUBLE, DOT, BRACKETLEFT, BRACKETRIGHT, + PARENTHLEFT, PARENTHRIGHT, CURLYLEFT, CURLYRIGHT, EXTENDS, ANDBIT, LT, GT, + DIAMOND, SEMICOLON, COLON, DOUBLECOLON, ELLIPSIS, COMMA, QUESTIONMARK, SUPER, PACKAGE, + IMPORT, STATIC, STAR, PLUS, MINUS, PERCENT, SLASH, PLUSPLUS, MINUSMINUS, TILDA, EXCLAMATIONMARK, + CLASS, PUBLIC, PROTECTED, PRIVATE, FINAL, STRICTFP, IMPLEMENTS, TRANSIENT, VOLATILE, ASSIGN, + STARASSIGN, SLASHASSIGN, PLUSASSIGN, MINUSASSIGN, PERCENTASSIGN, XORASSIGN, SHIFTLEFTASSIGN, + SHIFTRIGHTASSIGN, USRIGHTSHIFTASSIGN, ANDASSIGN, ORASSIGN, OR, AND, XORBIT, EQ, NOTEQ, LESSEQ, + GREATEQ, INSTANCEOF, SYNCHRONIZED, NATIVE, VOID, THIS, THROWS, ENUM, INTERFACE, ABSTRACT, AT, DEFAULT, ASSERT, + SWITCH, CASE, WHILE, FOR, IF, ELSE, DO, BREAK, CONTINUE, RETURN, THROW, TRY, CATCH, FINALLY, ORBIT, NEW, ARROW; + + override fun getComparator(): Comparator { + return object : Comparator { + override fun compare(a: ITerminal, b: ITerminal): Int { + if (a !is Token || b !is Token) { + throw ParserGeneratorException( + "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/test-shared/src/test/resources/grammars/java8/correctInputs/java1.txt b/test-shared/src/test/resources/grammars/java8/correctInputs/java1.txt new file mode 100644 index 000000000..7c69a8a52 --- /dev/null +++ b/test-shared/src/test/resources/grammars/java8/correctInputs/java1.txt @@ -0,0 +1,5 @@ +package org.junit.runner.manipulation; + +public class NoTestsRemainException extends Exception { + private static final long serialVersionUID = 1L; +} diff --git a/test-shared/src/test/resources/grammars/java8/correctInputs/java10.txt b/test-shared/src/test/resources/grammars/java8/correctInputs/java10.txt new file mode 100644 index 000000000..a4ec64517 --- /dev/null +++ b/test-shared/src/test/resources/grammars/java8/correctInputs/java10.txt @@ -0,0 +1,37 @@ +package org.junit.internal.matchers; + +import org.hamcrest.Description; +import org.hamcrest.Factory; +import org.hamcrest.Matcher; +import org.hamcrest.TypeSafeMatcher; + +public class ThrowableMessageMatcher extends + TypeSafeMatcher { + + private final Matcher matcher; + + public ThrowableMessageMatcher(Matcher matcher) { + this.matcher = matcher; + } + + public void describeTo(Description description) { + description.appendText("exception with message "); + description.appendDescriptionOf(matcher); + } + + @Override + protected boolean matchesSafely(T item) { + return matcher.matches(item.getMessage()); + } + + @Override + protected void describeMismatchSafely(T item, Description description) { + description.appendText("message "); + matcher.describeMismatch(item.getMessage(), description); + } + + @Factory + public static Matcher hasMessage(final Matcher matcher) { + return new ThrowableMessageMatcher(matcher); + } +} diff --git a/test-shared/src/test/resources/grammars/java8/correctInputs/java2.txt b/test-shared/src/test/resources/grammars/java8/correctInputs/java2.txt new file mode 100644 index 000000000..bee32f50b --- /dev/null +++ b/test-shared/src/test/resources/grammars/java8/correctInputs/java2.txt @@ -0,0 +1,12 @@ +package org.junit.tests.junit3compatibility; + +import junit.framework.Test; +import org.junit.runner.RunWith; +import org.junit.runners.AllTests; + +@RunWith(AllTests.class) +public class OldTests { + public static Test suite() { + return junit.tests.AllTests.suite(); + } +} diff --git a/test-shared/src/test/resources/grammars/java8/correctInputs/java3.txt b/test-shared/src/test/resources/grammars/java8/correctInputs/java3.txt new file mode 100644 index 000000000..3582f0ccc --- /dev/null +++ b/test-shared/src/test/resources/grammars/java8/correctInputs/java3.txt @@ -0,0 +1,14 @@ +package junit.tests.framework; + +import junit.framework.TestCase; + +public class OneTestCase extends TestCase { + public void noTestCase() { + } + + public void testCase() { + } + + public void testCase(int arg) { + } +} diff --git a/test-shared/src/test/resources/grammars/java8/correctInputs/java5.txt b/test-shared/src/test/resources/grammars/java8/correctInputs/java5.txt new file mode 100644 index 000000000..e55875c14 --- /dev/null +++ b/test-shared/src/test/resources/grammars/java8/correctInputs/java5.txt @@ -0,0 +1,16 @@ +package org.junit.internal.runners.statements; + +import org.junit.runners.model.Statement; + +public class Fail extends Statement { + private final Throwable error; + + public Fail(Throwable e) { + error = e; + } + + @Override + public void evaluate() throws Throwable { + throw error; + } +} diff --git a/test-shared/src/test/resources/grammars/java8/correctInputs/java6.txt b/test-shared/src/test/resources/grammars/java8/correctInputs/java6.txt new file mode 100644 index 000000000..ef21dd23b --- /dev/null +++ b/test-shared/src/test/resources/grammars/java8/correctInputs/java6.txt @@ -0,0 +1,13 @@ +package org.junit.tests.experimental.parallel; + +import org.junit.runner.RunWith; +import org.junit.runners.Suite; +import org.junit.runners.Suite.SuiteClasses; + +@RunWith(Suite.class) +@SuiteClasses({ + ParallelClassTest.class, + ParallelMethodTest.class +}) +public class AllParallelTests { +} diff --git a/test-shared/src/test/resources/grammars/java8/correctInputs/java7.txt b/test-shared/src/test/resources/grammars/java8/correctInputs/java7.txt new file mode 100644 index 000000000..5989e1be7 --- /dev/null +++ b/test-shared/src/test/resources/grammars/java8/correctInputs/java7.txt @@ -0,0 +1,17 @@ +package org.junit.tests.manipulation; + +import org.junit.runner.RunWith; +import org.junit.runners.Suite; +import org.junit.runners.Suite.SuiteClasses; + +@RunWith(Suite.class) +@SuiteClasses({ + FilterableTest.class, + FilterTest.class, + OrderableTest.class, + OrderWithTest.class, + SingleMethodTest.class, + SortableTest.class +}) +public class AllManipulationTests { +} diff --git a/test-shared/src/test/resources/grammars/java8/correctInputs/java8.txt b/test-shared/src/test/resources/grammars/java8/correctInputs/java8.txt new file mode 100644 index 000000000..2ff31d764 --- /dev/null +++ b/test-shared/src/test/resources/grammars/java8/correctInputs/java8.txt @@ -0,0 +1,24 @@ +package org.junit.internal.builders; + +import org.junit.internal.runners.SuiteMethod; +import org.junit.runner.Runner; +import org.junit.runners.model.RunnerBuilder; + +public class SuiteMethodBuilder extends RunnerBuilder { + @Override + public Runner runnerForClass(Class each) throws Throwable { + if (hasSuiteMethod(each)) { + return new SuiteMethod(each); + } + return null; + } + + public boolean hasSuiteMethod(Class testClass) { + try { + testClass.getMethod("suite"); + } catch (NoSuchMethodException e) { + return false; + } + return true; + } +} diff --git a/test-shared/src/test/resources/grammars/java8/correctInputs/java9.txt b/test-shared/src/test/resources/grammars/java8/correctInputs/java9.txt new file mode 100644 index 000000000..e85b58950 --- /dev/null +++ b/test-shared/src/test/resources/grammars/java8/correctInputs/java9.txt @@ -0,0 +1,32 @@ +package org.junit.internal.runners.statements; + +import java.util.List; + +import org.junit.runners.model.FrameworkMethod; +import org.junit.runners.model.Statement; + +public class RunBefores extends Statement { + private final Statement next; + + private final Object target; + + private final List befores; + + public RunBefores(Statement next, List befores, Object target) { + this.next = next; + this.befores = befores; + this.target = target; + } + + @Override + public void evaluate() throws Throwable { + for (FrameworkMethod before : befores) { + invokeMethod(before); + } + next.evaluate(); + } + + protected void invokeMethod(FrameworkMethod method) throws Throwable { + method.invokeExplosively(target); + } +} diff --git a/test-shared/src/test/resources/grammars/java8/incorrectInputs/java1.txt b/test-shared/src/test/resources/grammars/java8/incorrectInputs/java1.txt new file mode 100644 index 000000000..f247d12da --- /dev/null +++ b/test-shared/src/test/resources/grammars/java8/incorrectInputs/java1.txt @@ -0,0 +1,5 @@ +package org.junit.runner.manipulation; + +public ass NoTestsRemainException extends Exception { + private static final long serialVersionUID = 1L +} diff --git a/test-shared/src/test/resources/grammars/java8/incorrectInputs/java10.txt b/test-shared/src/test/resources/grammars/java8/incorrectInputs/java10.txt new file mode 100644 index 000000000..6fc61a7ab --- /dev/null +++ b/test-shared/src/test/resources/grammars/java8/incorrectInputs/java10.txt @@ -0,0 +1,37 @@ +package org.junit.internal.matchers; + +import org.hamcrest.Description; +import org.hamcrest.Factory; +import org.hamcrest.Matcher; +import org.hamcrest.TypeSafeMatcher; + +public class ThrowableMessageMatcher extends + TypeSafeMatcher + + private final Matcher matcher; + + public ThrowableMessageMatcher(Matcher matcher) { + this.matcher = matcher + } + + public void describeTo(Description description) { + description.appendText("exception with message "); + description.appendDescriptionOf(matcher); + } + + @Override + protected boolean matchesSafely(T item) { + return matcher.matches(item.getMessage()); + } + + @Override + protected void describeMismatchSafely(T item, Description description) { + description.appendText("message "); + matcher.describeMismatch(item.getMessage(), description); + } + + @Factory + public static Matcher hasMessage(final Matcher matcher) { + return new ThrowableMessageMatcher(matcher); + } +} diff --git a/test-shared/src/test/resources/grammars/java8/incorrectInputs/java2.txt b/test-shared/src/test/resources/grammars/java8/incorrectInputs/java2.txt new file mode 100644 index 000000000..40ae149a2 --- /dev/null +++ b/test-shared/src/test/resources/grammars/java8/incorrectInputs/java2.txt @@ -0,0 +1,12 @@ +package org.junit.tests.junit3compatibility; + +import junit.framework.Test; +import org.junit.runner.RunWith +import org.junit.runners.AllTests; + +@RunWith(AllTests.class) +public class OldTests { + public static Test suite() { + return junit.tests.AllTests.suite(); + } +} diff --git a/test-shared/src/test/resources/grammars/java8/incorrectInputs/java3.txt b/test-shared/src/test/resources/grammars/java8/incorrectInputs/java3.txt new file mode 100644 index 000000000..b027b5665 --- /dev/null +++ b/test-shared/src/test/resources/grammars/java8/incorrectInputs/java3.txt @@ -0,0 +1,14 @@ +package junit.tests.framework; + +import junit.framework.TestCase; + +public class OneTestCase extends TestCase { + public void noTestCase() { + } + + public void testCase { + } + + public void testCase(int arg) { + } +} diff --git a/test-shared/src/test/resources/grammars/java8/incorrectInputs/java4.txt b/test-shared/src/test/resources/grammars/java8/incorrectInputs/java4.txt new file mode 100644 index 000000000..a448a190e --- /dev/null +++ b/test-shared/src/test/resources/grammars/java8/incorrectInputs/java4.txt @@ -0,0 +1,66 @@ +package org.junit.experimental.categories; + +import static org.hamcrest.CoreMatchers.instanceOf; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.junit.runner.Description.createSuiteDescription; + +import java.util.List; + +import org.junit.Rule; +import org.junit.Test +import org.junit.rules.ExpectedException; +import org.junit.rules.TestName; +import org.junit.runner.Description; +import org.junit.runner.FilterFactory +import org.junit.runner.FilterFactoryParams; +import org.junit.runner.manipulation.Filter; + +public class CategoryFilterFactoryTest { + @Rule + public ExpectedException expectedException = ExpectedException.none(); + + @Rule + public TestName testName = new TestName(); + + private final CategoryFilterFactory categoryFilterFactory = new CategoryFilterFactoryStub(); + + @Test + public void shouldCreateFilter() throws Exception { + FilterFactoryParams params = new FilterFactoryParams( + createSuiteDescription(testName.getMethodName()), + CategoryFilterFactoryStub.class.getName()); + Filter filter = categoryFilterFactory.createFilter(params); + + assertThat(filter, instanceOf(DummyFilter.class)); + } + + @Test + public void shouldThrowException() throws Exception { + FilterFactoryParams params = new FilterFactoryParams( + createSuiteDescription(testName.getMethodName()), + "NonExistentFilter"); + + expectedException.expect(FilterFactory.FilterNotCreatedException.class); + + categoryFilterFactory.createFilter(params); + } + + private static class CategoryFilterFactoryStub extends CategoryFilterFactory { + @Override + protected Filter createFilter(List> categories) { + return new DummyFilter(); + } + } + + private static class DummyFilter extends Filter { + @Override + public boolean shouldRun(Description description) { + return false; + } + + @Override + public String describe() { + return null; + } + } +} diff --git a/test-shared/src/test/resources/grammars/java8/incorrectInputs/java5.txt b/test-shared/src/test/resources/grammars/java8/incorrectInputs/java5.txt new file mode 100644 index 000000000..2c34ba79f --- /dev/null +++ b/test-shared/src/test/resources/grammars/java8/incorrectInputs/java5.txt @@ -0,0 +1,16 @@ +package org.junit.internal.runners.statements; + +import org.junit.runners.model.Statement; + +public class Fail extends Statement { + private final Throwable error; + + public Fail(Throwable e) + error = e; + + + @Override + public void evaluate() throws Throwable { + throw error; + } +} diff --git a/test-shared/src/test/resources/grammars/java8/incorrectInputs/java6.txt b/test-shared/src/test/resources/grammars/java8/incorrectInputs/java6.txt new file mode 100644 index 000000000..927a6c91b --- /dev/null +++ b/test-shared/src/test/resources/grammars/java8/incorrectInputs/java6.txt @@ -0,0 +1,13 @@ +package org.junit.tests.experimental.parallel; + +import org.junit.runner.RunWith; +import org.junit.runners.Suite; +import org.junit.runners.Suite.SuiteClasses; + +@RunWith(Suite.class) +@SuiteClasses({ + ParallelClassTest.class + ParallelMethodTest.class +}) +public class AllParallelTests { +} diff --git a/test-shared/src/test/resources/grammars/java8/incorrectInputs/java7.txt b/test-shared/src/test/resources/grammars/java8/incorrectInputs/java7.txt new file mode 100644 index 000000000..9dc0c7621 --- /dev/null +++ b/test-shared/src/test/resources/grammars/java8/incorrectInputs/java7.txt @@ -0,0 +1,17 @@ +package org.junit.tests.manipulation; + +import org.junit.runner.RunWith; +import org.junit.runners.Suite; +import org.junit.runners.Suite.SuiteClasses; + +@RunWith(Suite.class) +@SuiteClasses({ + FilterableTest.class, + FilterTest.class, + OrderableTest.class, + OrderWithTest.class, + SingleMethodTest.class, + SortableTest.class + +public class AllManipulationTests { +} diff --git a/test-shared/src/test/resources/grammars/java8/incorrectInputs/java8.txt b/test-shared/src/test/resources/grammars/java8/incorrectInputs/java8.txt new file mode 100644 index 000000000..00e33c378 --- /dev/null +++ b/test-shared/src/test/resources/grammars/java8/incorrectInputs/java8.txt @@ -0,0 +1,24 @@ +package org.junit.internal.builders; + +import org.junit.internal.runners.SuiteMethod; +import org.junit.runner.Runner; +import org.junit.runners.model.RunnerBuilder; + +public class SuiteMethodBuilder extends RunnerBuilder { + @Override + public Runner runnerForClass(Class each) throws Throwable { + if (hasSuiteMethod(each)) { + return new SuiteMethod(each); + } + return null; + } + + public boolean hasSuiteMethod(Class testClass) { + try { + testClass.getMethod("suite"); + } (NoSuchMethodException e) { + return false; + } + return true; + } +} diff --git a/test-shared/src/test/resources/grammars/java8/incorrectInputs/java9.txt b/test-shared/src/test/resources/grammars/java8/incorrectInputs/java9.txt new file mode 100644 index 000000000..e8b3e9516 --- /dev/null +++ b/test-shared/src/test/resources/grammars/java8/incorrectInputs/java9.txt @@ -0,0 +1,32 @@ +package org.junit.internal.runners.statements; + +import java.util.List + +import org.junit.runners.model.FrameworkMethod; +import org.junit.runners.model.Statement; + +public class RunBefores extends Statement { + private final Statement next + + private final Object target; + + private final List befores; + + public RunBefores(Statement next, List befores, Object target) { + this.next = next; + this.befores = befores; + this.target = target; + } + + @Override + public void evaluate() throws Throwable { + for (FrameworkMethod before : befores) { + invokeMethod(before); + } + next.evaluate() + } + + protected void invokeMethod(FrameworkMethod method) throws Throwable { + method.invokeExplosively(target); + } +} diff --git a/test-shared/src/test/resources/grammars/java8/not_implemented/java4.txt b/test-shared/src/test/resources/grammars/java8/not_implemented/java4.txt new file mode 100644 index 000000000..f0bd7d5c6 --- /dev/null +++ b/test-shared/src/test/resources/grammars/java8/not_implemented/java4.txt @@ -0,0 +1,66 @@ +package org.junit.experimental.categories; + +import static org.hamcrest.CoreMatchers.instanceOf; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.junit.runner.Description.createSuiteDescription; + +import java.util.List; + +import org.junit.Rule; +import org.junit.Test; +import org.junit.rules.ExpectedException; +import org.junit.rules.TestName; +import org.junit.runner.Description; +import org.junit.runner.FilterFactory; +import org.junit.runner.FilterFactoryParams; +import org.junit.runner.manipulation.Filter; + +public class CategoryFilterFactoryTest { + @Rule + public ExpectedException expectedException = ExpectedException.none(); + + @Rule + public TestName testName = new TestName(); + + private final CategoryFilterFactory categoryFilterFactory = new CategoryFilterFactoryStub(); + + @Test + public void shouldCreateFilter() throws Exception { + FilterFactoryParams params = new FilterFactoryParams( + createSuiteDescription(testName.getMethodName()), + CategoryFilterFactoryStub.class.getName()); + Filter filter = categoryFilterFactory.createFilter(params); + + assertThat(filter, instanceOf(DummyFilter.class)); + } + + @Test + public void shouldThrowException() throws Exception { + FilterFactoryParams params = new FilterFactoryParams( + createSuiteDescription(testName.getMethodName()), + "NonExistentFilter"); + + expectedException.expect(FilterFactory.FilterNotCreatedException.class); + + categoryFilterFactory.createFilter(params); + } + + private static class CategoryFilterFactoryStub extends CategoryFilterFactory { + @Override + protected Filter createFilter(List> categories) { + return new DummyFilter(); + } + } + + private static class DummyFilter extends Filter { + @Override + public boolean shouldRun(Description description) { + return false; + } + + @Override + public String describe() { + return null; + } + } +} diff --git a/test-shared/src/test/resources/grammars/multi_dyck/ScanerlessGrammarDsl.kt b/test-shared/src/test/resources/grammars/multi_dyck/ScanerlessGrammarDsl.kt new file mode 100644 index 000000000..c071badd4 --- /dev/null +++ b/test-shared/src/test/resources/grammars/multi_dyck/ScanerlessGrammarDsl.kt @@ -0,0 +1,16 @@ +package grammars.multi_dyck + +import org.ucfs.grammar.combinator.Grammar +import org.ucfs.grammar.combinator.extension.StringExtension.times +import org.ucfs.grammar.combinator.regexp.* + +class ScanerlessGrammarDsl: Grammar() { + val S by Nt().asStart() + val S1 by Nt("(" * S * ")" * S) + val S2 by Nt("{" * S * "}" * S) + val S3 by Nt("[" * S * "]" * S) + + init { + S /= Epsilon or S1 or S2 or S3 + } +} \ No newline at end of file diff --git a/test-shared/src/test/resources/grammars/multi_dyck/grammar.rsm b/test-shared/src/test/resources/grammars/multi_dyck/grammar.rsm new file mode 100644 index 000000000..1ac068691 --- /dev/null +++ b/test-shared/src/test/resources/grammars/multi_dyck/grammar.rsm @@ -0,0 +1,39 @@ +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) +State(id=2,nonterminal=Nonterminal("S"),isStart=false,isFinal=true) +State(id=3,nonterminal=Nonterminal("S"),isStart=false,isFinal=true) +State(id=4,nonterminal=Nonterminal("S1"),isStart=true,isFinal=false) +State(id=5,nonterminal=Nonterminal("S1"),isStart=false,isFinal=false) +State(id=6,nonterminal=Nonterminal("S1"),isStart=false,isFinal=false) +State(id=7,nonterminal=Nonterminal("S1"),isStart=false,isFinal=false) +State(id=8,nonterminal=Nonterminal("S1"),isStart=false,isFinal=true) +State(id=9,nonterminal=Nonterminal("S2"),isStart=true,isFinal=false) +State(id=10,nonterminal=Nonterminal("S2"),isStart=false,isFinal=false) +State(id=11,nonterminal=Nonterminal("S2"),isStart=false,isFinal=false) +State(id=12,nonterminal=Nonterminal("S2"),isStart=false,isFinal=false) +State(id=13,nonterminal=Nonterminal("S2"),isStart=false,isFinal=true) +State(id=14,nonterminal=Nonterminal("S3"),isStart=true,isFinal=false) +State(id=15,nonterminal=Nonterminal("S3"),isStart=false,isFinal=false) +State(id=16,nonterminal=Nonterminal("S3"),isStart=false,isFinal=false) +State(id=17,nonterminal=Nonterminal("S3"),isStart=false,isFinal=false) +State(id=18,nonterminal=Nonterminal("S3"),isStart=false,isFinal=true) + +NonterminalEdge(tail=0,head=1,nonterminal=Nonterminal("S1")) +NonterminalEdge(tail=0,head=2,nonterminal=Nonterminal("S2")) +NonterminalEdge(tail=0,head=3,nonterminal=Nonterminal("S3")) + +TerminalEdge(tail=4,head=5,terminal=Terminal("(")) +NonterminalEdge(tail=5,head=6,nonterminal=Nonterminal("S")) +TerminalEdge(tail=6,head=7,terminal=Terminal(")")) +NonterminalEdge(tail=7,head=8,nonterminal=Nonterminal("S")) + +TerminalEdge(tail=9,head=10,terminal=Terminal("{")) +NonterminalEdge(tail=10,head=11,nonterminal=Nonterminal("S")) +TerminalEdge(tail=11,head=12,terminal=Terminal("}")) +NonterminalEdge(tail=12,head=13,nonterminal=Nonterminal("S")) + +TerminalEdge(tail=14,head=15,terminal=Terminal("[")) +NonterminalEdge(tail=15,head=16,nonterminal=Nonterminal("S")) +TerminalEdge(tail=16,head=17,terminal=Terminal("]")) +NonterminalEdge(tail=17,head=18,nonterminal=Nonterminal("S")) \ No newline at end of file diff --git a/test-shared/src/test/resources/grammars/multi_dyck/oneLineErrorInputs.txt b/test-shared/src/test/resources/grammars/multi_dyck/oneLineErrorInputs.txt new file mode 100644 index 000000000..6bb8a95f8 --- /dev/null +++ b/test-shared/src/test/resources/grammars/multi_dyck/oneLineErrorInputs.txt @@ -0,0 +1,14 @@ +( +) +[ +] +{ +} +[ ( +) } +] [ +] [ ( +[ ] } +} { ( ) +( } { ] [ ( ) +[ ] ] ) ( { ] \ No newline at end of file diff --git a/test-shared/src/test/resources/grammars/multi_dyck/oneLineInputs.txt b/test-shared/src/test/resources/grammars/multi_dyck/oneLineInputs.txt new file mode 100644 index 000000000..2654829bb --- /dev/null +++ b/test-shared/src/test/resources/grammars/multi_dyck/oneLineInputs.txt @@ -0,0 +1,11 @@ + +( ) +{ } +[ ] +( [ ] ) +{ ( ) } +[ { } ] +{ } [ ( ) ] +[ ] { ( ) } +( { [ ] } ) +( ) { } [ ] \ No newline at end of file diff --git a/test-shared/src/test/resources/grammars/simple_golang/ScanerlessGrammarDsl.kt b/test-shared/src/test/resources/grammars/simple_golang/ScanerlessGrammarDsl.kt new file mode 100644 index 000000000..2d12dfd8a --- /dev/null +++ b/test-shared/src/test/resources/grammars/simple_golang/ScanerlessGrammarDsl.kt @@ -0,0 +1,15 @@ +package grammars.simple_golang + +import org.ucfs.grammar.combinator.Grammar +import org.ucfs.grammar.combinator.extension.StringExtension.or +import org.ucfs.grammar.combinator.extension.StringExtension.times +import org.ucfs.grammar.combinator.regexp.Many +import org.ucfs.grammar.combinator.regexp.Nt +import org.ucfs.grammar.combinator.regexp.or + +class ScanerlessGrammarDsl : Grammar() { + val IntExpr by Nt("1" or "1" * "+" * "1") + val Statement by Nt(IntExpr * ";" or "r" * IntExpr * ";") + val Block by Nt(Many(Statement)) + val Program by Nt(Block).asStart() +} \ No newline at end of file diff --git a/test-shared/src/test/resources/grammars/simple_golang/grammar.rsm b/test-shared/src/test/resources/grammars/simple_golang/grammar.rsm new file mode 100644 index 000000000..539ecab5e --- /dev/null +++ b/test-shared/src/test/resources/grammars/simple_golang/grammar.rsm @@ -0,0 +1,23 @@ +StartState(id=0,nonterminal=Nonterminal("Program"),isStart=true,isFinal=false) +State(id=0,nonterminal=Nonterminal("Program"),isStart=true,isFinal=false) +State(id=1,nonterminal=Nonterminal("Program"),isStart=false,isFinal=true) +State(id=3,nonterminal=Nonterminal("Block"),isStart=true,isFinal=true) +State(id=4,nonterminal=Nonterminal("Statement"),isStart=true,isFinal=false) +State(id=5,nonterminal=Nonterminal("Statement"),isStart=false,isFinal=false) +State(id=6,nonterminal=Nonterminal("Statement"),isStart=false,isFinal=false) +State(id=7,nonterminal=Nonterminal("Statement"),isStart=false,isFinal=true) +State(id=8,nonterminal=Nonterminal("IntExpr"),isStart=true,isFinal=false) +State(id=9,nonterminal=Nonterminal("IntExpr"),isStart=false,isFinal=true) +State(id=10,nonterminal=Nonterminal("IntExpr"),isStart=false,isFinal=false) +State(id=11,nonterminal=Nonterminal("IntExpr"),isStart=false,isFinal=true) + +NonterminalEdge(tail=0,head=1,nonterminal=Nonterminal("Block")) +NonterminalEdge(tail=3,head=3,nonterminal=Nonterminal("Statement")) +NonterminalEdge(tail=4,head=6,nonterminal=Nonterminal("IntExpr")) +NonterminalEdge(tail=5,head=6,nonterminal=Nonterminal("IntExpr")) + +TerminalEdge(tail=4,head=5,terminal=Terminal("r")) +TerminalEdge(tail=6,head=7,terminal=Terminal(";")) +TerminalEdge(tail=8,head=9,terminal=Terminal("1")) +TerminalEdge(tail=9,head=10,terminal=Terminal("+")) +TerminalEdge(tail=10,head=11,terminal=Terminal("1")) \ No newline at end of file diff --git a/test-shared/src/test/resources/grammars/simple_golang/oneLineErrorInputs.txt b/test-shared/src/test/resources/grammars/simple_golang/oneLineErrorInputs.txt new file mode 100644 index 000000000..1d8dc1803 --- /dev/null +++ b/test-shared/src/test/resources/grammars/simple_golang/oneLineErrorInputs.txt @@ -0,0 +1,6 @@ +r +; ; +r 1 ; ; +r ; + ; +1 + ; + 1 ; + 1 + r ; ++ + + ; r + r ; \ No newline at end of file diff --git a/test-shared/src/test/resources/grammars/simple_golang/oneLineInputs.txt b/test-shared/src/test/resources/grammars/simple_golang/oneLineInputs.txt new file mode 100644 index 000000000..d9acb75b3 --- /dev/null +++ b/test-shared/src/test/resources/grammars/simple_golang/oneLineInputs.txt @@ -0,0 +1,7 @@ + +r 1 ; +r 1 + 1 ; +1 ; +1 + 1 ; +1 ; 1 + 1 ; 1 ; +r 1 ; r 1 + 1 ; 1 ; 1 + 1 ; \ No newline at end of file diff --git a/test-shared/src/test/resources/todo/LoopDyck/minimalWorstCase/input.dot b/test-shared/src/test/resources/todo/LoopDyck/minimalWorstCase/input.dot new file mode 100644 index 000000000..7c08420c5 --- /dev/null +++ b/test-shared/src/test/resources/todo/LoopDyck/minimalWorstCase/input.dot @@ -0,0 +1,7 @@ +digraph Input { + label="Minimal worst case, simple loop RSM for Dyck language" + start -> 0; + 0 -> 0 [label = "("]; + 0 -> 1 [label = ")"]; + 1 -> 0 [label = ")"]; +} \ No newline at end of file diff --git a/test-shared/src/test/resources/todo/LoopDyck/minimalWorstCase/result.dot b/test-shared/src/test/resources/todo/LoopDyck/minimalWorstCase/result.dot new file mode 100644 index 000000000..8e702aee9 --- /dev/null +++ b/test-shared/src/test/resources/todo/LoopDyck/minimalWorstCase/result.dot @@ -0,0 +1,43 @@ +digraph g { +labelloc="t" +label="" +0 [label = "Epsilon RSM: S_0, input: [0, 0]", shape = invhouse] +1 [label = "Intermediate input: 0, rsm: S_1, input: [0, 0]", shape = plain] +2 [label = "Intermediate input: 0, rsm: S_1, input: [0, 1]", shape = plain] +3 [label = "Intermediate input: 0, rsm: S_2, input: [0, 1]", shape = plain] +4 [label = "Intermediate input: 1, rsm: S_2, input: [0, 0]", shape = plain] +5 [label = "Nonterminal S, input: [0, 0]", shape = invtrapezium] +6 [label = "Nonterminal S, input: [0, 1]", shape = invtrapezium] +7 [label = "Range , input: [0, 0], rsm: [S_0, S_0]", shape = ellipse] +8 [label = "Range , input: [0, 0], rsm: [S_0, S_1]", shape = ellipse] +9 [label = "Range , input: [0, 0], rsm: [S_0, S_2]", shape = ellipse] +10 [label = "Range , input: [0, 0], rsm: [S_1, S_2]", shape = ellipse] +11 [label = "Range , input: [0, 1], rsm: [S_0, S_0]", shape = ellipse] +12 [label = "Range , input: [0, 1], rsm: [S_0, S_2]", shape = ellipse] +13 [label = "Range , input: [0, 1], rsm: [S_1, S_2]", shape = ellipse] +14 [label = "Range , input: [0, 1], rsm: [S_2, S_0]", shape = ellipse] +15 [label = "Range , input: [1, 0], rsm: [S_2, S_0]", shape = ellipse] +16 [label = "Terminal '(', input: [0, 0]", shape = rectangle] +17 [label = "Terminal ')', input: [0, 1]", shape = rectangle] +18 [label = "Terminal ')', input: [1, 0]", shape = rectangle] +1->8 +1->10 +2->8 +2->13 +3->9 +3->14 +4->12 +4->15 +5->7 +6->11 +7->0 +7->4 +8->16 +9->1 +10->5 +11->3 +12->2 +13->6 +14->17 +15->18 +}