parser

package
v0.0.3 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jul 7, 2026 License: MIT Imports: 18 Imported by: 5

Documentation

Index

Constants

View Source 
const MainName = "(main)"

Variables

View Source 
var (
	DefaultMixedDelimiter = MixedDelimiter{
		Start: []rune("{%"),
		End:   []rune("%}"),
	}

	TemplateStrDelimiter = MixedDelimiter{
		Start: []rune("{"),
		End:   []rune("}"),
	}
)

Functions

func RemoveAllSpaces added in v0.0.2 

func RemoveAllSpaces(t PToken) bool

RemoveAllSpaces reports the double-dash trim marker (`{%--` / `--%}`) on a mixed delimiter token, which strips ALL adjacent whitespace.

func RemoveSpaces 

func RemoveSpaces(t PToken) bool

func StripCR 

func StripCR(b []byte, comment bool) []byte

StripCR removes carriage return characters.

func TrimSpace 

func TrimSpace(left, right bool, s string) string

TrimSpace returns a slice of the string s, with all leading and trailing white space removed, as defined by Unicode.

func Unquote 

func Unquote(s string) (string, error)

Unquote interprets s as a single-quoted, double-quoted, or backquoted Go string literal, returning the string value that s quotes. (If s is single-quoted, it would be a Go character literal; Unquote returns the corresponding one-character string.)

Types

type BlockEnd 

type BlockEnd struct {
	Token token.Token
	Next  bool
}

type BlockWrap 

type BlockWrap struct {
	Start token.Token
	Ends  []BlockEnd
}

type Error 

type Error struct {
	Pos source.FilePos
	Msg string
}

Error represents a parser error.

func (*Error) Error 

func (e *Error) Error() string

func (*Error) Format 

func (e *Error) Format(f fmt.State, verb rune)

type ErrorList 

type ErrorList []*Error

ErrorList is a collection of parser errors.

func (*ErrorList) Add 

func (p *ErrorList) Add(pos source.FilePos, msg string)

Add adds a new parser error to the collection.

func (ErrorList) Err 

func (p ErrorList) Err() error

Err returns an error.

func (ErrorList) Error 

func (p ErrorList) Error() string

func (ErrorList) Format 

func (p ErrorList) Format(f fmt.State, verb rune)

func (ErrorList) Len 

func (p ErrorList) Len() int

Len returns the number of elements in the collection.

func (ErrorList) Less 

func (p ErrorList) Less(i, j int) bool

func (ErrorList) Sort 

func (p ErrorList) Sort()

Sort sorts the collection.

func (ErrorList) Swap 

func (p ErrorList) Swap(i, j int)

type File 

type File struct {
	InputFile *source.File
	Stmts     node.Stmts
	Comments  []*ast.CommentGroup
}

File represents a file unit.

func Parse 

func Parse(input, fileName string, opts *ParserOptions, scannerOpts *ScannerOptions) (*File, error)

func ParseFile 

func ParseFile(pth string, opts *ParserOptions, scannerOpts *ScannerOptions) (file *File, err error)

func ParseTemplateString added in v0.0.2 

func ParseTemplateString(tmpl string, pos source.Pos) (f *File, err error)

ParseTemplateString parses a template string as mixed content using { } delimiters and returns the parsed statements. It is used by TemplateLit compilation to process template interpolation expressions.

pos is the position of the string literal's opening delimiter (the quote) in the original source. The template content itself begins one byte after it, so the parsed file is based at pos+1 to keep interpolation expression positions mapped back to their location in the original source.

func (*File) BuildCode added in v0.0.2 

func (n *File) BuildCode(opt ...node.CodeOption) string

func (*File) End 

func (n *File) End() source.Pos

End returns the position of first character immediately after the node.

func (*File) Pos 

func (n *File) Pos() source.Pos

Pos returns the position of first character belonging to the node.

func (*File) String 

func (n *File) String() string

func (*File) WriteCode 

func (n *File) WriteCode(ctx *node.CodeWriteContext)

type Handlers 

type Handlers struct {
	source.NextHandlers
	ScanHandler   func(ch rune) (t PToken, insertSemi, ok bool)
	TokenHandlers TokenHandlers
}

func (*Handlers) CallTokenHandlers 

func (s *Handlers) CallTokenHandlers(t *PToken)

func (*Handlers) TokenHandler 

func (s *Handlers) TokenHandler(f func(t *PToken))

type MixedDelimiter 

type MixedDelimiter = source.StartEndDelimiter

type Mode 

type Mode int

Mode value is a set of flags for parser. 

const (
	// ParseComments parses comments and add them to AST
	ParseComments Mode = 1 << iota
	ParseMixed
	ParseConfigDisabled
	ParseMixedExprAsValue
	ParseFloatAsDecimal
	ParseCharAsString
)

func (*Mode) Clear 

func (b *Mode) Clear(flag Mode) *Mode

func (Mode) Has 

func (b Mode) Has(flag Mode) bool

func (*Mode) Set 

func (b *Mode) Set(flag Mode) *Mode

func (*Mode) Toggle 

func (b *Mode) Toggle(flag Mode) *Mode

type PToken added in v0.0.2 

type PToken struct {
	node.TokenLit
	InsertSemi bool

	Prev []PToken
	utils.Data
	// contains filtered or unexported fields
}

func (PToken) IsSemi added in v0.0.2 

func (t PToken) IsSemi() bool

func (PToken) IsSpace added in v0.0.2 

func (t PToken) IsSpace() bool

func (*PToken) LiteralRemoveLinePrefix added in v0.0.2 

func (t *PToken) LiteralRemoveLinePrefix(prefix string)

func (PToken) String added in v0.0.2 

func (t PToken) String() string

type ParseListHandler 

type ParseListHandler func(start token.Token, ends ...BlockWrap) (list []node.Stmt, end *BlockEnd)

type Parser 

type Parser struct {
	File    *source.File
	Errors  ErrorList
	Scanner ScannerInterface
	Token   PToken

	PrevToken PToken
	ExprLevel int // < 0: in control clause, >= 0: in expression

	Trace bool

	TraceOut io.Writer

	ParseStmtHandler func() node.Stmt
	InCode           bool
	BlockStart       token.Token
	BlockEnd         token.Token
	ScanFunc         func() PToken
	// contains filtered or unexported fields
}

Parser parses the Tengo source files. It's based on ToInterface's parser implementation.

func NewParser 

func NewParser(file *source.File, trace io.Writer) *Parser

NewParser creates a Parser.

func NewParserWithOptions 

func NewParserWithOptions(
	file *source.File,
	opts *ParserOptions,
	scannerOptions *ScannerOptions,
) *Parser

NewParserWithOptions creates a Parser with parser mode flags.

func NewParserWithScanner 

func NewParserWithScanner(
	scanner ScannerInterface,
	opts *ParserOptions,
) *Parser

NewParserWithScanner creates a Parser with parser mode flags.

func NewSingleParser 

func NewSingleParser(input, fileName string, opts *ParserOptions, scannerOpts *ScannerOptions) *Parser

func (*Parser) AtComma 

func (p *Parser) AtComma(context string, follow token.Token) bool

func (*Parser) AtCommaOrNewLine added in v0.0.2 

func (p *Parser) AtCommaOrNewLine(context string, follow token.Token) bool

func (*Parser) CallArgsOf 

func (p *Parser) CallArgsOf(lparen, rparen source.Pos, exprs ...node.Expr) (params *node.CallArgs)

func (*Parser) DefaultParseStmt 

func (p *Parser) DefaultParseStmt() (stmt node.Stmt)

func (*Parser) Error 

func (p *Parser) Error(pos source.Pos, msg string)

func (*Parser) ErrorExpectToken added in v0.0.2 

func (p *Parser) ErrorExpectToken(got PToken, expected ...token.Token) (tok PToken)

func (*Parser) ErrorExpected 

func (p *Parser) ErrorExpected(pos source.Pos, msg string)

func (*Parser) ErrorExpectedExpr 

func (p *Parser) ErrorExpectedExpr(expected, got node.Expr)

func (*Parser) Expect 

func (p *Parser) Expect(token token.Token) source.Pos

func (*Parser) ExpectLit 

func (p *Parser) ExpectLit(token token.Token) ast.Literal

func (*Parser) ExpectLits 

func (p *Parser) ExpectLits(toks ...token.Token) ast.Literal

func (*Parser) ExpectSemi 

func (p *Parser) ExpectSemi()

func (*Parser) ExpectToken 

func (p *Parser) ExpectToken(token token.Token) (tok PToken)

func (*Parser) Failed added in v0.0.2 

func (p *Parser) Failed() bool

func (*Parser) IsToken 

func (p *Parser) IsToken(toks ...token.Token) bool

func (*Parser) MakeExpr 

func (p *Parser) MakeExpr(s node.Stmt, want string) node.Expr

func (*Parser) Next 

func (p *Parser) Next() *Parser

func (*Parser) ParseArrayLitOrKeyValue 

func (p *Parser) ParseArrayLitOrKeyValue() node.Expr

func (*Parser) ParseBinaryExpr 

func (p *Parser) ParseBinaryExpr(prec1 int) node.Expr

func (*Parser) ParseBlockStmt 

func (p *Parser) ParseBlockStmt(ends ...token.Token) *node.BlockStmt

func (*Parser) ParseBody 

func (p *Parser) ParseBody() (b *node.BlockStmt, lambdaPos source.Pos, closure node.Expr)

func (*Parser) ParseBoolLit added in v0.0.2 

func (p *Parser) ParseBoolLit() *node.BoolLit

func (*Parser) ParseBranchStmt 

func (p *Parser) ParseBranchStmt(tok token.Token) node.Stmt

func (*Parser) ParseBytesLit added in v0.0.2 

func (p *Parser) ParseBytesLit(prefix node.BytesLitPrefix) node.Expr

ParseBytesLit parses the underlying string literal of a b"..."/h"..." bytes literal and wraps it in a *node.BytesLit. The current token is the string literal token carrying the bytes prefix data.

func (*Parser) ParseCall 

func (p *Parser) ParseCall(x node.Expr) *node.CallExpr

func (*Parser) ParseCallArgs 

func (p *Parser) ParseCallArgs(start, end token.Token) *node.CallArgs

func (*Parser) ParseCatchStmt 

func (p *Parser) ParseCatchStmt() *node.CatchStmt

func (*Parser) ParseCharLit 

func (p *Parser) ParseCharLit() node.Expr

func (*Parser) ParseClassExpr added in v0.0.2 

func (p *Parser) ParseClassExpr() node.Expr

ParseClassExpr parses an anonymous class expression `class { … }` (the expression form). The statement form with a name is parsed by ParseClassStmt.

func (*Parser) ParseClassStmt added in v0.0.2 

func (p *Parser) ParseClassStmt() node.Stmt

ParseClassStmt parses the statement form. `class Name { … }` becomes `const Name = <class expression>`; an anonymous `class { … }` used as a statement is parsed as an expression statement.

func (*Parser) ParseClosureExpr 

func (p *Parser) ParseClosureExpr(lambdaToken token.Token, paren *node.MultiParenExpr) *node.ClosureExpr

func (*Parser) ParseCodeStrLit added in v0.0.2 

func (p *Parser) ParseCodeStrLit() (t *node.CodeStrLit)

func (*Parser) ParseComputedExpr added in v0.0.2 

func (p *Parser) ParseComputedExpr() *node.ComputedExpr

func (*Parser) ParseCondExpr 

func (p *Parser) ParseCondExpr(cond node.Expr) node.Expr

func (*Parser) ParseConfigStmt 

func (p *Parser) ParseConfigStmt() (c *node.ConfigStmt)

func (*Parser) ParseCurlyDestructureStmt added in v0.0.2 

func (p *Parser) ParseCurlyDestructureStmt() node.Stmt

ParseCurlyDestructureStmt parses a TypeScript-style named-data destructuring statement: 

{ key, key2: target, name = default, **rest } := / = source

Entries use key-on-the-left (like TypeScript): `key` binds the value of key `key` to the variable `key`; `key2: target` binds the value of key `key2` to the variable `target`; `name = default` supplies a fallback when the key is absent; and a trailing `**rest` collects the remaining keys into a dict. It builds the same KeyValueArrayLit that the `(; … )` form produces (target:key order), so the existing dict-destructuring compiler handles it.

func (*Parser) ParseCurlyPattern added in v0.0.2 

func (p *Parser) ParseCurlyPattern() *node.KeyValueArrayLit

ParseCurlyPattern parses a `{ key, key2: target, name = default, **rest }` destructuring pattern into a KeyValueArrayLit (Curly). Shared by the statement form and by `const`/`var` declarations.

func (*Parser) ParseDateTimeLit added in v0.0.2 

func (p *Parser) ParseDateTimeLit(suffix rune) node.Expr

func (*Parser) ParseDecimalLit added in v0.0.2 

func (p *Parser) ParseDecimalLit() *node.DecimalLit

func (*Parser) ParseDecl 

func (p *Parser) ParseDecl() node.Decl

func (*Parser) ParseDeferStmt added in v0.0.2 

func (p *Parser) ParseDeferStmt() node.Stmt

func (*Parser) ParseDictElementLit 

func (p *Parser) ParseDictElementLit() *node.DictElementLit

func (*Parser) ParseDictElementLitFunc 

func (p *Parser) ParseDictElementLitFunc() *node.FuncDefLit

func (*Parser) ParseDictLit 

func (p *Parser) ParseDictLit() node.Expr

func (*Parser) ParseDurationLit added in v0.0.2 

func (p *Parser) ParseDurationLit() node.Expr

func (*Parser) ParseElse 

func (p *Parser) ParseElse(ifs bool) node.Stmt

func (*Parser) ParseEmbedExpr 

func (p *Parser) ParseEmbedExpr() node.Expr

func (*Parser) ParseEnumExpr added in v0.0.2 

func (p *Parser) ParseEnumExpr() node.Expr

ParseEnumExpr parses an anonymous enum expression `enum { … }` (the expression form). The statement form with a name is parsed by ParseEnumStmt.

func (*Parser) ParseEnumStmt added in v0.0.2 

func (p *Parser) ParseEnumStmt() node.Stmt

ParseEnumStmt parses the statement form. `enum Name { … }` becomes `const Name = <enum expression>`; an anonymous `enum { … }` used as a statement is parsed as an expression statement.

func (*Parser) ParseExportStmt added in v0.0.2 

func (p *Parser) ParseExportStmt() (stmt *node.ExportStmt)

func (*Parser) ParseExpr 

func (p *Parser) ParseExpr() node.Expr

func (*Parser) ParseExprList 

func (p *Parser) ParseExprList() (list []node.Expr)

func (*Parser) ParseFile 

func (p *Parser) ParseFile() (file *File, err error)

ParseFile parses the source and returns an AST file unit.

func (*Parser) ParseFileH 

func (p *Parser) ParseFileH(listHandler ParseListHandler) (file *File, err error)

ParseFileH parses the source and returns an AST file unit.

func (*Parser) ParseFinallyStmt 

func (p *Parser) ParseFinallyStmt() *node.FinallyStmt

func (*Parser) ParseFlagLit added in v0.0.2 

func (p *Parser) ParseFlagLit() *node.FlagLit

func (*Parser) ParseFloatLit added in v0.0.2 

func (p *Parser) ParseFloatLit() *node.FloatLit

func (*Parser) ParseForStmt 

func (p *Parser) ParseForStmt() node.Stmt

func (*Parser) ParseFuncDefLit added in v0.0.2 

func (p *Parser) ParseFuncDefLit(colon token.Token) *node.FuncDefLit

func (*Parser) ParseFuncExpr 

func (p *Parser) ParseFuncExpr() (e node.Expr)

func (*Parser) ParseFuncExprT added in v0.0.2 

func (p *Parser) ParseFuncExprT(tok PToken) (e node.Expr)

func (*Parser) ParseFuncHeaderExpr added in v0.0.2 

func (p *Parser) ParseFuncHeaderExpr() node.Expr

ParseFuncHeaderExpr parses a func-header value `< (params) <return> >`.

func (*Parser) ParseFuncReturnTypes added in v0.0.2 

func (p *Parser) ParseFuncReturnTypes() (types []*node.TypedIdentExpr)

ParseFuncReturnTypes parses an optional function return-type list following the parameter list, of the form "<T>" (single) or "<T1, T2, ...>" (multiple). Each entry is a typed ident, so bare types ("<int>") and named returns ("<x int>") are both supported. It returns nil when no return type is present.

func (*Parser) ParseFuncStmt added in v0.0.2 

func (p *Parser) ParseFuncStmt() (stmt node.Stmt)

func (*Parser) ParseGenDecl 

func (p *Parser) ParseGenDecl(
	keyword token.Token,
	fn func(token.Token, bool, []node.Spec, int) node.Spec,
) *node.GenDecl

func (*Parser) ParseHeredocLit added in v0.0.2 

func (p *Parser) ParseHeredocLit() (t *node.HeredocLit)

func (*Parser) ParseIdent 

func (p *Parser) ParseIdent() *node.IdentExpr

func (*Parser) ParseIfHeader 

func (p *Parser) ParseIfHeader() (init node.Stmt, cond node.Expr)

func (*Parser) ParseIfStmt 

func (p *Parser) ParseIfStmt() node.Stmt

func (*Parser) ParseImportExpr 

func (p *Parser) ParseImportExpr() node.Expr

func (*Parser) ParseIndexExpr added in v0.0.2 

func (p *Parser) ParseIndexExpr(x node.Expr) *node.IndexExpr

func (*Parser) ParseIndexOrSlice 

func (p *Parser) ParseIndexOrSlice(x node.Expr) node.Expr

func (*Parser) ParseIntLit added in v0.0.2 

func (p *Parser) ParseIntLit() *node.IntLit

func (*Parser) ParseInterfaceExpr added in v0.0.2 

func (p *Parser) ParseInterfaceExpr() node.Expr

ParseInterfaceExpr parses an anonymous interface expression `interface { … }`. The statement form with a name is parsed by ParseInterfaceStmt.

func (*Parser) ParseInterfaceStmt added in v0.0.2 

func (p *Parser) ParseInterfaceStmt() node.Stmt

ParseInterfaceStmt parses the statement form. `interface Name { … }` becomes `const Name = <interface expression>`; an anonymous `interface { … }` used as a statement is parsed as an expression statement.

func (*Parser) ParseKeyValueArrayLit 

func (p *Parser) ParseKeyValueArrayLit(lbrace source.Pos) *node.KeyValueArrayLit

func (*Parser) ParseKeyValueArrayLitAt 

func (p *Parser) ParseKeyValueArrayLitAt(lbrace source.Pos, rbraceToken token.Token) *node.KeyValueArrayLit

func (*Parser) ParseKeyValueLit 

func (p *Parser) ParseKeyValueLit() *node.KeyValueLit

func (*Parser) ParseKeyValuePairLit 

func (p *Parser) ParseKeyValuePairLit(endToken token.Token) *node.KeyValuePairLit

func (*Parser) ParseLiteral added in v0.0.2 

func (p *Parser) ParseLiteral() node.Expr

func (*Parser) ParseMatchExpr added in v0.0.2 

func (p *Parser) ParseMatchExpr() node.Expr

func (*Parser) ParseMethodInterfaceExpr added in v0.0.2 

func (p *Parser) ParseMethodInterfaceExpr() node.Expr

func (*Parser) ParseMethodInterfaceExprT added in v0.0.2 

func (p *Parser) ParseMethodInterfaceExprT(tok PToken) (e node.Expr)

ParseMethodInterfaceExprT parses `meti Name? { (params) <return>, … }`. Each header is a func header written without the surrounding angle brackets.

func (*Parser) ParseMethodInterfaceStmt added in v0.0.2 

func (p *Parser) ParseMethodInterfaceStmt() node.Stmt

func (*Parser) ParseMixedTextStmt 

func (p *Parser) ParseMixedTextStmt() (t *node.MixedTextStmt)

func (*Parser) ParseMixedValue 

func (p *Parser) ParseMixedValue() (ett *node.MixedValueStmt)

func (*Parser) ParseNullishSelector 

func (p *Parser) ParseNullishSelector(x node.Expr) (sel node.Expr)

func (*Parser) ParseOperand 

func (p *Parser) ParseOperand() node.Expr

func (*Parser) ParseParamDecl 

func (p *Parser) ParseParamDecl() (d *node.GenDecl)

func (*Parser) ParseParamSpec 

func (p *Parser) ParseParamSpec(keyword token.Token, multi bool, prev []node.Spec, i int) (spec node.Spec)

func (*Parser) ParseParemExpr 

func (p *Parser) ParseParemExpr(lparenToken, rparenToken token.Token) node.ToMultiParenConverter

func (*Parser) ParseParenOrClosure added in v0.0.2 

func (p *Parser) ParseParenOrClosure(lparenToken, rparenToken token.Token) node.Expr

func (*Parser) ParsePipe 

func (p *Parser) ParsePipe(x node.Expr) node.Expr

func (*Parser) ParsePrimaryExpr 

func (p *Parser) ParsePrimaryExpr() node.Expr

func (*Parser) ParsePrimitiveOperand 

func (p *Parser) ParsePrimitiveOperand() node.Expr

func (*Parser) ParsePropExpr added in v0.0.2 

func (p *Parser) ParsePropExpr() (e node.Expr)

func (*Parser) ParsePropExprT added in v0.0.2 

func (p *Parser) ParsePropExprT(tok PToken) (e node.Expr)

ParsePropExprT parses a property expression introduced by the `prop` keyword. It mirrors the func-with-methods body syntax: an optional name followed by either a single accessor `(params) <ret> {body}` or a brace block holding several accessors. A method with no parameters is the getter and a method with one parameter is a setter.

func (*Parser) ParsePropStmt added in v0.0.2 

func (p *Parser) ParsePropStmt() (stmt node.Stmt)

func (*Parser) ParseRawHeredocLit 

func (p *Parser) ParseRawHeredocLit() (t *node.RawHeredocLit)

func (*Parser) ParseRawStrLit added in v0.0.2 

func (p *Parser) ParseRawStrLit() (t *node.RawStrLit)

func (*Parser) ParseReturn 

func (p *Parser) ParseReturn() (ret node.Return)

func (*Parser) ParseReturnExpr 

func (p *Parser) ParseReturnExpr() node.Expr

func (*Parser) ParseReturnStmt 

func (p *Parser) ParseReturnStmt() node.Stmt

func (*Parser) ParseScopedBlockStmt 

func (p *Parser) ParseScopedBlockStmt() *node.BlockStmt

func (*Parser) ParseSelector 

func (p *Parser) ParseSelector(x node.Expr) (sel *node.SelectorExpr)

func (*Parser) ParseSelectorNode 

func (p *Parser) ParseSelectorNode(x node.Expr) (expr, sel node.Expr)

func (*Parser) ParseSimpleSelector added in v0.0.2 

func (p *Parser) ParseSimpleSelector(x node.Expr) (sel *node.SelectorExpr)

func (*Parser) ParseSimpleSelectorExpr added in v0.0.2 

func (p *Parser) ParseSimpleSelectorExpr(x node.Expr) node.Expr

func (*Parser) ParseSimpleSelectorNode added in v0.0.2 

func (p *Parser) ParseSimpleSelectorNode(x node.Expr) (expr, sel node.Expr)

func (*Parser) ParseSimpleStmt 

func (p *Parser) ParseSimpleStmt(forIn bool) node.Stmt

func (*Parser) ParseSingleParemExpr added in v0.0.2 

func (p *Parser) ParseSingleParemExpr(lparen, rparen token.Token) node.Expr

func (*Parser) ParseStmt 

func (p *Parser) ParseStmt() (stmt node.Stmt)

func (*Parser) ParseStmtList 

func (p *Parser) ParseStmtList(end ...token.Token) (list []node.Stmt)

func (*Parser) ParseStrLit added in v0.0.2 

func (p *Parser) ParseStrLit() *node.StrLit

func (*Parser) ParseSymbolLit added in v0.0.2 

func (p *Parser) ParseSymbolLit() *node.SymbolLit

func (*Parser) ParseTestStmt added in v0.0.2 

func (p *Parser) ParseTestStmt() node.Stmt

ParseTestStmt parses `test NAME { … }` / `bench NAME { … }`. NAME is an identifier or a string literal; the body is a block in which the injected `t` test context is available. A preceding doc comment is attached.

func (*Parser) ParseThrowExpr 

func (p *Parser) ParseThrowExpr() *node.ThrowExpr

func (*Parser) ParseThrowStmt 

func (p *Parser) ParseThrowStmt() node.Stmt

func (*Parser) ParseTryStmt 

func (p *Parser) ParseTryStmt() node.Stmt

func (*Parser) ParseTypedIdent 

func (p *Parser) ParseTypedIdent() *node.TypedIdentExpr

func (*Parser) ParseTypes added in v0.0.2 

func (p *Parser) ParseTypes() (types []*node.TypeExpr)

func (*Parser) ParseUintLit added in v0.0.2 

func (p *Parser) ParseUintLit() *node.UintLit

func (*Parser) ParseUnaryExpr 

func (p *Parser) ParseUnaryExpr() node.Expr

func (*Parser) ParseValueSpec 

func (p *Parser) ParseValueSpec(keyword token.Token, multi bool, prev []node.Spec, i int) node.Spec

func (*Parser) ParseWithExpr added in v0.0.2 

func (p *Parser) ParseWithExpr() node.Expr

ParseWithExpr parses the `with Resource [as IDENT]: Value` expression form.

func (*Parser) ParseWithStmt added in v0.0.2 

func (p *Parser) ParseWithStmt() node.Stmt

ParseWithStmt parses a `with` context-manager statement: 

with Resource { ... }
with Resource as IDENT { ... }
with IDENT = Resource { ... }
with IDENT := Resource { ... }

The `with Resource [as IDENT]: Value` expression form may also appear here as a statement (returning an ExprStmt wrapping a WithExpr).

func (*Parser) Peek added in v0.0.2 

func (p *Parser) Peek() PToken

func (*Parser) PeekC added in v0.0.2 

func (p *Parser) PeekC(count int) (t []PToken)

func (*Parser) PeekCb added in v0.0.2 

func (p *Parser) PeekCb(on func(t PToken) (more bool))

func (*Parser) PeekNoSpace added in v0.0.2 

func (p *Parser) PeekNoSpace() (r PToken)

func (*Parser) PrintTrace 

func (p *Parser) PrintTrace(a ...any)

func (*Parser) SkipSpace 

func (p *Parser) SkipSpace()

func (*Parser) WrapPostScan 

func (p *Parser) WrapPostScan(f func(in func(p *Parser)) func(p *Parser))

type ParserOptions 

type ParserOptions struct {
	Trace io.Writer
	Mode  Mode
}

type ScanMode 

type ScanMode uint8

ScanMode represents a scanner mode. 

const (
	ScanComments ScanMode = 1 << iota
	DontInsertSemis
	ScanMixed
	ScanConfigDisabled
	ScanMixedExprAsValue
	ScanFloatAsDecimal
	ScanCharAsString
)

List of scanner modes.

func (*ScanMode) Clear 

func (b *ScanMode) Clear(flag ScanMode) *ScanMode

func (ScanMode) Has 

func (b ScanMode) Has(flag ScanMode) bool

func (*ScanMode) Set 

func (b *ScanMode) Set(flag ScanMode) *ScanMode

func (*ScanMode) Toggle 

func (b *ScanMode) Toggle(flag ScanMode) *ScanMode

type Scanner 

type Scanner struct {
	Handlers
	source.Reader
	MixedDelimiter MixedDelimiter // the mixed delimiters

	InsertSemi bool // insert a semicolon before next newline

	InCode             bool
	ToText             bool
	BraceCount         int
	BreacksCount       int
	ParenCount         int
	TokenPool          TokenPool
	SkipWhitespaceFunc func(s *Scanner)
	HandleMixed        func(textStart *int, rt func() *PToken)
	EOF                *PToken
	// contains filtered or unexported fields
}

Scanner reads the Gad source text. It's based on ToInterface's scanner implementation.

func NewScanner 

func NewScanner(
	file *source.File,
	opts *ScannerOptions,
) *Scanner

NewScanner creates a Scanner.

func (*Scanner) AddNextToken 

func (s *Scanner) AddNextToken(n ...PToken) (r *PToken)

func (*Scanner) AddNextTokenPtr 

func (s *Scanner) AddNextTokenPtr(n ...*PToken) (r *PToken)

func (*Scanner) Clone 

func (s *Scanner) Clone() (c *Scanner)

func (*Scanner) GetMixedDelimiter 

func (s *Scanner) GetMixedDelimiter() *MixedDelimiter

func (*Scanner) List 

func (s *Scanner) List() (ret []PToken)

func (*Scanner) MixedCodeEnds 

func (s *Scanner) MixedCodeEnds(offsetInc int) bool

func (*Scanner) Mode 

func (s *Scanner) Mode() ScanMode

func (*Scanner) ModeP 

func (s *Scanner) ModeP() *ScanMode

func (Scanner) PeekScan 

func (s Scanner) PeekScan() (t PToken)

func (*Scanner) Scan 

func (s *Scanner) Scan() (t PToken)

func (*Scanner) ScanCodeBlock 

func (s *Scanner) ScanCodeBlock(leftText *PToken) (code PToken)

func (*Scanner) ScanComment 

func (s *Scanner) ScanComment() string

func (*Scanner) ScanIdentifier 

func (s *Scanner) ScanIdentifier() string

func (*Scanner) ScanNow 

func (s *Scanner) ScanNow() (t PToken)

ScanNow returns a token, token literal and its position.

func (*Scanner) ScanNumber 

func (s *Scanner) ScanNumber(seenDecimalPoint bool) (tok token.Token, lit string)

func (*Scanner) SetMode 

func (s *Scanner) SetMode(m ScanMode)

func (*Scanner) Switch2 

func (s *Scanner) Switch2(tok0, tok1 token.Token) token.Token

func (*Scanner) Switch3 

func (s *Scanner) Switch3(
	tok0, tok1 token.Token,
	ch2 rune,
	tok2 token.Token,
) token.Token

func (*Scanner) Switch4 

func (s *Scanner) Switch4(
	tok0, tok1 token.Token,
	ch2 rune,
	tok2, tok3 token.Token,
) token.Token

type ScannerInterface 

type ScannerInterface interface {
	Scan() (t PToken)
	Mode() ScanMode
	SetMode(m ScanMode)
	SourceFile() *source.File
	Source() []byte
	ErrorHandler(h ...source.ScannerErrorHandler)
	GetMixedDelimiter() *MixedDelimiter
}

type ScannerOptions 

type ScannerOptions struct {
	Mode           ScanMode
	MixedDelimiter MixedDelimiter
}

type TextFlag 

type TextFlag uint8

TextFlag represents a text flag. 

const (
	TrimLeft TextFlag = 1 << iota
	TrimRight
)

List of scanner modes.

func (*TextFlag) Clear 

func (b *TextFlag) Clear(flag TextFlag) *TextFlag

func (TextFlag) Has 

func (b TextFlag) Has(flag TextFlag) bool

func (*TextFlag) Set 

func (b *TextFlag) Set(flag TextFlag) *TextFlag

func (TextFlag) String 

func (b TextFlag) String() (s string)

func (*TextFlag) Toggle 

func (b *TextFlag) Toggle(flag TextFlag) *TextFlag

type TokenHandler 

type TokenHandler func(t *PToken)

type TokenHandlers 

type TokenHandlers []TokenHandler

func (*TokenHandlers) Remove 

func (th *TokenHandlers) Remove(h TokenHandler)

type TokenPool 

type TokenPool []*PToken

func (*TokenPool) Add 

func (p *TokenPool) Add(t ...*PToken)

func (TokenPool) Empty 

func (p TokenPool) Empty() bool

func (TokenPool) Last 

func (p TokenPool) Last() (t *PToken)

func (*TokenPool) Semi 

func (p *TokenPool) Semi()

func (*TokenPool) Shift 

func (p *TokenPool) Shift() (t *PToken)

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.