commonMain.api.processor.optionsDefault.kt Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of agl-processor-jvm8 Show documentation
Dynamic, scan-on-demand, parsing; when a regular expression is just not enough
The newest version!
/**
 * Copyright (C) 2022 Dr. David H. Akehurst (http://dr.david.h.akehurst.net)
 *
 * 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
 *
 *         http://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.
 */

package net.akehurst.language.api.processor

import net.akehurst.language.api.parser.InputLocation

internal class LanguageProcessorConfigurationDefault(
    override var targetGrammarName: String?,
    override var defaultGoalRuleName: String?,
    override var typeModelResolver: TypeModelResolver?,
    override var scopeModelResolver: ScopeModelResolver?,
    override var syntaxAnalyserResolver: SyntaxAnalyserResolver?,
    override var semanticAnalyserResolver: SemanticAnalyserResolver?,
    override var formatterResolver: FormatterResolver?,
    override var styleResolver: StyleResolver?,
    override var completionProvider: CompletionProviderResolver?
) : LanguageProcessorConfiguration

internal class ProcessOptionsDefault(
    override val parse: ParseOptions = ParseOptionsDefault(),
    override val syntaxAnalysis: SyntaxAnalysisOptions = SyntaxAnalysisOptionsDefault(),
    override val semanticAnalysis: SemanticAnalysisOptions = SemanticAnalysisOptionsDefault(),
    override val completionProvider: CompletionProviderOptions = CompletionProviderOptionsDefault()
) : ProcessOptions

internal class ParseOptionsDefault(
    override var goalRuleName: String? = null,
    override var automatonKind: AutomatonKind = AutomatonKind.LOOKAHEAD_1,
    override var reportErrors: Boolean = true,
    override val reportGrammarAmbiguities: Boolean = false,
    override var cacheSkip: Boolean = true
) : ParseOptions

internal class SyntaxAnalysisOptionsDefault(
    override var active: Boolean = true
) : SyntaxAnalysisOptions

internal class SemanticAnalysisOptionsDefault(
    override var active: Boolean = true,
    override var locationMap: Map = emptyMap(),
    override var context: ContextType? = null,
    override var checkReferences: Boolean = true,
    override var resolveReferences: Boolean = true,
    override val other: Map = mutableMapOf()
) : SemanticAnalysisOptions

internal class CompletionProviderOptionsDefault(
    override var context: ContextType? = null,
    override val options: Map = mutableMapOf()
) : CompletionProviderOptions

@DslMarker
annotation class LanguageProcessorConfigurationDslMarker

@LanguageProcessorConfigurationDslMarker
class LanguageProcessorConfigurationBuilder(
    val base: LanguageProcessorConfiguration?
) {

    private var _targetGrammarName: String? = null
    private var _defaultGoalRuleName: String? = null
    private var _typeModelResolver: TypeModelResolver? = null
    private var _scopeModelResolver: ScopeModelResolver? = null
    private var _syntaxAnalyserResolver: SyntaxAnalyserResolver? = null
    private var _semanticAnalyserResolver: SemanticAnalyserResolver? = null
    private var _formatterResolver: FormatterResolver? = null
    private var _styleResolver: StyleResolver? = null
    private var _completionProviderResolver: CompletionProviderResolver? = null

    fun targetGrammarName(value: String?) {
        _targetGrammarName = value
    }

    fun defaultGoalRuleName(value: String?) {
        _defaultGoalRuleName = value
    }

    fun typeModelResolver(func: TypeModelResolver?) {
        this._typeModelResolver = func
    }

    fun scopeModelResolver(func: ScopeModelResolver?) {
        _scopeModelResolver = func
    }

    fun syntaxAnalyserResolver(func: SyntaxAnalyserResolver?) {
        _syntaxAnalyserResolver = func
    }

    fun semanticAnalyserResolver(value: SemanticAnalyserResolver?) {
        _semanticAnalyserResolver = value
    }

    fun formatterResolver(func: FormatterResolver?) {
        _formatterResolver = func
    }

    fun styleResolver(func: StyleResolver?) {
        _styleResolver = func
    }

    fun completionProvider(value: CompletionProviderResolver?) {
        _completionProviderResolver = value
    }

    fun build(): LanguageProcessorConfiguration {
        return when (base) {
            null -> LanguageProcessorConfigurationDefault(
                _targetGrammarName,
                _defaultGoalRuleName,
                _typeModelResolver,
                _scopeModelResolver,
                _syntaxAnalyserResolver,
                _semanticAnalyserResolver,
                _formatterResolver,
                _styleResolver,
                _completionProviderResolver
            )

            is LanguageProcessorConfigurationDefault -> LanguageProcessorConfigurationDefault(
                targetGrammarName = _targetGrammarName ?: base.targetGrammarName,
                defaultGoalRuleName = _defaultGoalRuleName ?: base.defaultGoalRuleName,
                typeModelResolver = _typeModelResolver ?: base.typeModelResolver,
                scopeModelResolver = _scopeModelResolver ?: base.scopeModelResolver,
                syntaxAnalyserResolver = _syntaxAnalyserResolver ?: base.syntaxAnalyserResolver,
                semanticAnalyserResolver = _semanticAnalyserResolver ?: base.semanticAnalyserResolver,
                formatterResolver = _formatterResolver ?: base.formatterResolver,
                styleResolver = _styleResolver ?: base.styleResolver,
                completionProvider = _completionProviderResolver ?: base.completionProvider
            )

            else -> error("Cannot override LanguageProcessorConfiguration of type ${base::class.simpleName}")
        }
    }
}

@DslMarker
annotation class ProcessOptionsDslMarker

@ProcessOptionsDslMarker
class ProcessOptionsBuilder {

    private var _parser: ParseOptions = ParseOptionsDefault()
    private var _syntaxAnalyser: SyntaxAnalysisOptions = SyntaxAnalysisOptionsDefault()
    private var _semanticAnalyser: SemanticAnalysisOptions = SemanticAnalysisOptionsDefault()
    private var _completionProvider: CompletionProviderOptions = CompletionProviderOptionsDefault()

    fun parse(init: ParseOptionsBuilder.() -> Unit) {
        val b = ParseOptionsBuilder()
        b.init()
        _parser = b.build()
    }

    fun syntaxAnalysis(init: SyntaxAnalysisOptionsBuilder.() -> Unit) {
        val b = SyntaxAnalysisOptionsBuilder()
        b.init()
        _syntaxAnalyser = b.build()
    }

    fun semanticAnalysis(init: SemanticAnalysisOptionsBuilder.() -> Unit) {
        val b = SemanticAnalysisOptionsBuilder()
        b.init()
        _semanticAnalyser = b.build()
    }

    fun completionProvider(init: CompletionProviderOptionsBuilder.() -> Unit) {
        val b = CompletionProviderOptionsBuilder()
        b.init()
        _completionProvider = b.build()
    }

    fun build(): ProcessOptions {
        return ProcessOptionsDefault(_parser, _syntaxAnalyser, _semanticAnalyser, _completionProvider)
    }
}

@ProcessOptionsDslMarker
class ParseOptionsBuilder {
    private var _goalRuleName: String? = null
    private var _automatonKind: AutomatonKind = AutomatonKind.LOOKAHEAD_1
    private var _reportErrors: Boolean = true
    private var _reportGrammarAmbiguities = false
    private var _cacheSkip: Boolean = true

    fun goalRuleName(value: String?) {
        _goalRuleName = value
    }

    fun automatonKind(value: AutomatonKind) {
        _automatonKind = value
    }

    fun reportErrors(value: Boolean) {
        _reportErrors = value
    }

    fun reportGrammarAmbiguities(value: Boolean) {
        _reportGrammarAmbiguities = value
    }

    fun cacheSkip(value: Boolean) {
        _cacheSkip = value
    }

    fun build(): ParseOptions {
        return ParseOptionsDefault(_goalRuleName, _automatonKind, _reportErrors, _reportGrammarAmbiguities, _cacheSkip)
    }
}

@ProcessOptionsDslMarker
class SyntaxAnalysisOptionsBuilder() {

    private var _active = true

    fun active(value: Boolean) {
        _active = value
    }

    fun build(): SyntaxAnalysisOptions {
        return SyntaxAnalysisOptionsDefault(_active)
    }
}

@ProcessOptionsDslMarker
class SemanticAnalysisOptionsBuilder() {

    private var _active = true
    private var _locationMap = emptyMap()
    private var _context: ContextType? = null
    private var _checkReferences = true
    private var _resolveReferences = true
    private val _options = mutableMapOf()

    fun active(value: Boolean) {
        _active = value
    }

    fun locationMap(value: Map) {
        _locationMap = value
    }

    fun context(value: ContextType?) {
        _context = value
    }

    fun checkReferences(value: Boolean) {
        _checkReferences = value
    }

    fun resolveReferences(value: Boolean) {
        _resolveReferences = value
    }

    fun option(key: String, value: Any) {
        _options[key] = value
    }

    fun build(): SemanticAnalysisOptions {
        return SemanticAnalysisOptionsDefault(
            _active,
            _locationMap,
            _context,
            _checkReferences,
            _resolveReferences,
            _options
        )
    }
}

@ProcessOptionsDslMarker
class CompletionProviderOptionsBuilder() {

    private var _context: ContextType? = null
    private val _options = mutableMapOf()

    fun context(value: ContextType?) {
        _context = value
    }

    fun option(key: String, value: Any) {
        _options[key] = value
    }

    fun build(): CompletionProviderOptions {
        return CompletionProviderOptionsDefault(_context, _options)
    }
}