Documentation
¶
Overview ¶
Package parser implements the ClassAd lexer and parser.
Package parser provides the ClassAd parser implementation. The parser is generated from classad.y using goyacc.
Index ¶
- Constants
- func Parse(input string) (ast.Node, error)
- func ParseClassAd(input string) (*ast.ClassAd, error)
- func ParseExpr(input string) (ast.Expr, error)
- func ParseOldClassAd(input string) (*ast.ClassAd, error)
- func ParseScopedIdentifier(identifier string) (string, ast.AttributeScope)
- type Lexer
- type ReaderParser
- type StreamingLexer
- type Token
Constants ¶
const AND = 57356
const BOOLEAN_LITERAL = 57350
const ELVIS = 57354
const EQ = 57357
const ERROR = 57352
const GE = 57362
const IDENTIFIER = 57346
const INT64_MIN_MAGNITUDE = 57353
const INTEGER_LITERAL = 57348
const IS = 57359
const ISNT = 57360
const LE = 57361
const LSHIFT = 57363
const NE = 57358
const OR = 57355
const REAL_LITERAL = 57349
const RSHIFT = 57364
const STRING_LITERAL = 57347
const UNARY = 57366
const UNDEFINED = 57351
const URSHIFT = 57365
Variables ¶
This section is empty.
Functions ¶
func Parse ¶
Parse parses a ClassAd string (a bracketed record, "[ a = 1; ... ]") and returns its AST. It does not accept a bare expression; to parse a standalone expression such as "a + 1" or "{1, 2}", use ParseExpr.
func ParseClassAd ¶
ParseClassAd parses a ClassAd and returns a ClassAd AST node. It returns an error if the input is not a ClassAd (for example a bare expression).
func ParseExpr ¶ added in v0.1.0
ParseExpr parses a standalone ClassAd expression (for example "a + 1", `strcat("x", "y")`, or "{1, 2, 3}") and returns its expression AST. It returns an error if the input is not a single well-formed expression.
The grammar's top-level production is a ClassAd, so the expression is parsed inside a throwaway single-attribute wrapper and the attribute's value is returned. This keeps Parse ClassAd-only -- avoiding grammar ambiguity between a record literal and a bare expression -- while still giving callers direct expression access.
func ParseOldClassAd ¶
ParseOldClassAd parses a ClassAd in the "old" HTCondor format. Old ClassAds have attributes separated by newlines without surrounding brackets. Example:
Foo = 3 Bar = "hello" Moo = Foo =!= Undefined
This implementation converts the old format to new format and reuses the existing parser.
func ParseScopedIdentifier ¶
func ParseScopedIdentifier(identifier string) (string, ast.AttributeScope)
ParseScopedIdentifier parses an identifier that may have a scope prefix. Returns the attribute name and scope.
Types ¶
type Lexer ¶
type Lexer struct {
// contains filtered or unexported fields
}
Lexer wraps the streaming lexer for string inputs while retaining the input and position fields used in existing tests.
func (*Lexer) Result ¶
Result returns the parsed result and any error. It must surface an error recorded on the underlying streaming lexer even when the parser produced a (partial) result -- e.g. trailing input that triggers a lexer error after a complete ClassAd, which the reference parser rejects.
type ReaderParser ¶
type ReaderParser struct {
// contains filtered or unexported fields
}
ReaderParser parses consecutive ClassAds from a buffered reader without requiring delimiters between ads. It reuses a single streaming lexer instance for efficiency.
func NewReaderParser ¶
func NewReaderParser(r io.Reader) *ReaderParser
NewReaderParser creates a reusable parser that pulls consecutive ClassAds from the provided reader without requiring delimiters. Non-buffered readers are wrapped internally for efficiency.
func (*ReaderParser) ParseClassAd ¶
func (p *ReaderParser) ParseClassAd() (*ast.ClassAd, error)
ParseClassAd parses the next ClassAd from the underlying reader. It reuses the same streaming lexer instance to avoid per-call allocations. It returns io.EOF when there is no more data to parse.
type StreamingLexer ¶
type StreamingLexer struct {
// contains filtered or unexported fields
}
StreamingLexer tokenizes ClassAds directly from an io.Reader. It stops producing tokens after the first complete ClassAd so the caller can parse multiple ads from a single stream.
func NewStreamingLexer ¶
func NewStreamingLexer(r io.Reader) *StreamingLexer
NewStreamingLexer creates a lexer that consumes tokens directly from a reader. It wraps non-buffered readers in a bufio.Reader for efficiency.
func (*StreamingLexer) Error ¶
func (l *StreamingLexer) Error(s string)
Error implements the goyacc Lexer interface.
func (*StreamingLexer) Lex ¶
func (l *StreamingLexer) Lex(lval *yySymType) int
Lex implements the goyacc Lexer interface.
func (*StreamingLexer) Result ¶
func (l *StreamingLexer) Result() (ast.Node, error)
Result returns the parsed result and any error.
func (*StreamingLexer) SetResult ¶
func (l *StreamingLexer) SetResult(node ast.Node)
SetResult sets the parse result.
Source Files