gradle-grammarkit-plugin/org.jetbrains.grammarkit.tasks/GenerateLexerTask

GenerateLexerTask

@CacheableTask

abstract class GenerateLexerTask : JavaExec

The generateLexer task generates a lexer for the given grammar. The task is configured using common org.jetbrains.grammarkit.GrammarKitPluginExtension extension.

Constructors

GenerateLexerTask

constructor()

Properties

actions

open var actions: List<Action<in Task>>

allJvmArgs

open var allJvmArgs: List<String>

ant

open val ant: AntBuilder

args

open var args: List<String>

argumentProviders

open val argumentProviders: List<CommandLineArgumentProvider>

asDynamicObject

@get:Internal

open val asDynamicObject: DynamicObject

bootstrapClasspath

open var bootstrapClasspath: FileCollection

classpath

open var classpath: FileCollection

commandLine

@get:Internal

open val commandLine: List<String>

conventionMapping

@get:Internal

open val conventionMapping: ConventionMapping

debug

open var debug: Boolean

debugOptions

open val debugOptions: JavaDebugOptions

defaultCharacterEncoding

open var defaultCharacterEncoding: @Nullable String?

dependsOn

open val dependsOn: Set<Any>

description

open var description: @Nullable String?

destroyables

open val destroyables: TaskDestroyables

didWork

open var didWork: Boolean

enableAssertions

open var enableAssertions: Boolean

enabled

open var enabled: Boolean

environment

@get:Internal

open var environment: Map<String, Any>

errorOutput

@get:Internal

open var errorOutput: OutputStream

executable

@get:Internal(value = "covered by getJavaVersion")

open val executable: @Nullable String?

executionResult

@get:Internal

open val executionResult: Provider<ExecResult>

extensions

open val extensions: ExtensionContainer

finalizedBy

open val finalizedBy: TaskDependency

group

open var group: @Nullable String?

identityPath

open val identityPath: Path

impliesSubProjects

open var impliesSubProjects: Boolean

inputs

open val inputs: TaskInputsInternal

isCompatibleWithConfigurationCache

open val isCompatibleWithConfigurationCache: Boolean

isEnabled

@get:Internal

open var isEnabled: Boolean

isHasCustomActions

open val isHasCustomActions: Boolean

isIgnoreExitValue

@get:Input

open var isIgnoreExitValue: Boolean

javaLauncher

open val javaLauncher: Property<JavaLauncher>

javaVersion

@get:Input

open val javaVersion: JavaVersion

jvmArgs

open var jvmArgs: List<String>

jvmArgumentProviders

open val jvmArgumentProviders: List<CommandLineArgumentProvider>

jvmArguments

open val jvmArguments: ListProperty<String>

lifecycleDependencies

@get:Internal

open val lifecycleDependencies: TaskDependencyInternal

localState

open val localState: TaskLocalState

logger

open val logger: Logger

logging

open val logging: LoggingManager

mainClass

open val mainClass: Property<String>

mainModule

open val mainModule: Property<String>

maxHeapSize

open var maxHeapSize: @Nullable String?

minHeapSize

open var minHeapSize: @Nullable String?

modularity

open val modularity: ModularitySpec

mustRunAfter

open val mustRunAfter: TaskDependency

name

open val name: String

onlyIf

open val onlyIf: Spec<in TaskInternal>

outputs

open val outputs: TaskOutputsInternal

path

open val path: String

project

open val project: Project

purgeOldFiles

@get:Input

@get:Optional

abstract val purgeOldFiles: Property<Boolean>

Purge old files from the target directory before generating the lexer.

reasonNotToTrackState

open val reasonNotToTrackState: Optional<String>

reasonTaskIsIncompatibleWithConfigurationCache

open val reasonTaskIsIncompatibleWithConfigurationCache: Optional<String>

requiredServices

open val requiredServices: TaskRequiredServices

sharedResources

open val sharedResources: List<ResourceLock>

shouldRunAfter

open val shouldRunAfter: TaskDependency

skeleton

@get:InputFile

@get:PathSensitive(value = PathSensitivity.RELATIVE)

@get:Optional

abstract val skeleton: RegularFileProperty

An optional path to the skeleton file to use for the generated lexer. The path will be provided as --skel option. By default, it uses the idea-flex.skeleton skeleton file.

source

@get:Internal

abstract val ~~source~~: Property<String>

sourceFile

@get:InputFile

@get:PathSensitive(value = PathSensitivity.RELATIVE)

abstract val sourceFile: RegularFileProperty

Required. The source Flex file to generate the lexer from.

standardInput

@get:Internal

open var standardInput: InputStream

standardOutput

@get:Internal

open var standardOutput: OutputStream

standardOutputCapture

open val standardOutputCapture: StandardOutputCapture

state

open val state: TaskStateInternal

systemProperties

open var systemProperties: Map<String, @Nullable Any?>

targetClass

@get:Internal

abstract val ~~targetClass~~: Property<String>

The Java file name where the generated lexer will be written.

targetDir

@get:Internal

abstract val ~~targetDir~~: Property<String>

The path to the target directory for the generated lexer.

targetFile

@get:Internal

abstract val ~~targetFile~~: RegularFileProperty

The output file computed from the targetDir and targetClass properties.

targetOutputDir

@get:OutputDirectory

abstract val targetOutputDir: DirectoryProperty

Required. The output directory for the generated lexer.

taskActions

open val taskActions: List<InputChangesAwareTaskAction>

taskDependencies

open val taskDependencies: TaskDependencyInternal

taskIdentity

open val taskIdentity: TaskIdentity<*>

temporaryDir

open val temporaryDir: File

temporaryDirFactory

open val temporaryDirFactory: Factory<File>

timeout

open val timeout: Property<Duration>

workingDir

@get:Internal

open var workingDir: File

Functions

acceptServiceReferences

open fun acceptServiceReferences(serviceReferences: Set<ServiceReferenceSpec>)

appendParallelSafeAction

open fun appendParallelSafeAction(action: Action<in Task>)

args

open fun args(vararg args: Any): JavaExec

open fun args(args: Iterable<*>): JavaExecSpec

bootstrapClasspath

open fun bootstrapClasspath(vararg classpath: @Nullable Any?): JavaExec

classpath

open fun classpath(vararg paths: @Nullable Any?): JavaExec

compareTo

open operator fun compareTo(otherTask: Task): Int

configure

open fun configure(closure: Closure<*>): Task

conventionMapping

open fun conventionMapping(property: String, mapping: Closure<*>): Task

open fun conventionMapping(property: String, mapping: Callable<*>): Task

copyTo

open fun copyTo(options: JavaForkOptions): JavaExec

open fun copyTo(target: ProcessForkOptions): JavaExec

debugOptions

open fun debugOptions(action: Action<JavaDebugOptions>)

dependsOn

open fun dependsOn(vararg paths: Any): Task

doFirst

open fun doFirst(action: Closure<*>): Task

open fun doFirst(action: Action<in Task>): Task

open fun doFirst(actionName: String, action: Action<in Task>): Task

doLast

open fun doLast(action: Closure<*>): Task

open fun doLast(action: Action<in Task>): Task

open fun doLast(actionName: String, action: Action<in Task>): Task

doNotTrackState

open fun doNotTrackState(reasonNotToTrackState: String)

environment

open fun environment(environmentVariables: Map<String, *>): JavaExec

open fun environment(name: String, value: Any): JavaExec

exec

open override fun exec()

executable

open fun executable(executable: Any): JavaExec

finalizedBy

open fun finalizedBy(vararg paths: Any): Task

hasProperty

open fun hasProperty(propertyName: String): Boolean

hasTaskActions

open fun hasTaskActions(): Boolean

jvmArgs

open fun jvmArgs(vararg arguments: Any): JavaExec

open fun jvmArgs(arguments: Iterable<*>): JavaExec

mustRunAfter

open fun mustRunAfter(vararg paths: Any): Task

notCompatibleWithConfigurationCache

open fun notCompatibleWithConfigurationCache(reason: String)

onlyIf

open fun onlyIf(onlyIfClosure: Closure<*>)

open fun onlyIf(spec: Spec<in Task>)

open fun onlyIf(onlyIfReason: String, spec: Spec<in Task>)

prependParallelSafeAction

open fun prependParallelSafeAction(action: Action<in Task>)

property

open fun property(propertyName: String): Any

setArgsString

open fun setArgsString(args: String): JavaExec

setDependsOn

open fun setDependsOn(dependsOn: Iterable<*>)

setExecutable

open fun setExecutable(executable: Any)

open fun setExecutable(executable: String)

setFinalizedBy

open fun setFinalizedBy(finalizedByTasks: Iterable<*>)

setMustRunAfter

open fun setMustRunAfter(mustRunAfterTasks: Iterable<*>)

setOnlyIf

open fun setOnlyIf(onlyIfClosure: Closure<*>)

open fun setOnlyIf(spec: Spec<in Task>)

open fun setOnlyIf(onlyIfReason: String, spec: Spec<in Task>)

setProperty

open fun setProperty(name: String, value: Any)

setShouldRunAfter

open fun setShouldRunAfter(shouldRunAfterTasks: Iterable<*>)

shouldRunAfter

open fun shouldRunAfter(vararg paths: Any): TaskDependency

systemProperties

open fun systemProperties(properties: Map<String, out @Nullable Any?>): JavaExec

systemProperty

open fun systemProperty(name: String, value: @Nullable Any?): JavaExec

targetFile

fun targetFile(lexerClass: String): Provider<RegularFile>

fun targetFile(lexerClass: Provider<String>): Provider<RegularFile>

The location of the lexer class computed from the targetOutputDir. Because the lexer class is defined in the flex file, it needs to be passed here too.

usesService

open fun usesService(service: Provider<out BuildService<*>>)

workingDir

open fun workingDir(dir: Any): JavaExec