Myzel394/config-lsp
1
0
Fork 0
mirror of https://github.com/Myzel394/config-lsp.git synced 2025-06-18 23:15:26 +02:00
Code Issues Packages Projects Releases Wiki Activity

chore: Update parsers; Add update script

Browse Source
This commit is contained in:
Myzel394 2024-09-22 11:22:38 +02:00
parent 250ec83a59
commit 4eb4a1845c
No known key found for this signature in database
GPG Key ID: DEC4AAB876F73185
52 changed files with 2914 additions and 109 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
handlers/ssh_config/Config.g4
View File

@ -13,17 +13,23 @@ separator
;
key
: STRING
: string
;
value
: (STRING WHITESPACE)* STRING? WHITESPACE?
: (string WHITESPACE)* string? WHITESPACE?
;
leadingComment
: HASH WHITESPACE? (STRING WHITESPACE?)+
: HASH WHITESPACE? (string WHITESPACE?)+
;
string
: (QUOTED_STRING | STRING)
;
///////////////////////////////////////////////
HASH
: '#'
;
@ -33,9 +39,13 @@ WHITESPACE
;
STRING
: ~(' ' | '\t' | '\r' | '\n' | '#')+
: ~('#' | '\r' | '\n' | '"' | ' ' | '\t')+
;
NEWLINE
: '\r'? '\n'
;
QUOTED_STRING
: '"' WHITESPACE? (STRING WHITESPACE)* STRING? ('"')?
;

2
handlers/sshd_config/analyzer/analyzer.go
View File

@ -10,7 +10,7 @@ import (
)
func Analyze(
d *sshdconfig.SSHDocument,
d *sshdconfig.SSHDDocument,
) []protocol.Diagnostic {
errors := analyzeStructureIsValid(d)

8
handlers/sshd_config/analyzer/include.go
View File

@ -17,7 +17,7 @@ import (
var whitespacePattern = regexp.MustCompile(`\S+`)
func analyzeIncludeValues(
d *sshdconfig.SSHDocument,
d *sshdconfig.SSHDDocument,
) []common.LSPError {
errs := make([]common.LSPError, 0)
@ -70,12 +70,12 @@ func createIncludePaths(
func parseFile(
filePath string,
) (*sshdconfig.SSHDocument, error) {
) (*sshdconfig.SSHDDocument, error) {
if d, ok := sshdconfig.DocumentParserMap[filePath]; ok {
return d, nil
}
c := ast.NewSSHConfig()
c := ast.NewSSHDConfig()
content, err := os.ReadFile(filePath)
@ -89,7 +89,7 @@ func parseFile(
return nil, errors.New(fmt.Sprintf("Errors in %s", filePath))
}
d := &sshdconfig.SSHDocument{
d := &sshdconfig.SSHDDocument{
Config: c,
}

6
handlers/sshd_config/analyzer/match.go
View File

@ -2,8 +2,8 @@ package analyzer
import (
"config-lsp/common"
"config-lsp/common/parsers/openssh-match-parser"
sshdconfig "config-lsp/handlers/sshd_config"
"config-lsp/handlers/sshd_config/match-parser"
"config-lsp/utils"
"errors"
"fmt"
@ -11,7 +11,7 @@ import (
)
func analyzeMatchBlocks(
d *sshdconfig.SSHDocument,
d *sshdconfig.SSHDDocument,
) []common.LSPError {
errs := make([]common.LSPError, 0)
@ -54,7 +54,7 @@ func analyzeMatchBlocks(
}
func analyzeMatchValueNegation(
value *matchparser.MatchValue,
value *matchparser.matchparser,
) []common.LSPError {
errs := make([]common.LSPError, 0)

6
handlers/sshd_config/analyzer/match_test.go
View File

@ -15,7 +15,7 @@ func TestEmptyMatchBlocksMakesErrors(
PermitRootLogin yes
Match User root
`)
c := ast.NewSSHConfig()
c := ast.NewSSHDConfig()
errors := c.Parse(input)
if len(errors) > 0 {
@ -28,7 +28,7 @@ Match User root
t.Fatalf("Index error: %v", errors)
}
d := &sshdconfig.SSHDocument{
d := &sshdconfig.SSHDDocument{
Config: c,
Indexes: indexes,
}
@ -47,7 +47,7 @@ func TestContainsOnlyNegativeValues(
PermitRootLogin yes
Match User !root,!admin
`)
c := ast.NewSSHConfig()
c := ast.NewSSHDConfig()
errors := c.Parse(input)
if len(errors) > 0 {

2
handlers/sshd_config/analyzer/options.go
View File

@ -12,7 +12,7 @@ import (
)
func analyzeStructureIsValid(
d *sshdconfig.SSHDocument,
d *sshdconfig.SSHDDocument,
) []common.LSPError {
errs := make([]common.LSPError, 0)
it := d.Config.Options.Iterator()

2
handlers/sshd_config/analyzer/quotes.go
View File

@ -9,7 +9,7 @@ import (
)
func analyzeQuotesAreValid(
d *sshdconfig.SSHDocument,
d *sshdconfig.SSHDDocument,
) []common.LSPError {
errs := make([]common.LSPError, 0)

90
handlers/sshd_config/ast/listener.go
View File

@ -3,23 +3,23 @@ package ast
import (
"config-lsp/common"
commonparser "config-lsp/common/parser"
matchparser2 "config-lsp/common/parsers/openssh-match-parser"
"config-lsp/handlers/sshd_config/ast/parser"
"config-lsp/handlers/sshd_config/match-parser"
"strings"
"github.com/emirpasic/gods/maps/treemap"
gods "github.com/emirpasic/gods/utils"
)
type sshListenerContext struct {
type sshdListenerContext struct {
line uint32
currentOption *SSHDOption
currentMatchBlock *SSHDMatchBlock
isKeyAMatchBlock bool
}
func createSSHListenerContext() *sshListenerContext {
context := new(sshListenerContext)
func createListenerContext() *sshdListenerContext {
context := new(sshdListenerContext)
context.isKeyAMatchBlock = false
return context
@ -27,37 +27,37 @@ func createSSHListenerContext() *sshListenerContext {
func createListener(
config *SSHDConfig,
context *sshListenerContext,
) sshParserListener {
return sshParserListener{
Config: config,
Errors: make([]common.LSPError, 0),
sshContext: context,
context *sshdListenerContext,
) sshdParserListener {
return sshdParserListener{
Config: config,
Errors: make([]common.LSPError, 0),
sshdContext: context,
}
}
type sshParserListener struct {
type sshdParserListener struct {
*parser.BaseConfigListener
Config *SSHDConfig
Errors []common.LSPError
sshContext *sshListenerContext
Config *SSHDConfig
Errors []common.LSPError
sshdContext *sshdListenerContext
}
func (s *sshParserListener) EnterEntry(ctx *parser.EntryContext) {
func (s *sshdParserListener) EnterEntry(ctx *parser.EntryContext) {
location := common.CharacterRangeFromCtx(ctx.BaseParserRuleContext)
location.ChangeBothLines(s.sshContext.line)
location.ChangeBothLines(s.sshdContext.line)
option := &SSHDOption{
LocationRange: location,
Value: commonparser.ParseRawString(ctx.GetText(), commonparser.FullFeatures),
}
s.sshContext.currentOption = option
s.sshdContext.currentOption = option
}
func (s *sshParserListener) EnterKey(ctx *parser.KeyContext) {
func (s *sshdParserListener) EnterKey(ctx *parser.KeyContext) {
location := common.CharacterRangeFromCtx(ctx.BaseParserRuleContext)
location.ChangeBothLines(s.sshContext.line)
location.ChangeBothLines(s.sshdContext.line)
text := ctx.GetText()
value := commonparser.ParseRawString(text, commonparser.FullFeatures)
@ -70,63 +70,63 @@ func (s *sshParserListener) EnterKey(ctx *parser.KeyContext) {
)
if strings.ToLower(text) == "match" {
s.sshContext.isKeyAMatchBlock = true
s.sshdContext.isKeyAMatchBlock = true
}
s.sshContext.currentOption.Key = &SSHDKey{
s.sshdContext.currentOption.Key = &SSHDKey{
LocationRange: location,
Value: value,
Key: key,
}
}
func (s *sshParserListener) EnterSeparator(ctx *parser.SeparatorContext) {
func (s *sshdParserListener) EnterSeparator(ctx *parser.SeparatorContext) {
location := common.CharacterRangeFromCtx(ctx.BaseParserRuleContext)
location.ChangeBothLines(s.sshContext.line)
location.ChangeBothLines(s.sshdContext.line)
text := ctx.GetText()
value := commonparser.ParseRawString(text, commonparser.FullFeatures)
s.sshContext.currentOption.Separator = &SSHDSeparator{
s.sshdContext.currentOption.Separator = &SSHDSeparator{
LocationRange: location,
Value: value,
}
}
func (s *sshParserListener) EnterValue(ctx *parser.ValueContext) {
func (s *sshdParserListener) EnterValue(ctx *parser.ValueContext) {
location := common.CharacterRangeFromCtx(ctx.BaseParserRuleContext)
location.ChangeBothLines(s.sshContext.line)
location.ChangeBothLines(s.sshdContext.line)
s.sshContext.currentOption.OptionValue = &SSHDValue{
s.sshdContext.currentOption.OptionValue = &SSHDValue{
LocationRange: location,
Value: commonparser.ParseRawString(ctx.GetText(), commonparser.FullFeatures),
}
}
func (s *sshParserListener) ExitEntry(ctx *parser.EntryContext) {
func (s *sshdParserListener) ExitEntry(ctx *parser.EntryContext) {
location := common.CharacterRangeFromCtx(ctx.BaseParserRuleContext)
location.ChangeBothLines(s.sshContext.line)
location.ChangeBothLines(s.sshdContext.line)
defer (func() {
s.sshContext.currentOption = nil
s.sshdContext.currentOption = nil
})()
if s.sshContext.isKeyAMatchBlock {
if s.sshdContext.isKeyAMatchBlock {
// Add new match block
var match *matchparser2.Match
var match *matchparser.Match
if s.sshContext.currentOption.OptionValue != nil {
matchParser := matchparser2.NewMatch()
if s.sshdContext.currentOption.OptionValue != nil {
matchParser := matchparser.NewMatch()
errors := matchParser.Parse(
s.sshContext.currentOption.OptionValue.Value.Raw,
s.sshdContext.currentOption.OptionValue.Value.Raw,
location.Start.Line,
s.sshContext.currentOption.OptionValue.Start.Character,
s.sshdContext.currentOption.OptionValue.Start.Character,
)
if len(errors) > 0 {
for _, err := range errors {
s.Errors = append(s.Errors, common.LSPError{
Range: err.Range.ShiftHorizontal(s.sshContext.currentOption.Start.Character),
Range: err.Range.ShiftHorizontal(s.sshdContext.currentOption.Start.Character),
Err: err.Err,
})
}
@ -137,7 +137,7 @@ func (s *sshParserListener) ExitEntry(ctx *parser.EntryContext) {
matchBlock := &SSHDMatchBlock{
LocationRange: location,
MatchOption: s.sshContext.currentOption,
MatchOption: s.sshdContext.currentOption,
MatchValue: match,
Options: treemap.NewWith(gods.UInt32Comparator),
}
@ -146,23 +146,23 @@ func (s *sshParserListener) ExitEntry(ctx *parser.EntryContext) {
matchBlock,
)
s.sshContext.currentMatchBlock = matchBlock
s.sshdContext.currentMatchBlock = matchBlock
s.sshContext.isKeyAMatchBlock = false
s.sshdContext.isKeyAMatchBlock = false
return
}
if s.sshContext.currentMatchBlock != nil {
s.sshContext.currentMatchBlock.Options.Put(
if s.sshdContext.currentMatchBlock != nil {
s.sshdContext.currentMatchBlock.Options.Put(
location.Start.Line,
s.sshContext.currentOption,
s.sshdContext.currentOption,
)
s.sshContext.currentMatchBlock.End = s.sshContext.currentOption.End
s.sshdContext.currentMatchBlock.End = s.sshdContext.currentOption.End
} else {
s.Config.Options.Put(
location.Start.Line,
s.sshContext.currentOption,
s.sshdContext.currentOption,
)
}
}

6
handlers/sshd_config/ast/parser.go
View File

@ -12,7 +12,7 @@ import (
gods "github.com/emirpasic/gods/utils"
)
func NewSSHConfig() *SSHDConfig {
func NewSSHDConfig() *SSHDConfig {
config := &SSHDConfig{}
config.Clear()
@ -30,7 +30,7 @@ var emptyPattern = regexp.MustCompile(`^\s*$`)
func (c *SSHDConfig) Parse(input string) []common.LSPError {
errors := make([]common.LSPError, 0)
lines := utils.SplitIntoLines(input)
context := createSSHListenerContext()
context := createListenerContext()
for rawLineNumber, line := range lines {
context.line = uint32(rawLineNumber)
@ -54,7 +54,7 @@ func (c *SSHDConfig) Parse(input string) []common.LSPError {
}
func (c *SSHDConfig) parseStatement(
context *sshListenerContext,
context *sshdListenerContext,
input string,
) []common.LSPError {
stream := antlr.NewInputStream(input)

22
handlers/sshd_config/ast/parser_test.go
View File

@ -12,7 +12,7 @@ func TestSimpleParserExample(
PermitRootLogin no
PasswordAuthentication yes
`)
p := NewSSHConfig()
p := NewSSHDConfig()
errors := p.Parse(input)
if len(errors) != 0 {
@ -68,7 +68,7 @@ PermitRootLogin no
Match Address 192.168.0.1
PasswordAuthentication yes
`)
p := NewSSHConfig()
p := NewSSHDConfig()
errors := p.Parse(input)
if len(errors) != 0 {
@ -117,7 +117,7 @@ func TestMultipleEntriesInMatchBlock(
input := utils.Dedent(`
Match User lena User root
`)
p := NewSSHConfig()
p := NewSSHDConfig()
errors := p.Parse(input)
if len(errors) != 0 {
@ -148,7 +148,7 @@ func TestIncompleteMatchBlock(
) {
input := "Match User lena User "
p := NewSSHConfig()
p := NewSSHDConfig()
errors := p.Parse(input)
if !(len(errors) == 0) {
@ -183,7 +183,7 @@ Match User lena
Match Address 192.168.0.2
MaxAuthTries 3
`)
p := NewSSHConfig()
p := NewSSHDConfig()
errors := p.Parse(input)
if len(errors) != 0 {
@ -263,7 +263,7 @@ Port 22
AddressFamily any
Sample
`)
p := NewSSHConfig()
p := NewSSHDConfig()
errors := p.Parse(input)
if len(errors) != 0 {
@ -309,7 +309,7 @@ func TestIncompleteExample(
input := utils.Dedent(`
MACs
`)
p := NewSSHConfig()
p := NewSSHDConfig()
errors := p.Parse(input)
if len(errors) != 0 {
@ -470,7 +470,7 @@ Match Address 172.22.100.0/24,172.22.5.0/24,127.0.0.1
PermitRootLogin without-password
PasswordAuthentication yes
`)
p := NewSSHConfig()
p := NewSSHDConfig()
errors := p.Parse(input)
if len(errors) != 0 {
@ -551,7 +551,7 @@ func TestQuotedOptionExample(
input := utils.Dedent(`
PermitRootLogin "no"
`)
p := NewSSHConfig()
p := NewSSHDConfig()
errors := p.Parse(input)
if len(errors) != 0 {
@ -585,7 +585,7 @@ func TestQuotedKeyExample(
input := utils.Dedent(`
"PermitRootLogin" no
`)
p := NewSSHConfig()
p := NewSSHDConfig()
errors := p.Parse(input)
if len(errors) != 0 {
@ -623,7 +623,7 @@ func TestQuotedValueWithSpacesExample(
input := utils.Dedent(`
PermitRootLogin "no yes maybe"
`)
p := NewSSHConfig()
p := NewSSHDConfig()
errors := p.Parse(input)
if len(errors) != 0 {

4
handlers/sshd_config/ast/sshd_config.go
View File

@ -3,7 +3,7 @@ package ast
import (
"config-lsp/common"
commonparser "config-lsp/common/parser"
"config-lsp/common/parsers/openssh-match-parser"
"config-lsp/handlers/sshd_config/match-parser"
"github.com/emirpasic/gods/maps/treemap"
)
@ -47,7 +47,7 @@ type SSHDOption struct {
type SSHDMatchBlock struct {
common.LocationRange
MatchOption *SSHDOption
MatchValue *matchparser.Match
MatchValue *matchparser.matchparser
// [uint32]*SSHDOption -> line number -> *SSHDOption
Options *treemap.Map

4
handlers/sshd_config/handlers/completions.go
View File

@ -12,7 +12,7 @@ import (
)
func GetRootCompletions(
d *sshdconfig.SSHDocument,
d *sshdconfig.SSHDDocument,
parentMatchBlock *ast.SSHDMatchBlock,
suggestValue bool,
) ([]protocol.CompletionItem, error) {
@ -72,7 +72,7 @@ func GetRootCompletions(
}
func GetOptionCompletions(
d *sshdconfig.SSHDocument,
d *sshdconfig.SSHDDocument,
entry *ast.SSHDOption,
matchBlock *ast.SSHDMatchBlock,
cursor common.CursorPosition,

6
handlers/sshd_config/handlers/completions_match.go
View File

@ -2,16 +2,16 @@ package handlers
import (
"config-lsp/common"
"config-lsp/common/parsers/openssh-match-parser"
sshdconfig "config-lsp/handlers/sshd_config"
"config-lsp/handlers/sshd_config/fields"
"config-lsp/handlers/sshd_config/match-parser"
protocol "github.com/tliron/glsp/protocol_3_16"
)
func getMatchCompletions(
d *sshdconfig.SSHDocument,
d *sshdconfig.SSHDDocument,
cursor common.CursorPosition,
match *matchparser.Match,
match *matchparser.matchparser,
) ([]protocol.CompletionItem, error) {
if match == nil || len(match.Entries) == 0 {
completions := getMatchCriteriaCompletions()

2
handlers/sshd_config/handlers/formatting.go
View File

@ -8,7 +8,7 @@ import (
)
func FormatDocument(
d *sshdconfig.SSHDocument,
d *sshdconfig.SSHDDocument,
textRange protocol.Range,
options protocol.FormattingOptions,
) ([]protocol.TextEdit, error) {

4
handlers/sshd_config/handlers/formatting_nodes.go
View File

@ -2,8 +2,8 @@ package handlers
import (
"config-lsp/common/formatting"
"config-lsp/common/parsers/openssh-match-parser"
"config-lsp/handlers/sshd_config/ast"
"config-lsp/handlers/sshd_config/match-parser"
"config-lsp/utils"
"fmt"
"strings"
@ -80,7 +80,7 @@ func formatSSHDMatchBlock(
}
func formatMatchToString(
match *matchparser.Match,
match *matchparser.matchparser,
) string {
entriesAsStrings := utils.Map(
match.Entries,

4
handlers/sshd_config/handlers/formatting_test.go
View File

@ -17,7 +17,7 @@ func TestSimpleFormattingExampleWorks(
PermitRootLogin yes
a b
`)
config := ast.NewSSHConfig()
config := ast.NewSSHDConfig()
errors := config.Parse(input)
if len(errors) > 0 {
@ -30,7 +30,7 @@ a b
t.Fatalf("Failed to create indexes: %v", errors)
}
d := sshdconfig.SSHDocument{
d := sshdconfig.SSHDDocument{
Config: config,
Indexes: i,
}

4
handlers/sshd_config/indexes/indexes_test.go
View File

@ -20,7 +20,7 @@ Match Address 192.168.0.1/24
RoomLogin yes
PermitRootLogin yes
`)
config := ast.NewSSHConfig()
config := ast.NewSSHDConfig()
errors := config.Parse(input)
if len(errors) > 0 {
@ -54,7 +54,7 @@ func TestIncludeExample(
PermitRootLogin yes
Include /etc/ssh/sshd_config.d/*.conf hello_world
`)
config := ast.NewSSHConfig()
config := ast.NewSSHDConfig()
errors := config.Parse(input)
if len(errors) > 0 {

6
handlers/sshd_config/lsp/text-document-did-open.go
View File

@ -17,13 +17,13 @@ func TextDocumentDidOpen(
) error {
common.ClearDiagnostics(context, params.TextDocument.URI)
var document *sshdconfig.SSHDocument
var document *sshdconfig.SSHDDocument
if foundDocument, ok := sshdconfig.DocumentParserMap[params.TextDocument.URI]; ok {
document = foundDocument
} else {
config := ast.NewSSHConfig()
document = &sshdconfig.SSHDocument{
config := ast.NewSSHDConfig()
document = &sshdconfig.SSHDDocument{
Config: config,
}
sshdconfig.DocumentParserMap[params.TextDocument.URI] = document

0
common/parsers/openssh-match-parser/Match.g4 → handlers/sshd_config/match-parser/Match.g4
View File

0
common/parsers/openssh-match-parser/error-listener.go → handlers/sshd_config/match-parser/error-listener.go
View File

0
common/parsers/openssh-match-parser/full_test.go → handlers/sshd_config/match-parser/full_test.go
View File

0
common/parsers/openssh-match-parser/parser/Match.interp → handlers/sshd_config/match-parser/handlers/sshd_config/match-parser/Match.interp
View File

0
common/parsers/openssh-match-parser/parser/Match.tokens → handlers/sshd_config/match-parser/handlers/sshd_config/match-parser/Match.tokens
View File

0
common/parsers/openssh-match-parser/parser/MatchLexer.interp → handlers/sshd_config/match-parser/handlers/sshd_config/match-parser/MatchLexer.interp
View File

0
common/parsers/openssh-match-parser/parser/MatchLexer.tokens → handlers/sshd_config/match-parser/handlers/sshd_config/match-parser/MatchLexer.tokens
View File

58
handlers/sshd_config/match-parser/handlers/sshd_config/match-parser/match_base_listener.go Normal file
View File

@ -0,0 +1,58 @@
// Code generated from handlers/sshd_config/match-parser/Match.g4 by ANTLR 4.13.0. DO NOT EDIT.
package parser // Match
import "github.com/antlr4-go/antlr/v4"
// BaseMatchListener is a complete listener for a parse tree produced by MatchParser.
type BaseMatchListener struct{}
var _ MatchListener = &BaseMatchListener{}
// VisitTerminal is called when a terminal node is visited.
func (s *BaseMatchListener) VisitTerminal(node antlr.TerminalNode) {}
// VisitErrorNode is called when an error node is visited.
func (s *BaseMatchListener) VisitErrorNode(node antlr.ErrorNode) {}
// EnterEveryRule is called when any rule is entered.
func (s *BaseMatchListener) EnterEveryRule(ctx antlr.ParserRuleContext) {}
// ExitEveryRule is called when any rule is exited.
func (s *BaseMatchListener) ExitEveryRule(ctx antlr.ParserRuleContext) {}
// EnterRoot is called when production root is entered.
func (s *BaseMatchListener) EnterRoot(ctx *RootContext) {}
// ExitRoot is called when production root is exited.
func (s *BaseMatchListener) ExitRoot(ctx *RootContext) {}
// EnterMatchEntry is called when production matchEntry is entered.
func (s *BaseMatchListener) EnterMatchEntry(ctx *MatchEntryContext) {}
// ExitMatchEntry is called when production matchEntry is exited.
func (s *BaseMatchListener) ExitMatchEntry(ctx *MatchEntryContext) {}
// EnterSeparator is called when production separator is entered.
func (s *BaseMatchListener) EnterSeparator(ctx *SeparatorContext) {}
// ExitSeparator is called when production separator is exited.
func (s *BaseMatchListener) ExitSeparator(ctx *SeparatorContext) {}
// EnterCriteria is called when production criteria is entered.
func (s *BaseMatchListener) EnterCriteria(ctx *CriteriaContext) {}
// ExitCriteria is called when production criteria is exited.
func (s *BaseMatchListener) ExitCriteria(ctx *CriteriaContext) {}
// EnterValues is called when production values is entered.
func (s *BaseMatchListener) EnterValues(ctx *ValuesContext) {}
// ExitValues is called when production values is exited.
func (s *BaseMatchListener) ExitValues(ctx *ValuesContext) {}
// EnterValue is called when production value is entered.
func (s *BaseMatchListener) EnterValue(ctx *ValueContext) {}
// ExitValue is called when production value is exited.
func (s *BaseMatchListener) ExitValue(ctx *ValueContext) {}

109
handlers/sshd_config/match-parser/handlers/sshd_config/match-parser/match_lexer.go Normal file
View File

@ -0,0 +1,109 @@
// Code generated from handlers/sshd_config/match-parser/Match.g4 by ANTLR 4.13.0. DO NOT EDIT.
package parser
import (
"fmt"
"github.com/antlr4-go/antlr/v4"
"sync"
"unicode"
)
// Suppress unused import error
var _ = fmt.Printf
var _ = sync.Once{}
var _ = unicode.IsLetter
type MatchLexer struct {
*antlr.BaseLexer
channelNames []string
modeNames []string
// TODO: EOF string
}
var MatchLexerLexerStaticData struct {
once sync.Once
serializedATN []int32
ChannelNames []string
ModeNames []string
LiteralNames []string
SymbolicNames []string
RuleNames []string
PredictionContextCache *antlr.PredictionContextCache
atn *antlr.ATN
decisionToDFA []*antlr.DFA
}
func matchlexerLexerInit() {
staticData := &MatchLexerLexerStaticData
staticData.ChannelNames = []string{
"DEFAULT_TOKEN_CHANNEL", "HIDDEN",
}
staticData.ModeNames = []string{
"DEFAULT_MODE",
}
staticData.LiteralNames = []string{
"", "','",
}
staticData.SymbolicNames = []string{
"", "COMMA", "STRING", "WHITESPACE",
}
staticData.RuleNames = []string{
"COMMA", "STRING", "WHITESPACE",
}
staticData.PredictionContextCache = antlr.NewPredictionContextCache()
staticData.serializedATN = []int32{
4, 0, 3, 19, 6, -1, 2, 0, 7, 0, 2, 1, 7, 1, 2, 2, 7, 2, 1, 0, 1, 0, 1,
1, 4, 1, 11, 8, 1, 11, 1, 12, 1, 12, 1, 2, 4, 2, 16, 8, 2, 11, 2, 12, 2,
17, 0, 0, 3, 1, 1, 3, 2, 5, 3, 1, 0, 2, 5, 0, 9, 10, 13, 13, 32, 32, 35,
35, 44, 44, 2, 0, 9, 9, 32, 32, 20, 0, 1, 1, 0, 0, 0, 0, 3, 1, 0, 0, 0,
0, 5, 1, 0, 0, 0, 1, 7, 1, 0, 0, 0, 3, 10, 1, 0, 0, 0, 5, 15, 1, 0, 0,
0, 7, 8, 5, 44, 0, 0, 8, 2, 1, 0, 0, 0, 9, 11, 8, 0, 0, 0, 10, 9, 1, 0,
0, 0, 11, 12, 1, 0, 0, 0, 12, 10, 1, 0, 0, 0, 12, 13, 1, 0, 0, 0, 13, 4,
1, 0, 0, 0, 14, 16, 7, 1, 0, 0, 15, 14, 1, 0, 0, 0, 16, 17, 1, 0, 0, 0,
17, 15, 1, 0, 0, 0, 17, 18, 1, 0, 0, 0, 18, 6, 1, 0, 0, 0, 3, 0, 12, 17,
0,
}
deserializer := antlr.NewATNDeserializer(nil)
staticData.atn = deserializer.Deserialize(staticData.serializedATN)
atn := staticData.atn
staticData.decisionToDFA = make([]*antlr.DFA, len(atn.DecisionToState))
decisionToDFA := staticData.decisionToDFA
for index, state := range atn.DecisionToState {
decisionToDFA[index] = antlr.NewDFA(state, index)
}
}
// MatchLexerInit initializes any static state used to implement MatchLexer. By default the
// static state used to implement the lexer is lazily initialized during the first call to
// NewMatchLexer(). You can call this function if you wish to initialize the static state ahead
// of time.
func MatchLexerInit() {
staticData := &MatchLexerLexerStaticData
staticData.once.Do(matchlexerLexerInit)
}
// NewMatchLexer produces a new lexer instance for the optional input antlr.CharStream.
func NewMatchLexer(input antlr.CharStream) *MatchLexer {
MatchLexerInit()
l := new(MatchLexer)
l.BaseLexer = antlr.NewBaseLexer(input)
staticData := &MatchLexerLexerStaticData
l.Interpreter = antlr.NewLexerATNSimulator(l, staticData.atn, staticData.decisionToDFA, staticData.PredictionContextCache)
l.channelNames = staticData.ChannelNames
l.modeNames = staticData.ModeNames
l.RuleNames = staticData.RuleNames
l.LiteralNames = staticData.LiteralNames
l.SymbolicNames = staticData.SymbolicNames
l.GrammarFileName = "Match.g4"
// TODO: l.EOF = antlr.TokenEOF
return l
}
// MatchLexer tokens.
const (
MatchLexerCOMMA = 1
MatchLexerSTRING = 2
MatchLexerWHITESPACE = 3
)

46
handlers/sshd_config/match-parser/handlers/sshd_config/match-parser/match_listener.go Normal file
View File

@ -0,0 +1,46 @@
// Code generated from handlers/sshd_config/match-parser/Match.g4 by ANTLR 4.13.0. DO NOT EDIT.
package parser // Match
import "github.com/antlr4-go/antlr/v4"
// MatchListener is a complete listener for a parse tree produced by MatchParser.
type MatchListener interface {
antlr.ParseTreeListener
// EnterRoot is called when entering the root production.
EnterRoot(c *RootContext)
// EnterMatchEntry is called when entering the matchEntry production.
EnterMatchEntry(c *MatchEntryContext)
// EnterSeparator is called when entering the separator production.
EnterSeparator(c *SeparatorContext)
// EnterCriteria is called when entering the criteria production.
EnterCriteria(c *CriteriaContext)
// EnterValues is called when entering the values production.
EnterValues(c *ValuesContext)
// EnterValue is called when entering the value production.
EnterValue(c *ValueContext)
// ExitRoot is called when exiting the root production.
ExitRoot(c *RootContext)
// ExitMatchEntry is called when exiting the matchEntry production.
ExitMatchEntry(c *MatchEntryContext)
// ExitSeparator is called when exiting the separator production.
ExitSeparator(c *SeparatorContext)
// ExitCriteria is called when exiting the criteria production.
ExitCriteria(c *CriteriaContext)
// ExitValues is called when exiting the values production.
ExitValues(c *ValuesContext)
// ExitValue is called when exiting the value production.
ExitValue(c *ValueContext)
}

961
handlers/sshd_config/match-parser/handlers/sshd_config/match-parser/match_parser.go Normal file
View File

@ -0,0 +1,961 @@
// Code generated from handlers/sshd_config/match-parser/Match.g4 by ANTLR 4.13.0. DO NOT EDIT.
package parser // Match
import (
"fmt"
"strconv"
"sync"
"github.com/antlr4-go/antlr/v4"
)
// Suppress unused import errors
var _ = fmt.Printf
var _ = strconv.Itoa
var _ = sync.Once{}
type MatchParser struct {
*antlr.BaseParser
}
var MatchParserStaticData struct {
once sync.Once
serializedATN []int32
LiteralNames []string
SymbolicNames []string
RuleNames []string
PredictionContextCache *antlr.PredictionContextCache
atn *antlr.ATN
decisionToDFA []*antlr.DFA
}
func matchParserInit() {
staticData := &MatchParserStaticData
staticData.LiteralNames = []string{
"", "','",
}
staticData.SymbolicNames = []string{
"", "COMMA", "STRING", "WHITESPACE",
}
staticData.RuleNames = []string{
"root", "matchEntry", "separator", "criteria", "values", "value",
}
staticData.PredictionContextCache = antlr.NewPredictionContextCache()
staticData.serializedATN = []int32{
4, 1, 3, 52, 2, 0, 7, 0, 2, 1, 7, 1, 2, 2, 7, 2, 2, 3, 7, 3, 2, 4, 7, 4,
2, 5, 7, 5, 1, 0, 3, 0, 14, 8, 0, 1, 0, 1, 0, 3, 0, 18, 8, 0, 5, 0, 20,
8, 0, 10, 0, 12, 0, 23, 9, 0, 1, 0, 1, 0, 1, 1, 1, 1, 3, 1, 29, 8, 1, 1,
1, 3, 1, 32, 8, 1, 1, 2, 1, 2, 1, 3, 1, 3, 1, 4, 3, 4, 39, 8, 4, 1, 4,
1, 4, 3, 4, 43, 8, 4, 5, 4, 45, 8, 4, 10, 4, 12, 4, 48, 9, 4, 1, 5, 1,
5, 1, 5, 0, 0, 6, 0, 2, 4, 6, 8, 10, 0, 0, 53, 0, 13, 1, 0, 0, 0, 2, 26,
1, 0, 0, 0, 4, 33, 1, 0, 0, 0, 6, 35, 1, 0, 0, 0, 8, 38, 1, 0, 0, 0, 10,
49, 1, 0, 0, 0, 12, 14, 3, 2, 1, 0, 13, 12, 1, 0, 0, 0, 13, 14, 1, 0, 0,
0, 14, 21, 1, 0, 0, 0, 15, 17, 5, 3, 0, 0, 16, 18, 3, 2, 1, 0, 17, 16,
1, 0, 0, 0, 17, 18, 1, 0, 0, 0, 18, 20, 1, 0, 0, 0, 19, 15, 1, 0, 0, 0,
20, 23, 1, 0, 0, 0, 21, 19, 1, 0, 0, 0, 21, 22, 1, 0, 0, 0, 22, 24, 1,
0, 0, 0, 23, 21, 1, 0, 0, 0, 24, 25, 5, 0, 0, 1, 25, 1, 1, 0, 0, 0, 26,
28, 3, 6, 3, 0, 27, 29, 3, 4, 2, 0, 28, 27, 1, 0, 0, 0, 28, 29, 1, 0, 0,
0, 29, 31, 1, 0, 0, 0, 30, 32, 3, 8, 4, 0, 31, 30, 1, 0, 0, 0, 31, 32,
1, 0, 0, 0, 32, 3, 1, 0, 0, 0, 33, 34, 5, 3, 0, 0, 34, 5, 1, 0, 0, 0, 35,
36, 5, 2, 0, 0, 36, 7, 1, 0, 0, 0, 37, 39, 3, 10, 5, 0, 38, 37, 1, 0, 0,
0, 38, 39, 1, 0, 0, 0, 39, 46, 1, 0, 0, 0, 40, 42, 5, 1, 0, 0, 41, 43,
3, 10, 5, 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, 9, 1, 0, 0, 0, 48, 46, 1, 0, 0, 0, 49, 50, 5, 2, 0, 0, 50,
11, 1, 0, 0, 0, 8, 13, 17, 21, 28, 31, 38, 42, 46,
}
deserializer := antlr.NewATNDeserializer(nil)
staticData.atn = deserializer.Deserialize(staticData.serializedATN)
atn := staticData.atn
staticData.decisionToDFA = make([]*antlr.DFA, len(atn.DecisionToState))
decisionToDFA := staticData.decisionToDFA
for index, state := range atn.DecisionToState {
decisionToDFA[index] = antlr.NewDFA(state, index)
}
}
// MatchParserInit initializes any static state used to implement MatchParser. By default the
// static state used to implement the parser is lazily initialized during the first call to
// NewMatchParser(). You can call this function if you wish to initialize the static state ahead
// of time.
func MatchParserInit() {
staticData := &MatchParserStaticData
staticData.once.Do(matchParserInit)
}
// NewMatchParser produces a new parser instance for the optional input antlr.TokenStream.
func NewMatchParser(input antlr.TokenStream) *MatchParser {
MatchParserInit()
this := new(MatchParser)
this.BaseParser = antlr.NewBaseParser(input)
staticData := &MatchParserStaticData
this.Interpreter = antlr.NewParserATNSimulator(this, staticData.atn, staticData.decisionToDFA, staticData.PredictionContextCache)
this.RuleNames = staticData.RuleNames
this.LiteralNames = staticData.LiteralNames
this.SymbolicNames = staticData.SymbolicNames
this.GrammarFileName = "Match.g4"
return this
}
// MatchParser tokens.
const (
MatchParserEOF = antlr.TokenEOF
MatchParserCOMMA = 1
MatchParserSTRING = 2
MatchParserWHITESPACE = 3
)
// MatchParser rules.
const (
MatchParserRULE_root = 0
MatchParserRULE_matchEntry = 1
MatchParserRULE_separator = 2
MatchParserRULE_criteria = 3
MatchParserRULE_values = 4
MatchParserRULE_value = 5
)
// IRootContext is an interface to support dynamic dispatch.
type IRootContext interface {
antlr.ParserRuleContext
// GetParser returns the parser.
GetParser() antlr.Parser
// Getter signatures
EOF() antlr.TerminalNode
AllMatchEntry() []IMatchEntryContext
MatchEntry(i int) IMatchEntryContext
AllWHITESPACE() []antlr.TerminalNode
WHITESPACE(i int) antlr.TerminalNode
// IsRootContext differentiates from other interfaces.
IsRootContext()
}
type RootContext struct {
antlr.BaseParserRuleContext
parser antlr.Parser
}
func NewEmptyRootContext() *RootContext {
var p = new(RootContext)
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
p.RuleIndex = MatchParserRULE_root
return p
}
func InitEmptyRootContext(p *RootContext) {
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
p.RuleIndex = MatchParserRULE_root
}
func (*RootContext) IsRootContext() {}
func NewRootContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RootContext {
var p = new(RootContext)
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
p.parser = parser
p.RuleIndex = MatchParserRULE_root
return p
}
func (s *RootContext) GetParser() antlr.Parser { return s.parser }
func (s *RootContext) EOF() antlr.TerminalNode {
return s.GetToken(MatchParserEOF, 0)
}
func (s *RootContext) AllMatchEntry() []IMatchEntryContext {
children := s.GetChildren()
len := 0
for _, ctx := range children {
if _, ok := ctx.(IMatchEntryContext); ok {
len++
}
}
tst := make([]IMatchEntryContext, len)
i := 0
for _, ctx := range children {
if t, ok := ctx.(IMatchEntryContext); ok {
tst[i] = t.(IMatchEntryContext)
i++
}
}
return tst
}
func (s *RootContext) MatchEntry(i int) IMatchEntryContext {
var t antlr.RuleContext
j := 0
for _, ctx := range s.GetChildren() {
if _, ok := ctx.(IMatchEntryContext); ok {
if j == i {
t = ctx.(antlr.RuleContext)
break
}
j++
}
}
if t == nil {
return nil
}
return t.(IMatchEntryContext)
}
func (s *RootContext) AllWHITESPACE() []antlr.TerminalNode {
return s.GetTokens(MatchParserWHITESPACE)
}
func (s *RootContext) WHITESPACE(i int) antlr.TerminalNode {
return s.GetToken(MatchParserWHITESPACE, i)
}
func (s *RootContext) GetRuleContext() antlr.RuleContext {
return s
}
func (s *RootContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
return antlr.TreesStringTree(s, ruleNames, recog)
}
func (s *RootContext) EnterRule(listener antlr.ParseTreeListener) {
if listenerT, ok := listener.(MatchListener); ok {
listenerT.EnterRoot(s)
}
}
func (s *RootContext) ExitRule(listener antlr.ParseTreeListener) {
if listenerT, ok := listener.(MatchListener); ok {
listenerT.ExitRoot(s)
}
}
func (p *MatchParser) Root() (localctx IRootContext) {
localctx = NewRootContext(p, p.GetParserRuleContext(), p.GetState())
p.EnterRule(localctx, 0, MatchParserRULE_root)
var _la int
p.EnterOuterAlt(localctx, 1)
p.SetState(13)
p.GetErrorHandler().Sync(p)
if p.HasError() {
goto errorExit
}
_la = p.GetTokenStream().LA(1)
if _la == MatchParserSTRING {
{
p.SetState(12)
p.MatchEntry()
}
}
p.SetState(21)
p.GetErrorHandler().Sync(p)
if p.HasError() {
goto errorExit
}
_la = p.GetTokenStream().LA(1)
for _la == MatchParserWHITESPACE {
{
p.SetState(15)
p.Match(MatchParserWHITESPACE)
if p.HasError() {
// Recognition error - abort rule
goto errorExit
}
}
p.SetState(17)
p.GetErrorHandler().Sync(p)
if p.HasError() {
goto errorExit
}
_la = p.GetTokenStream().LA(1)
if _la == MatchParserSTRING {
{
p.SetState(16)
p.MatchEntry()
}
}
p.SetState(23)
p.GetErrorHandler().Sync(p)
if p.HasError() {
goto errorExit
}
_la = p.GetTokenStream().LA(1)
}
{
p.SetState(24)
p.Match(MatchParserEOF)
if p.HasError() {
// Recognition error - abort rule
goto errorExit
}
}
errorExit:
if p.HasError() {
v := p.GetError()
localctx.SetException(v)
p.GetErrorHandler().ReportError(p, v)
p.GetErrorHandler().Recover(p, v)
p.SetError(nil)
}
p.ExitRule()
return localctx
goto errorExit // Trick to prevent compiler error if the label is not used
}
// IMatchEntryContext is an interface to support dynamic dispatch.
type IMatchEntryContext interface {
antlr.ParserRuleContext
// GetParser returns the parser.
GetParser() antlr.Parser
// Getter signatures
Criteria() ICriteriaContext
Separator() ISeparatorContext
Values() IValuesContext
// IsMatchEntryContext differentiates from other interfaces.
IsMatchEntryContext()
}
type MatchEntryContext struct {
antlr.BaseParserRuleContext
parser antlr.Parser
}
func NewEmptyMatchEntryContext() *MatchEntryContext {
var p = new(MatchEntryContext)
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
p.RuleIndex = MatchParserRULE_matchEntry
return p
}
func InitEmptyMatchEntryContext(p *MatchEntryContext) {
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
p.RuleIndex = MatchParserRULE_matchEntry
}
func (*MatchEntryContext) IsMatchEntryContext() {}
func NewMatchEntryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MatchEntryContext {
var p = new(MatchEntryContext)
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
p.parser = parser
p.RuleIndex = MatchParserRULE_matchEntry
return p
}
func (s *MatchEntryContext) GetParser() antlr.Parser { return s.parser }
func (s *MatchEntryContext) Criteria() ICriteriaContext {
var t antlr.RuleContext
for _, ctx := range s.GetChildren() {
if _, ok := ctx.(ICriteriaContext); ok {
t = ctx.(antlr.RuleContext)
break
}
}
if t == nil {
return nil
}
return t.(ICriteriaContext)
}
func (s *MatchEntryContext) Separator() ISeparatorContext {
var t antlr.RuleContext
for _, ctx := range s.GetChildren() {
if _, ok := ctx.(ISeparatorContext); ok {
t = ctx.(antlr.RuleContext)
break
}
}
if t == nil {
return nil
}
return t.(ISeparatorContext)
}
func (s *MatchEntryContext) Values() IValuesContext {
var t antlr.RuleContext
for _, ctx := range s.GetChildren() {
if _, ok := ctx.(IValuesContext); ok {
t = ctx.(antlr.RuleContext)
break
}
}
if t == nil {
return nil
}
return t.(IValuesContext)
}
func (s *MatchEntryContext) GetRuleContext() antlr.RuleContext {
return s
}
func (s *MatchEntryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
return antlr.TreesStringTree(s, ruleNames, recog)
}
func (s *MatchEntryContext) EnterRule(listener antlr.ParseTreeListener) {
if listenerT, ok := listener.(MatchListener); ok {
listenerT.EnterMatchEntry(s)
}
}
func (s *MatchEntryContext) ExitRule(listener antlr.ParseTreeListener) {
if listenerT, ok := listener.(MatchListener); ok {
listenerT.ExitMatchEntry(s)
}
}
func (p *MatchParser) MatchEntry() (localctx IMatchEntryContext) {
localctx = NewMatchEntryContext(p, p.GetParserRuleContext(), p.GetState())
p.EnterRule(localctx, 2, MatchParserRULE_matchEntry)
p.EnterOuterAlt(localctx, 1)
{
p.SetState(26)
p.Criteria()
}
p.SetState(28)
p.GetErrorHandler().Sync(p)
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 3, p.GetParserRuleContext()) == 1 {
{
p.SetState(27)
p.Separator()
}
} else if p.HasError() { // JIM
goto errorExit
}
p.SetState(31)
p.GetErrorHandler().Sync(p)
if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 4, p.GetParserRuleContext()) == 1 {
{
p.SetState(30)
p.Values()
}
} else if p.HasError() { // JIM
goto errorExit
}
errorExit:
if p.HasError() {
v := p.GetError()
localctx.SetException(v)
p.GetErrorHandler().ReportError(p, v)
p.GetErrorHandler().Recover(p, v)
p.SetError(nil)
}
p.ExitRule()
return localctx
goto errorExit // Trick to prevent compiler error if the label is not used
}
// ISeparatorContext is an interface to support dynamic dispatch.
type ISeparatorContext interface {
antlr.ParserRuleContext
// GetParser returns the parser.
GetParser() antlr.Parser
// Getter signatures
WHITESPACE() antlr.TerminalNode
// IsSeparatorContext differentiates from other interfaces.
IsSeparatorContext()
}
type SeparatorContext struct {
antlr.BaseParserRuleContext
parser antlr.Parser
}
func NewEmptySeparatorContext() *SeparatorContext {
var p = new(SeparatorContext)
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
p.RuleIndex = MatchParserRULE_separator
return p
}
func InitEmptySeparatorContext(p *SeparatorContext) {
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
p.RuleIndex = MatchParserRULE_separator
}
func (*SeparatorContext) IsSeparatorContext() {}
func NewSeparatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SeparatorContext {
var p = new(SeparatorContext)
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
p.parser = parser
p.RuleIndex = MatchParserRULE_separator
return p
}
func (s *SeparatorContext) GetParser() antlr.Parser { return s.parser }
func (s *SeparatorContext) WHITESPACE() antlr.TerminalNode {
return s.GetToken(MatchParserWHITESPACE, 0)
}
func (s *SeparatorContext) GetRuleContext() antlr.RuleContext {
return s
}
func (s *SeparatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
return antlr.TreesStringTree(s, ruleNames, recog)
}
func (s *SeparatorContext) EnterRule(listener antlr.ParseTreeListener) {
if listenerT, ok := listener.(MatchListener); ok {
listenerT.EnterSeparator(s)
}
}
func (s *SeparatorContext) ExitRule(listener antlr.ParseTreeListener) {
if listenerT, ok := listener.(MatchListener); ok {
listenerT.ExitSeparator(s)
}
}
func (p *MatchParser) Separator() (localctx ISeparatorContext) {
localctx = NewSeparatorContext(p, p.GetParserRuleContext(), p.GetState())
p.EnterRule(localctx, 4, MatchParserRULE_separator)
p.EnterOuterAlt(localctx, 1)
{
p.SetState(33)
p.Match(MatchParserWHITESPACE)
if p.HasError() {
// Recognition error - abort rule
goto errorExit
}
}
errorExit:
if p.HasError() {
v := p.GetError()
localctx.SetException(v)
p.GetErrorHandler().ReportError(p, v)
p.GetErrorHandler().Recover(p, v)
p.SetError(nil)
}
p.ExitRule()
return localctx
goto errorExit // Trick to prevent compiler error if the label is not used
}
// ICriteriaContext is an interface to support dynamic dispatch.
type ICriteriaContext interface {
antlr.ParserRuleContext
// GetParser returns the parser.
GetParser() antlr.Parser
// Getter signatures
STRING() antlr.TerminalNode
// IsCriteriaContext differentiates from other interfaces.
IsCriteriaContext()
}
type CriteriaContext struct {
antlr.BaseParserRuleContext
parser antlr.Parser
}
func NewEmptyCriteriaContext() *CriteriaContext {
var p = new(CriteriaContext)
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
p.RuleIndex = MatchParserRULE_criteria
return p
}
func InitEmptyCriteriaContext(p *CriteriaContext) {
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
p.RuleIndex = MatchParserRULE_criteria
}
func (*CriteriaContext) IsCriteriaContext() {}
func NewCriteriaContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CriteriaContext {
var p = new(CriteriaContext)
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
p.parser = parser
p.RuleIndex = MatchParserRULE_criteria
return p
}
func (s *CriteriaContext) GetParser() antlr.Parser { return s.parser }
func (s *CriteriaContext) STRING() antlr.TerminalNode {
return s.GetToken(MatchParserSTRING, 0)
}
func (s *CriteriaContext) GetRuleContext() antlr.RuleContext {
return s
}
func (s *CriteriaContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
return antlr.TreesStringTree(s, ruleNames, recog)
}
func (s *CriteriaContext) EnterRule(listener antlr.ParseTreeListener) {
if listenerT, ok := listener.(MatchListener); ok {
listenerT.EnterCriteria(s)
}
}
func (s *CriteriaContext) ExitRule(listener antlr.ParseTreeListener) {
if listenerT, ok := listener.(MatchListener); ok {
listenerT.ExitCriteria(s)
}
}
func (p *MatchParser) Criteria() (localctx ICriteriaContext) {
localctx = NewCriteriaContext(p, p.GetParserRuleContext(), p.GetState())
p.EnterRule(localctx, 6, MatchParserRULE_criteria)
p.EnterOuterAlt(localctx, 1)
{
p.SetState(35)
p.Match(MatchParserSTRING)
if p.HasError() {
// Recognition error - abort rule
goto errorExit
}
}
errorExit:
if p.HasError() {
v := p.GetError()
localctx.SetException(v)
p.GetErrorHandler().ReportError(p, v)
p.GetErrorHandler().Recover(p, v)
p.SetError(nil)
}
p.ExitRule()
return localctx
goto errorExit // Trick to prevent compiler error if the label is not used
}
// IValuesContext is an interface to support dynamic dispatch.
type IValuesContext interface {
antlr.ParserRuleContext
// GetParser returns the parser.
GetParser() antlr.Parser
// Getter signatures
AllValue() []IValueContext
Value(i int) IValueContext
AllCOMMA() []antlr.TerminalNode
COMMA(i int) antlr.TerminalNode
// IsValuesContext differentiates from other interfaces.
IsValuesContext()
}
type ValuesContext struct {
antlr.BaseParserRuleContext
parser antlr.Parser
}
func NewEmptyValuesContext() *ValuesContext {
var p = new(ValuesContext)
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
p.RuleIndex = MatchParserRULE_values
return p
}
func InitEmptyValuesContext(p *ValuesContext) {
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
p.RuleIndex = MatchParserRULE_values
}
func (*ValuesContext) IsValuesContext() {}
func NewValuesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ValuesContext {
var p = new(ValuesContext)
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
p.parser = parser
p.RuleIndex = MatchParserRULE_values
return p
}
func (s *ValuesContext) GetParser() antlr.Parser { return s.parser }
func (s *ValuesContext) AllValue() []IValueContext {
children := s.GetChildren()
len := 0
for _, ctx := range children {
if _, ok := ctx.(IValueContext); ok {
len++
}
}
tst := make([]IValueContext, len)
i := 0
for _, ctx := range children {
if t, ok := ctx.(IValueContext); ok {
tst[i] = t.(IValueContext)
i++
}
}
return tst
}
func (s *ValuesContext) Value(i int) IValueContext {
var t antlr.RuleContext
j := 0
for _, ctx := range s.GetChildren() {
if _, ok := ctx.(IValueContext); ok {
if j == i {
t = ctx.(antlr.RuleContext)
break
}
j++
}
}
if t == nil {
return nil
}
return t.(IValueContext)
}
func (s *ValuesContext) AllCOMMA() []antlr.TerminalNode {
return s.GetTokens(MatchParserCOMMA)
}
func (s *ValuesContext) COMMA(i int) antlr.TerminalNode {
return s.GetToken(MatchParserCOMMA, i)
}
func (s *ValuesContext) GetRuleContext() antlr.RuleContext {
return s
}
func (s *ValuesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
return antlr.TreesStringTree(s, ruleNames, recog)
}
func (s *ValuesContext) EnterRule(listener antlr.ParseTreeListener) {
if listenerT, ok := listener.(MatchListener); ok {
listenerT.EnterValues(s)
}
}
func (s *ValuesContext) ExitRule(listener antlr.ParseTreeListener) {
if listenerT, ok := listener.(MatchListener); ok {
listenerT.ExitValues(s)
}
}
func (p *MatchParser) Values() (localctx IValuesContext) {
localctx = NewValuesContext(p, p.GetParserRuleContext(), p.GetState())
p.EnterRule(localctx, 8, MatchParserRULE_values)
var _la int
p.EnterOuterAlt(localctx, 1)
p.SetState(38)
p.GetErrorHandler().Sync(p)
if p.HasError() {
goto errorExit
}
_la = p.GetTokenStream().LA(1)
if _la == MatchParserSTRING {
{
p.SetState(37)
p.Value()
}
}
p.SetState(46)
p.GetErrorHandler().Sync(p)
if p.HasError() {
goto errorExit
}
_la = p.GetTokenStream().LA(1)
for _la == MatchParserCOMMA {
{
p.SetState(40)
p.Match(MatchParserCOMMA)
if p.HasError() {
// Recognition error - abort rule
goto errorExit
}
}
p.SetState(42)
p.GetErrorHandler().Sync(p)
if p.HasError() {
goto errorExit
}
_la = p.GetTokenStream().LA(1)
if _la == MatchParserSTRING {
{
p.SetState(41)
p.Value()
}
}
p.SetState(48)
p.GetErrorHandler().Sync(p)
if p.HasError() {
goto errorExit
}
_la = p.GetTokenStream().LA(1)
}
errorExit:
if p.HasError() {
v := p.GetError()
localctx.SetException(v)
p.GetErrorHandler().ReportError(p, v)
p.GetErrorHandler().Recover(p, v)
p.SetError(nil)
}
p.ExitRule()
return localctx
goto errorExit // Trick to prevent compiler error if the label is not used
}
// IValueContext is an interface to support dynamic dispatch.
type IValueContext interface {
antlr.ParserRuleContext
// GetParser returns the parser.
GetParser() antlr.Parser
// Getter signatures
STRING() antlr.TerminalNode
// IsValueContext differentiates from other interfaces.
IsValueContext()
}
type ValueContext struct {
antlr.BaseParserRuleContext
parser antlr.Parser
}
func NewEmptyValueContext() *ValueContext {
var p = new(ValueContext)
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
p.RuleIndex = MatchParserRULE_value
return p
}
func InitEmptyValueContext(p *ValueContext) {
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
p.RuleIndex = MatchParserRULE_value
}
func (*ValueContext) IsValueContext() {}
func NewValueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ValueContext {
var p = new(ValueContext)
antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)
p.parser = parser
p.RuleIndex = MatchParserRULE_value
return p
}
func (s *ValueContext) GetParser() antlr.Parser { return s.parser }
func (s *ValueContext) STRING() antlr.TerminalNode {
return s.GetToken(MatchParserSTRING, 0)
}
func (s *ValueContext) GetRuleContext() antlr.RuleContext {
return s
}
func (s *ValueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
return antlr.TreesStringTree(s, ruleNames, recog)
}
func (s *ValueContext) EnterRule(listener antlr.ParseTreeListener) {
if listenerT, ok := listener.(MatchListener); ok {
listenerT.EnterValue(s)
}
}
func (s *ValueContext) ExitRule(listener antlr.ParseTreeListener) {
if listenerT, ok := listener.(MatchListener); ok {
listenerT.ExitValue(s)
}
}
func (p *MatchParser) Value() (localctx IValueContext) {
localctx = NewValueContext(p, p.GetParserRuleContext(), p.GetState())
p.EnterRule(localctx, 10, MatchParserRULE_value)
p.EnterOuterAlt(localctx, 1)
{
p.SetState(49)
p.Match(MatchParserSTRING)
if p.HasError() {
// Recognition error - abort rule
goto errorExit
}
}
errorExit:
if p.HasError() {
v := p.GetError()
localctx.SetException(v)
p.GetErrorHandler().ReportError(p, v)
p.GetErrorHandler().Recover(p, v)
p.SetError(nil)
}
p.ExitRule()
return localctx
goto errorExit // Trick to prevent compiler error if the label is not used
}

16
common/parsers/openssh-match-parser/listener.go → handlers/sshd_config/match-parser/listener.go
View File

@ -3,7 +3,7 @@ package matchparser
import (
"config-lsp/common"
commonparser "config-lsp/common/parser"
parser2 "config-lsp/common/parsers/openssh-match-parser/parser"
"config-lsp/handlers/sshd_config/match-parser/parser"
"config-lsp/utils"
"errors"
"fmt"
@ -39,13 +39,13 @@ func createListener(
}
type matchParserListener struct {
*parser2.BaseMatchListener
*parser.BaseMatchListener
match *Match
Errors []common.LSPError
matchContext *matchListenerContext
}
func (s *matchParserListener) EnterMatchEntry(ctx *parser2.MatchEntryContext) {
func (s *matchParserListener) EnterMatchEntry(ctx *parser.MatchEntryContext) {
location := common.CharacterRangeFromCtx(ctx.BaseParserRuleContext).ShiftHorizontal(s.matchContext.startCharacter)
location.ChangeBothLines(s.matchContext.line)
@ -58,7 +58,7 @@ func (s *matchParserListener) EnterMatchEntry(ctx *parser2.MatchEntryContext) {
s.matchContext.currentEntry = entry
}
func (s *matchParserListener) ExitMatchEntry(ctx *parser2.MatchEntryContext) {
func (s *matchParserListener) ExitMatchEntry(ctx *parser.MatchEntryContext) {
s.matchContext.currentEntry = nil
}
@ -72,7 +72,7 @@ var availableCriteria = map[string]MatchCriteriaType{
string(MatchCriteriaTypeAddress): MatchCriteriaTypeAddress,
}
func (s *matchParserListener) EnterCriteria(ctx *parser2.CriteriaContext) {
func (s *matchParserListener) EnterCriteria(ctx *parser.CriteriaContext) {
location := common.CharacterRangeFromCtx(ctx.BaseParserRuleContext).ShiftHorizontal(s.matchContext.startCharacter)
location.ChangeBothLines(s.matchContext.line)
@ -95,7 +95,7 @@ func (s *matchParserListener) EnterCriteria(ctx *parser2.CriteriaContext) {
}
}
func (s *matchParserListener) EnterSeparator(ctx *parser2.SeparatorContext) {
func (s *matchParserListener) EnterSeparator(ctx *parser.SeparatorContext) {
location := common.CharacterRangeFromCtx(ctx.BaseParserRuleContext).ShiftHorizontal(s.matchContext.startCharacter)
location.ChangeBothLines(s.matchContext.line)
@ -104,7 +104,7 @@ func (s *matchParserListener) EnterSeparator(ctx *parser2.SeparatorContext) {
}
}
func (s *matchParserListener) EnterValues(ctx *parser2.ValuesContext) {
func (s *matchParserListener) EnterValues(ctx *parser.ValuesContext) {
location := common.CharacterRangeFromCtx(ctx.BaseParserRuleContext).ShiftHorizontal(s.matchContext.startCharacter)
location.ChangeBothLines(s.matchContext.line)
@ -114,7 +114,7 @@ func (s *matchParserListener) EnterValues(ctx *parser2.ValuesContext) {
}
}
func (s *matchParserListener) EnterValue(ctx *parser2.ValueContext) {
func (s *matchParserListener) EnterValue(ctx *parser.ValueContext) {
location := common.CharacterRangeFromCtx(ctx.BaseParserRuleContext).ShiftHorizontal(s.matchContext.startCharacter)
location.ChangeBothLines(s.matchContext.line)

0
common/parsers/openssh-match-parser/match_ast.go → handlers/sshd_config/match-parser/match_ast.go
View File

0
common/parsers/openssh-match-parser/match_fields.go → handlers/sshd_config/match-parser/match_fields.go
View File

6
common/parsers/openssh-match-parser/parser.go → handlers/sshd_config/match-parser/parser.go
View File

@ -2,7 +2,7 @@ package matchparser
import (
"config-lsp/common"
parser2 "config-lsp/common/parsers/openssh-match-parser/parser"
"config-lsp/handlers/sshd_config/match-parser/parser"
"github.com/antlr4-go/antlr/v4"
)
@ -27,14 +27,14 @@ func (m *Match) Parse(
stream := antlr.NewInputStream(input)
lexerErrorListener := createErrorListener(context.line)
lexer := parser2.NewMatchLexer(stream)
lexer := parser.NewMatchLexer(stream)
lexer.RemoveErrorListeners()
lexer.AddErrorListener(&lexerErrorListener)
tokenStream := antlr.NewCommonTokenStream(lexer, antlr.TokenDefaultChannel)
parserErrorListener := createErrorListener(context.line)
antlrParser := parser2.NewMatchParser(tokenStream)
antlrParser := parser.NewMatchParser(tokenStream)
antlrParser.RemoveErrorListeners()
antlrParser.AddErrorListener(&parserErrorListener)

23
handlers/sshd_config/match-parser/parser/Match.interp Normal file
View File

@ -0,0 +1,23 @@
token literal names:
null
','
null
null
token symbolic names:
null
COMMA
STRING
WHITESPACE
rule names:
root
matchEntry
separator
criteria
values
value
atn:
[4, 1, 3, 52, 2, 0, 7, 0, 2, 1, 7, 1, 2, 2, 7, 2, 2, 3, 7, 3, 2, 4, 7, 4, 2, 5, 7, 5, 1, 0, 3, 0, 14, 8, 0, 1, 0, 1, 0, 3, 0, 18, 8, 0, 5, 0, 20, 8, 0, 10, 0, 12, 0, 23, 9, 0, 1, 0, 1, 0, 1, 1, 1, 1, 3, 1, 29, 8, 1, 1, 1, 3, 1, 32, 8, 1, 1, 2, 1, 2, 1, 3, 1, 3, 1, 4, 3, 4, 39, 8, 4, 1, 4, 1, 4, 3, 4, 43, 8, 4, 5, 4, 45, 8, 4, 10, 4, 12, 4, 48, 9, 4, 1, 5, 1, 5, 1, 5, 0, 0, 6, 0, 2, 4, 6, 8, 10, 0, 0, 53, 0, 13, 1, 0, 0, 0, 2, 26, 1, 0, 0, 0, 4, 33, 1, 0, 0, 0, 6, 35, 1, 0, 0, 0, 8, 38, 1, 0, 0, 0, 10, 49, 1, 0, 0, 0, 12, 14, 3, 2, 1, 0, 13, 12, 1, 0, 0, 0, 13, 14, 1, 0, 0, 0, 14, 21, 1, 0, 0, 0, 15, 17, 5, 3, 0, 0, 16, 18, 3, 2, 1, 0, 17, 16, 1, 0, 0, 0, 17, 18, 1, 0, 0, 0, 18, 20, 1, 0, 0, 0, 19, 15, 1, 0, 0, 0, 20, 23, 1, 0, 0, 0, 21, 19, 1, 0, 0, 0, 21, 22, 1, 0, 0, 0, 22, 24, 1, 0, 0, 0, 23, 21, 1, 0, 0, 0, 24, 25, 5, 0, 0, 1, 25, 1, 1, 0, 0, 0, 26, 28, 3, 6, 3, 0, 27, 29, 3, 4, 2, 0, 28, 27, 1, 0, 0, 0, 28, 29, 1, 0, 0, 0, 29, 31, 1, 0, 0, 0, 30, 32, 3, 8, 4, 0, 31, 30, 1, 0, 0, 0, 31, 32, 1, 0, 0, 0, 32, 3, 1, 0, 0, 0, 33, 34, 5, 3, 0, 0, 34, 5, 1, 0, 0, 0, 35, 36, 5, 2, 0, 0, 36, 7, 1, 0, 0, 0, 37, 39, 3, 10, 5, 0, 38, 37, 1, 0, 0, 0, 38, 39, 1, 0, 0, 0, 39, 46, 1, 0, 0, 0, 40, 42, 5, 1, 0, 0, 41, 43, 3, 10, 5, 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, 9, 1, 0, 0, 0, 48, 46, 1, 0, 0, 0, 49, 50, 5, 2, 0, 0, 50, 11, 1, 0, 0, 0, 8, 13, 17, 21, 28, 31, 38, 42, 46]

4
handlers/sshd_config/match-parser/parser/Match.tokens Normal file
View File

@ -0,0 +1,4 @@
COMMA=1
STRING=2
WHITESPACE=3
','=1

26
handlers/sshd_config/match-parser/parser/MatchLexer.interp Normal file
View File

@ -0,0 +1,26 @@
token literal names:
null
','
null
null
token symbolic names:
null
COMMA
STRING
WHITESPACE
rule names:
COMMA
STRING
WHITESPACE
channel names:
DEFAULT_TOKEN_CHANNEL
HIDDEN
mode names:
DEFAULT_MODE
atn:
[4, 0, 3, 19, 6, -1, 2, 0, 7, 0, 2, 1, 7, 1, 2, 2, 7, 2, 1, 0, 1, 0, 1, 1, 4, 1, 11, 8, 1, 11, 1, 12, 1, 12, 1, 2, 4, 2, 16, 8, 2, 11, 2, 12, 2, 17, 0, 0, 3, 1, 1, 3, 2, 5, 3, 1, 0, 2, 5, 0, 9, 10, 13, 13, 32, 32, 35, 35, 44, 44, 2, 0, 9, 9, 32, 32, 20, 0, 1, 1, 0, 0, 0, 0, 3, 1, 0, 0, 0, 0, 5, 1, 0, 0, 0, 1, 7, 1, 0, 0, 0, 3, 10, 1, 0, 0, 0, 5, 15, 1, 0, 0, 0, 7, 8, 5, 44, 0, 0, 8, 2, 1, 0, 0, 0, 9, 11, 8, 0, 0, 0, 10, 9, 1, 0, 0, 0, 11, 12, 1, 0, 0, 0, 12, 10, 1, 0, 0, 0, 12, 13, 1, 0, 0, 0, 13, 4, 1, 0, 0, 0, 14, 16, 7, 1, 0, 0, 15, 14, 1, 0, 0, 0, 16, 17, 1, 0, 0, 0, 17, 15, 1, 0, 0, 0, 17, 18, 1, 0, 0, 0, 18, 6, 1, 0, 0, 0, 3, 0, 12, 17, 0]

4
handlers/sshd_config/match-parser/parser/MatchLexer.tokens Normal file
View File

@ -0,0 +1,4 @@
COMMA=1
STRING=2
WHITESPACE=3
','=1

0
common/parsers/openssh-match-parser/parser/match_base_listener.go → handlers/sshd_config/match-parser/parser/match_base_listener.go
View File

0
common/parsers/openssh-match-parser/parser/match_lexer.go → handlers/sshd_config/match-parser/parser/match_lexer.go
View File

0
common/parsers/openssh-match-parser/parser/match_listener.go → handlers/sshd_config/match-parser/parser/match_listener.go
View File

0
common/parsers/openssh-match-parser/parser/match_parser.go → handlers/sshd_config/match-parser/parser/match_parser.go
View File

0
common/parsers/openssh-match-parser/parser_test.go → handlers/sshd_config/match-parser/parser_test.go
View File

28
handlers/sshd_config/parser/handlers/sshd_config/Config.interp Normal file
View File

@ -0,0 +1,28 @@
token literal names:
null
'#'
null
null
null
null
token symbolic names:
null
HASH
WHITESPACE
STRING
NEWLINE
QUOTED_STRING
rule names:
lineStatement
entry
separator
key
value
leadingComment
string
atn:
[4, 1, 5, 71, 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, 1, 0, 1, 0, 1, 0, 3, 0, 18, 8, 0, 3, 0, 20, 8, 0, 1, 0, 1, 0, 1, 1, 3, 1, 25, 8, 1, 1, 1, 3, 1, 28, 8, 1, 1, 1, 3, 1, 31, 8, 1, 1, 1, 3, 1, 34, 8, 1, 1, 1, 3, 1, 37, 8, 1, 1, 2, 1, 2, 1, 3, 1, 3, 1, 4, 1, 4, 1, 4, 5, 4, 46, 8, 4, 10, 4, 12, 4, 49, 9, 4, 1, 4, 3, 4, 52, 8, 4, 1, 4, 3, 4, 55, 8, 4, 1, 5, 1, 5, 3, 5, 59, 8, 5, 1, 5, 1, 5, 3, 5, 63, 8, 5, 4, 5, 65, 8, 5, 11, 5, 12, 5, 66, 1, 6, 1, 6, 1, 6, 0, 0, 7, 0, 2, 4, 6, 8, 10, 12, 0, 1, 2, 0, 3, 3, 5, 5, 77, 0, 19, 1, 0, 0, 0, 2, 24, 1, 0, 0, 0, 4, 38, 1, 0, 0, 0, 6, 40, 1, 0, 0, 0, 8, 47, 1, 0, 0, 0, 10, 56, 1, 0, 0, 0, 12, 68, 1, 0, 0, 0, 14, 20, 3, 2, 1, 0, 15, 20, 3, 10, 5, 0, 16, 18, 5, 2, 0, 0, 17, 16, 1, 0, 0, 0, 17, 18, 1, 0, 0, 0, 18, 20, 1, 0, 0, 0, 19, 14, 1, 0, 0, 0, 19, 15, 1, 0, 0, 0, 19, 17, 1, 0, 0, 0, 20, 21, 1, 0, 0, 0, 21, 22, 5, 0, 0, 1, 22, 1, 1, 0, 0, 0, 23, 25, 5, 2, 0, 0, 24, 23, 1, 0, 0, 0, 24, 25, 1, 0, 0, 0, 25, 27, 1, 0, 0, 0, 26, 28, 3, 6, 3, 0, 27, 26, 1, 0, 0, 0, 27, 28, 1, 0, 0, 0, 28, 30, 1, 0, 0, 0, 29, 31, 3, 4, 2, 0, 30, 29, 1, 0, 0, 0, 30, 31, 1, 0, 0, 0, 31, 33, 1, 0, 0, 0, 32, 34, 3, 8, 4, 0, 33, 32, 1, 0, 0, 0, 33, 34, 1, 0, 0, 0, 34, 36, 1, 0, 0, 0, 35, 37, 3, 10, 5, 0, 36, 35, 1, 0, 0, 0, 36, 37, 1, 0, 0, 0, 37, 3, 1, 0, 0, 0, 38, 39, 5, 2, 0, 0, 39, 5, 1, 0, 0, 0, 40, 41, 3, 12, 6, 0, 41, 7, 1, 0, 0, 0, 42, 43, 3, 12, 6, 0, 43, 44, 5, 2, 0, 0, 44, 46, 1, 0, 0, 0, 45, 42, 1, 0, 0, 0, 46, 49, 1, 0, 0, 0, 47, 45, 1, 0, 0, 0, 47, 48, 1, 0, 0, 0, 48, 51, 1, 0, 0, 0, 49, 47, 1, 0, 0, 0, 50, 52, 3, 12, 6, 0, 51, 50, 1, 0, 0, 0, 51, 52, 1, 0, 0, 0, 52, 54, 1, 0, 0, 0, 53, 55, 5, 2, 0, 0, 54, 53, 1, 0, 0, 0, 54, 55, 1, 0, 0, 0, 55, 9, 1, 0, 0, 0, 56, 58, 5, 1, 0, 0, 57, 59, 5, 2, 0, 0, 58, 57, 1, 0, 0, 0, 58, 59, 1, 0, 0, 0, 59, 64, 1, 0, 0, 0, 60, 62, 3, 12, 6, 0, 61, 63, 5, 2, 0, 0, 62, 61, 1, 0, 0, 0, 62, 63, 1, 0, 0, 0, 63, 65, 1, 0, 0, 0, 64, 60, 1, 0, 0, 0, 65, 66, 1, 0, 0, 0, 66, 64, 1, 0, 0, 0, 66, 67, 1, 0, 0, 0, 67, 11, 1, 0, 0, 0, 68, 69, 7, 0, 0, 0, 69, 13, 1, 0, 0, 0, 13, 17, 19, 24, 27, 30, 33, 36, 47, 51, 54, 58, 62, 66]

6
handlers/sshd_config/parser/handlers/sshd_config/Config.tokens Normal file
View File

@ -0,0 +1,6 @@
HASH=1
WHITESPACE=2
STRING=3
NEWLINE=4
QUOTED_STRING=5
'#'=1

32
handlers/sshd_config/parser/handlers/sshd_config/ConfigLexer.interp Normal file
View File

@ -0,0 +1,32 @@
token literal names:
null
'#'
null
null
null
null
token symbolic names:
null
HASH
WHITESPACE
STRING
NEWLINE
QUOTED_STRING
rule names:
HASH
WHITESPACE
STRING
NEWLINE
QUOTED_STRING
channel names:
DEFAULT_TOKEN_CHANNEL
HIDDEN
mode names:
DEFAULT_MODE
atn:
[4, 0, 5, 46, 6, -1, 2, 0, 7, 0, 2, 1, 7, 1, 2, 2, 7, 2, 2, 3, 7, 3, 2, 4, 7, 4, 1, 0, 1, 0, 1, 1, 4, 1, 15, 8, 1, 11, 1, 12, 1, 16, 1, 2, 4, 2, 20, 8, 2, 11, 2, 12, 2, 21, 1, 3, 3, 3, 25, 8, 3, 1, 3, 1, 3, 1, 4, 1, 4, 3, 4, 31, 8, 4, 1, 4, 1, 4, 1, 4, 5, 4, 36, 8, 4, 10, 4, 12, 4, 39, 9, 4, 1, 4, 3, 4, 42, 8, 4, 1, 4, 3, 4, 45, 8, 4, 0, 0, 5, 1, 1, 3, 2, 5, 3, 7, 4, 9, 5, 1, 0, 2, 2, 0, 9, 9, 32, 32, 4, 0, 9, 10, 13, 13, 32, 32, 34, 35, 52, 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, 1, 11, 1, 0, 0, 0, 3, 14, 1, 0, 0, 0, 5, 19, 1, 0, 0, 0, 7, 24, 1, 0, 0, 0, 9, 28, 1, 0, 0, 0, 11, 12, 5, 35, 0, 0, 12, 2, 1, 0, 0, 0, 13, 15, 7, 0, 0, 0, 14, 13, 1, 0, 0, 0, 15, 16, 1, 0, 0, 0, 16, 14, 1, 0, 0, 0, 16, 17, 1, 0, 0, 0, 17, 4, 1, 0, 0, 0, 18, 20, 8, 1, 0, 0, 19, 18, 1, 0, 0, 0, 20, 21, 1, 0, 0, 0, 21, 19, 1, 0, 0, 0, 21, 22, 1, 0, 0, 0, 22, 6, 1, 0, 0, 0, 23, 25, 5, 13, 0, 0, 24, 23, 1, 0, 0, 0, 24, 25, 1, 0, 0, 0, 25, 26, 1, 0, 0, 0, 26, 27, 5, 10, 0, 0, 27, 8, 1, 0, 0, 0, 28, 30, 5, 34, 0, 0, 29, 31, 3, 3, 1, 0, 30, 29, 1, 0, 0, 0, 30, 31, 1, 0, 0, 0, 31, 37, 1, 0, 0, 0, 32, 33, 3, 5, 2, 0, 33, 34, 3, 3, 1, 0, 34, 36, 1, 0, 0, 0, 35, 32, 1, 0, 0, 0, 36, 39, 1, 0, 0, 0, 37, 35, 1, 0, 0, 0, 37, 38, 1, 0, 0, 0, 38, 41, 1, 0, 0, 0, 39, 37, 1, 0, 0, 0, 40, 42, 3, 5, 2, 0, 41, 40, 1, 0, 0, 0, 41, 42, 1, 0, 0, 0, 42, 44, 1, 0, 0, 0, 43, 45, 5, 34, 0, 0, 44, 43, 1, 0, 0, 0, 44, 45, 1, 0, 0, 0, 45, 10, 1, 0, 0, 0, 8, 0, 16, 21, 24, 30, 37, 41, 44, 0]

6
handlers/sshd_config/parser/handlers/sshd_config/ConfigLexer.tokens Normal file
View File

@ -0,0 +1,6 @@
HASH=1
WHITESPACE=2
STRING=3
NEWLINE=4
QUOTED_STRING=5
'#'=1

64
handlers/sshd_config/parser/handlers/sshd_config/config_base_listener.go Normal file
View File

@ -0,0 +1,64 @@
// Code generated from handlers/sshd_config/Config.g4 by ANTLR 4.13.0. DO NOT EDIT.
package parser // Config
import "github.com/antlr4-go/antlr/v4"
// BaseConfigListener is a complete listener for a parse tree produced by ConfigParser.
type BaseConfigListener struct{}
var _ ConfigListener = &BaseConfigListener{}
// VisitTerminal is called when a terminal node is visited.
func (s *BaseConfigListener) VisitTerminal(node antlr.TerminalNode) {}
// VisitErrorNode is called when an error node is visited.
func (s *BaseConfigListener) VisitErrorNode(node antlr.ErrorNode) {}
// EnterEveryRule is called when any rule is entered.
func (s *BaseConfigListener) EnterEveryRule(ctx antlr.ParserRuleContext) {}
// ExitEveryRule is called when any rule is exited.
func (s *BaseConfigListener) ExitEveryRule(ctx antlr.ParserRuleContext) {}
// EnterLineStatement is called when production lineStatement is entered.
func (s *BaseConfigListener) EnterLineStatement(ctx *LineStatementContext) {}
// ExitLineStatement is called when production lineStatement is exited.
func (s *BaseConfigListener) ExitLineStatement(ctx *LineStatementContext) {}
// EnterEntry is called when production entry is entered.
func (s *BaseConfigListener) EnterEntry(ctx *EntryContext) {}
// ExitEntry is called when production entry is exited.
func (s *BaseConfigListener) ExitEntry(ctx *EntryContext) {}
// EnterSeparator is called when production separator is entered.
func (s *BaseConfigListener) EnterSeparator(ctx *SeparatorContext) {}
// ExitSeparator is called when production separator is exited.
func (s *BaseConfigListener) ExitSeparator(ctx *SeparatorContext) {}
// EnterKey is called when production key is entered.
func (s *BaseConfigListener) EnterKey(ctx *KeyContext) {}
// ExitKey is called when production key is exited.
func (s *BaseConfigListener) ExitKey(ctx *KeyContext) {}
// EnterValue is called when production value is entered.
func (s *BaseConfigListener) EnterValue(ctx *ValueContext) {}
// ExitValue is called when production value is exited.
func (s *BaseConfigListener) ExitValue(ctx *ValueContext) {}
// EnterLeadingComment is called when production leadingComment is entered.
func (s *BaseConfigListener) EnterLeadingComment(ctx *LeadingCommentContext) {}
// ExitLeadingComment is called when production leadingComment is exited.
func (s *BaseConfigListener) ExitLeadingComment(ctx *LeadingCommentContext) {}
// EnterString is called when production string is entered.
func (s *BaseConfigListener) EnterString(ctx *StringContext) {}
// ExitString is called when production string is exited.
func (s *BaseConfigListener) ExitString(ctx *StringContext) {}

122
handlers/sshd_config/parser/handlers/sshd_config/config_lexer.go Normal file
View File

@ -0,0 +1,122 @@
// Code generated from handlers/sshd_config/Config.g4 by ANTLR 4.13.0. DO NOT EDIT.
package parser
import (
"fmt"
"github.com/antlr4-go/antlr/v4"
"sync"
"unicode"
)
// Suppress unused import error
var _ = fmt.Printf
var _ = sync.Once{}
var _ = unicode.IsLetter
type ConfigLexer struct {
*antlr.BaseLexer
channelNames []string
modeNames []string
// TODO: EOF string
}
var ConfigLexerLexerStaticData struct {
once sync.Once
serializedATN []int32
ChannelNames []string
ModeNames []string
LiteralNames []string
SymbolicNames []string
RuleNames []string
PredictionContextCache *antlr.PredictionContextCache
atn *antlr.ATN
decisionToDFA []*antlr.DFA
}
func configlexerLexerInit() {
staticData := &ConfigLexerLexerStaticData
staticData.ChannelNames = []string{
"DEFAULT_TOKEN_CHANNEL", "HIDDEN",
}
staticData.ModeNames = []string{
"DEFAULT_MODE",
}
staticData.LiteralNames = []string{
"", "'#'",
}
staticData.SymbolicNames = []string{
"", "HASH", "WHITESPACE", "STRING", "NEWLINE", "QUOTED_STRING",
}
staticData.RuleNames = []string{
"HASH", "WHITESPACE", "STRING", "NEWLINE", "QUOTED_STRING",
}
staticData.PredictionContextCache = antlr.NewPredictionContextCache()
staticData.serializedATN = []int32{
4, 0, 5, 46, 6, -1, 2, 0, 7, 0, 2, 1, 7, 1, 2, 2, 7, 2, 2, 3, 7, 3, 2,
4, 7, 4, 1, 0, 1, 0, 1, 1, 4, 1, 15, 8, 1, 11, 1, 12, 1, 16, 1, 2, 4, 2,
20, 8, 2, 11, 2, 12, 2, 21, 1, 3, 3, 3, 25, 8, 3, 1, 3, 1, 3, 1, 4, 1,
4, 3, 4, 31, 8, 4, 1, 4, 1, 4, 1, 4, 5, 4, 36, 8, 4, 10, 4, 12, 4, 39,
9, 4, 1, 4, 3, 4, 42, 8, 4, 1, 4, 3, 4, 45, 8, 4, 0, 0, 5, 1, 1, 3, 2,
5, 3, 7, 4, 9, 5, 1, 0, 2, 2, 0, 9, 9, 32, 32, 4, 0, 9, 10, 13, 13, 32,
32, 34, 35, 52, 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, 1, 11, 1, 0, 0, 0, 3, 14, 1, 0, 0, 0,
5, 19, 1, 0, 0, 0, 7, 24, 1, 0, 0, 0, 9, 28, 1, 0, 0, 0, 11, 12, 5, 35,
0, 0, 12, 2, 1, 0, 0, 0, 13, 15, 7, 0, 0, 0, 14, 13, 1, 0, 0, 0, 15, 16,
1, 0, 0, 0, 16, 14, 1, 0, 0, 0, 16, 17, 1, 0, 0, 0, 17, 4, 1, 0, 0, 0,
18, 20, 8, 1, 0, 0, 19, 18, 1, 0, 0, 0, 20, 21, 1, 0, 0, 0, 21, 19, 1,
0, 0, 0, 21, 22, 1, 0, 0, 0, 22, 6, 1, 0, 0, 0, 23, 25, 5, 13, 0, 0, 24,
23, 1, 0, 0, 0, 24, 25, 1, 0, 0, 0, 25, 26, 1, 0, 0, 0, 26, 27, 5, 10,
0, 0, 27, 8, 1, 0, 0, 0, 28, 30, 5, 34, 0, 0, 29, 31, 3, 3, 1, 0, 30, 29,
1, 0, 0, 0, 30, 31, 1, 0, 0, 0, 31, 37, 1, 0, 0, 0, 32, 33, 3, 5, 2, 0,
33, 34, 3, 3, 1, 0, 34, 36, 1, 0, 0, 0, 35, 32, 1, 0, 0, 0, 36, 39, 1,
0, 0, 0, 37, 35, 1, 0, 0, 0, 37, 38, 1, 0, 0, 0, 38, 41, 1, 0, 0, 0, 39,
37, 1, 0, 0, 0, 40, 42, 3, 5, 2, 0, 41, 40, 1, 0, 0, 0, 41, 42, 1, 0, 0,
0, 42, 44, 1, 0, 0, 0, 43, 45, 5, 34, 0, 0, 44, 43, 1, 0, 0, 0, 44, 45,
1, 0, 0, 0, 45, 10, 1, 0, 0, 0, 8, 0, 16, 21, 24, 30, 37, 41, 44, 0,
}
deserializer := antlr.NewATNDeserializer(nil)
staticData.atn = deserializer.Deserialize(staticData.serializedATN)
atn := staticData.atn
staticData.decisionToDFA = make([]*antlr.DFA, len(atn.DecisionToState))
decisionToDFA := staticData.decisionToDFA
for index, state := range atn.DecisionToState {
decisionToDFA[index] = antlr.NewDFA(state, index)
}
}
// ConfigLexerInit initializes any static state used to implement ConfigLexer. By default the
// static state used to implement the lexer is lazily initialized during the first call to
// NewConfigLexer(). You can call this function if you wish to initialize the static state ahead
// of time.
func ConfigLexerInit() {
staticData := &ConfigLexerLexerStaticData
staticData.once.Do(configlexerLexerInit)
}
// NewConfigLexer produces a new lexer instance for the optional input antlr.CharStream.
func NewConfigLexer(input antlr.CharStream) *ConfigLexer {
ConfigLexerInit()
l := new(ConfigLexer)
l.BaseLexer = antlr.NewBaseLexer(input)
staticData := &ConfigLexerLexerStaticData
l.Interpreter = antlr.NewLexerATNSimulator(l, staticData.atn, staticData.decisionToDFA, staticData.PredictionContextCache)
l.channelNames = staticData.ChannelNames
l.modeNames = staticData.ModeNames
l.RuleNames = staticData.RuleNames
l.LiteralNames = staticData.LiteralNames
l.SymbolicNames = staticData.SymbolicNames
l.GrammarFileName = "Config.g4"
// TODO: l.EOF = antlr.TokenEOF
return l
}
// ConfigLexer tokens.
const (
ConfigLexerHASH = 1
ConfigLexerWHITESPACE = 2
ConfigLexerSTRING = 3
ConfigLexerNEWLINE = 4
ConfigLexerQUOTED_STRING = 5
)

52
handlers/sshd_config/parser/handlers/sshd_config/config_listener.go Normal file
View File

@ -0,0 +1,52 @@
// Code generated from handlers/sshd_config/Config.g4 by ANTLR 4.13.0. DO NOT EDIT.
package parser // Config
import "github.com/antlr4-go/antlr/v4"
// ConfigListener is a complete listener for a parse tree produced by ConfigParser.
type ConfigListener interface {
antlr.ParseTreeListener
// EnterLineStatement is called when entering the lineStatement production.
EnterLineStatement(c *LineStatementContext)
// EnterEntry is called when entering the entry production.
EnterEntry(c *EntryContext)
// EnterSeparator is called when entering the separator production.
EnterSeparator(c *SeparatorContext)
// EnterKey is called when entering the key production.
EnterKey(c *KeyContext)
// EnterValue is called when entering the value production.
EnterValue(c *ValueContext)
// EnterLeadingComment is called when entering the leadingComment production.
EnterLeadingComment(c *LeadingCommentContext)
// EnterString is called when entering the string production.
EnterString(c *StringContext)
// ExitLineStatement is called when exiting the lineStatement production.
ExitLineStatement(c *LineStatementContext)
// ExitEntry is called when exiting the entry production.
ExitEntry(c *EntryContext)
// ExitSeparator is called when exiting the separator production.
ExitSeparator(c *SeparatorContext)
// ExitKey is called when exiting the key production.
ExitKey(c *KeyContext)
// ExitValue is called when exiting the value production.
ExitValue(c *ValueContext)
// ExitLeadingComment is called when exiting the leadingComment production.
ExitLeadingComment(c *LeadingCommentContext)
// ExitString is called when exiting the string production.
ExitString(c *StringContext)
}

1254
handlers/sshd_config/parser/handlers/sshd_config/config_parser.go Normal file
View File

File diff suppressed because it is too large Load Diff

4
handlers/sshd_config/shared.go
View File

@ -7,9 +7,9 @@ import (
protocol "github.com/tliron/glsp/protocol_3_16"
)
type SSHDocument struct {
type SSHDDocument struct {
Config *ast.SSHDConfig
Indexes *indexes.SSHDIndexes
}
var DocumentParserMap = map[protocol.DocumentUri]*SSHDocument{}
var DocumentParserMap = map[protocol.DocumentUri]*SSHDDocument{}

6
handlers/sshd_config/test_utils/input.go
View File

@ -11,9 +11,9 @@ import (
func DocumentFromInput(
t *testing.T,
content string,
) *sshdconfig.SSHDocument {
) *sshdconfig.SSHDDocument {
input := utils.Dedent(content)
c := ast.NewSSHConfig()
c := ast.NewSSHDConfig()
errors := c.Parse(input)
if len(errors) > 0 {
@ -26,7 +26,7 @@ func DocumentFromInput(
t.Fatalf("Index error: %v", errors)
}
return &sshdconfig.SSHDocument{
return &sshdconfig.SSHDDocument{
Config: c,
Indexes: i,
}