chore: Update parsers; Add update script

handlers/ssh_config/Config.g4

@@ -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? ('"')?
+    ;

handlers/sshd_config/analyzer/analyzer.go

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

handlers/sshd_config/analyzer/include.go

@@ -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,
 	}
 

handlers/sshd_config/analyzer/match.go

@@ -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)
 

handlers/sshd_config/analyzer/match_test.go

@@ -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 {

handlers/sshd_config/analyzer/options.go

@@ -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()

handlers/sshd_config/analyzer/quotes.go

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

handlers/sshd_config/ast/listener.go

@@ -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 {
+func createListenerContext() *sshdListenerContext {
-	context := new(sshListenerContext)
+	context := new(sshdListenerContext)
 	context.isKeyAMatchBlock = false
 
 	return context
@@ -27,37 +27,37 @@ func createSSHListenerContext() *sshListenerContext {
 
 func createListener(
 	config *SSHDConfig,
-	context *sshListenerContext,
+	context *sshdListenerContext,
-) sshParserListener {
+) sshdParserListener {
-	return sshParserListener{
+	return sshdParserListener{
-		Config:     config,
+		Config:      config,
-		Errors:     make([]common.LSPError, 0),
+		Errors:      make([]common.LSPError, 0),
-		sshContext: context,
+		sshdContext: context,
 	}
 }
 
-type sshParserListener struct {
+type sshdParserListener struct {
 	*parser.BaseConfigListener
-	Config     *SSHDConfig
+	Config      *SSHDConfig
-	Errors     []common.LSPError
+	Errors      []common.LSPError
-	sshContext *sshListenerContext
+	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 {
+		if s.sshdContext.currentOption.OptionValue != nil {
-			matchParser := matchparser2.NewMatch()
+			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 {
+	if s.sshdContext.currentMatchBlock != nil {
-		s.sshContext.currentMatchBlock.Options.Put(
+		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,
 		)
 	}
 }

handlers/sshd_config/ast/parser.go

@@ -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)

handlers/sshd_config/ast/parser_test.go

@@ -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 {

handlers/sshd_config/ast/sshd_config.go

@@ -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

handlers/sshd_config/handlers/completions.go

@@ -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,

handlers/sshd_config/handlers/completions_match.go

@@ -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()

handlers/sshd_config/handlers/formatting.go

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

handlers/sshd_config/handlers/formatting_nodes.go

@@ -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,

handlers/sshd_config/handlers/formatting_test.go

@@ -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,
 	}

handlers/sshd_config/indexes/indexes_test.go

@@ -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 {

handlers/sshd_config/lsp/text-document-did-open.go

@@ -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()
+		config := ast.NewSSHDConfig()
-		document = &sshdconfig.SSHDocument{
+		document = &sshdconfig.SSHDDocument{
 			Config: config,
 		}
 		sshdconfig.DocumentParserMap[params.TextDocument.URI] = document

handlers/sshd_config/match-parser/handlers/sshd_config/match-parser/match_base_listener.go

@@ -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) {}

handlers/sshd_config/match-parser/handlers/sshd_config/match-parser/match_lexer.go

@@ -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
+)

handlers/sshd_config/match-parser/handlers/sshd_config/match-parser/match_listener.go

@@ -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)
+}

handlers/sshd_config/match-parser/handlers/sshd_config/match-parser/match_parser.go

@@ -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
+}

handlers/sshd_config/match-parser/listener.go

@@ -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)
 

handlers/sshd_config/match-parser/parser.go

@@ -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)
 

handlers/sshd_config/match-parser/parser/Match.interp

@@ -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]

handlers/sshd_config/match-parser/parser/Match.tokens

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

handlers/sshd_config/match-parser/parser/MatchLexer.interp

@@ -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]

handlers/sshd_config/match-parser/parser/MatchLexer.tokens

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

handlers/sshd_config/parser/handlers/sshd_config/Config.interp

@@ -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]

handlers/sshd_config/parser/handlers/sshd_config/Config.tokens

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

handlers/sshd_config/parser/handlers/sshd_config/ConfigLexer.interp

@@ -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]

handlers/sshd_config/parser/handlers/sshd_config/ConfigLexer.tokens

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

handlers/sshd_config/parser/handlers/sshd_config/config_base_listener.go

@@ -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) {}

handlers/sshd_config/parser/handlers/sshd_config/config_lexer.go

@@ -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
+)

handlers/sshd_config/parser/handlers/sshd_config/config_listener.go

@@ -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)
+}

handlers/sshd_config/shared.go

@@ -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{}

handlers/sshd_config/test_utils/input.go

@@ -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,
 	}