parser

package

Go to main page

Versions in this module

v0

v0.2.5

Oct 22, 2024

v0.2.4

Oct 22, 2024

v0.2.3

Oct 22, 2024

v0.2.2

Oct 18, 2024

v0.2.1

Sep 9, 2024

v0.2.0

Feb 6, 2024

v0.1.9

Feb 6, 2024

v0.1.8

Feb 5, 2024

v0.1.7

Jan 31, 2024

v0.1.6

Jan 31, 2024

v0.1.5

Nov 28, 2023

v0.1.4

Nov 25, 2023

Changes in this version

type Annotation

+ func (a *Annotation) Equals(node Node) bool

type Annotations

+ func (a *Annotations) Equals(node Node) bool

type BadDefinition

+ func (d *BadDefinition) Equals(node Node) bool

type BadHeader

+ func (h *BadHeader) Equals(node Node) bool

type CPPInclude

+ func (i *CPPInclude) Equals(node Node) bool

type CPPIncludeKeyword

+ func (c *CPPIncludeKeyword) Equals(node Node) bool

type ColonKeyword

+ func (c *ColonKeyword) Equals(node Node) bool

type CommaKeyword

+ func (r *CommaKeyword) Equals(node Node) bool

type Comment

+ func (c *Comment) Equals(node Node) bool

type Const

+ func (c *Const) Equals(node Node) bool

type ConstKeyword

+ func (c *ConstKeyword) Equals(node Node) bool

type ConstValue

+ func (c *ConstValue) Equals(node Node) bool

type CppType

+ func (c *CppType) Equals(node Node) bool

type CppTypeKeyword

+ func (r *CppTypeKeyword) Equals(node Node) bool

type Document

+ func (d *Document) Equals(node Node) bool

type Enum

+ func (e *Enum) Equals(node Node) bool

type EnumKeyword

+ func (e *EnumKeyword) Equals(node Node) bool

type EnumValue

+ func (e *EnumValue) Equals(node Node) bool

type EqualKeyword

+ func (e *EqualKeyword) Equals(node Node) bool

type Exception

+ func (e *Exception) Equals(node Node) bool

type ExceptionKeyword

+ func (e *ExceptionKeyword) Equals(node Node) bool

type ExtendsKeyword

+ func (s *ExtendsKeyword) Equals(node Node) bool

type Field

+ func (f *Field) Equals(node Node) bool

type FieldIndex

+ func (f *FieldIndex) Equals(node Node) bool

type FieldType

+ func (c *FieldType) Equals(node Node) bool

type Function

+ func (f *Function) Equals(node Node) bool

type Identifier

+ func (i *Identifier) Equals(node Node) bool

type IdentifierName

+ func (i *IdentifierName) Equals(node Node) bool

type Include

+ func (i *Include) Equals(node Node) bool

type IncludeKeyword

+ func (i *IncludeKeyword) Equals(node Node) bool

type Keyword

+ func (i *Keyword) Equals(k *Keyword) bool

type KeywordLiteral

+ func (k *KeywordLiteral) Equals(node Node) bool

type LBrkKeyword

+ func (l *LBrkKeyword) Equals(node Node) bool

type LCurKeyword

+ func (s *LCurKeyword) Equals(node Node) bool

type LParKeyword

+ func (l *LParKeyword) Equals(node Node) bool

type LPointKeyword

+ func (l *LPointKeyword) Equals(node Node) bool

type ListSeparatorKeyword

+ func (e *ListSeparatorKeyword) Equals(node Node) bool

type Literal

+ func (l *Literal) Equals(node Node) bool

type LiteralValue

+ func (l *LiteralValue) Equals(node Node) bool

type Namespace

+ func (n *Namespace) Equals(node Node) bool

type NamespaceKeyword

+ func (n *NamespaceKeyword) Equals(node Node) bool

type NamespaceScope

+ func (ns *NamespaceScope) Equals(node Node) bool

type Node

+ Equals func(node Node) bool

type OnewayKeyword

+ func (o *OnewayKeyword) Equals(node Node) bool

type RBrkKeyword

+ func (l *RBrkKeyword) Equals(node Node) bool

type RCurKeyword

+ func (s *RCurKeyword) Equals(node Node) bool

type RParKeyword

+ func (r *RParKeyword) Equals(node Node) bool

type RPointKeyword

+ func (r *RPointKeyword) Equals(node Node) bool

type RequiredKeyword

+ func (r *RequiredKeyword) Equals(node Node) bool

type Service

+ func (s *Service) Equals(node Node) bool

type ServiceKeyword

+ func (s *ServiceKeyword) Equals(node Node) bool

type Struct

+ func (s *Struct) Equals(node Node) bool

type StructKeyword

+ func (s *StructKeyword) Equals(node Node) bool

type Throws

+ func (t *Throws) Equals(node Node) bool

type ThrowsKeyword

+ func (t *ThrowsKeyword) Equals(node Node) bool

type TypeName

+ func (t *TypeName) Equals(node Node) bool

type Typedef

+ func (t *Typedef) Equals(node Node) bool

type TypedefKeyword

+ func (t *TypedefKeyword) Equals(node Node) bool

type Union

+ func (u *Union) Equals(node Node) bool

type UnionKeyword

+ func (u *UnionKeyword) Equals(node Node) bool

type VoidKeyword

+ func (v *VoidKeyword) Equals(node Node) bool

v0.1.3

Nov 16, 2023

v0.1.2

Nov 7, 2023

v0.1.1

Oct 11, 2023

v0.1.0

Oct 8, 2023

v0.0.9

Oct 3, 2023

Changes in this version

type Node

+ func SearchNodePathByPosition(root Node, pos Position) []Node

v0.0.8

Aug 17, 2023

v0.0.7

Aug 14, 2023

Changes in this version

+ const LCUR

+ const RCUR

+ var InvalidConstConstValueError error = errors.New("expecting a valid const value")

+ var InvalidConstError error = errors.New("expecting a valid const definition")

+ var InvalidConstIdentifierError error = errors.New("expecting a valid const identifier")

+ var InvalidConstMissingValueError error = errors.New("expecting a const value")

+ var InvalidCppIncludeError error = errors.New("expecting a valid cpp include header")

+ var InvalidDefinitionError error = errors.New("expecting a valid definition")

+ var InvalidEnumBlockLCURError error = errors.New("expecting a starting '{' of enum block")

+ var InvalidEnumBlockRCURError error = errors.New("expecting a ending '}' of enum block")

+ var InvalidEnumError error = errors.New("expecting a valid enum definition")

+ var InvalidEnumIdentifierError error = errors.New("expecting a valid enum identifier")

+ var InvalidEnumValueError error = errors.New("expecting a valid enum field")

+ var InvalidEnumValueIntConstantError error = errors.New("expecting a valid int contant")

+ var InvalidExceptionBlockLCURError error = errors.New("expecting a starting '{' of exception block")

+ var InvalidExceptionBlockRCURError error = errors.New("expecting a ending '}' of exception block")

+ var InvalidExceptionError error = errors.New("expecting a valid exception definition")

+ var InvalidExceptionFieldError error = errors.New("expecting a valid exception field")

+ var InvalidExceptionIdentifierError error = errors.New("expecting a valid exception identifier")

+ var InvalidFieldIndexError error = errors.New("expecting a valid int16 field index")

+ var InvalidFieldTypeError error = errors.New("expecting a valid field type")

+ var InvalidFunctionArgumentError error = errors.New("expecting a valid function argument")

+ var InvalidFunctionIdentifierError error = errors.New("expecting a valid function identifier")

+ var InvalidHeaderError error = errors.New("expecting a valid header")

+ var InvalidIdentifierError error = errors.New("expecting a valid identifier")

+ var InvalidIncludeError error = errors.New("expecting a valid include header")

+ var InvalidLiteral1Error error = errors.New("expecting a valid literal")

+ var InvalidLiteral1MissingRightError error = errors.New("expecting a right \" ")

+ var InvalidLiteral2Error error = errors.New("expecting a valid literal")

+ var InvalidLiteral2MissingRightError error = errors.New("expecting a right ' ")

+ var InvalidNamespaceError error = errors.New("expecting a valid namespace header")

+ var InvalidPosition = Position

+ var InvalidServiceBlockRCURError error = errors.New("expecting a ending '}' of service block")

+ var InvalidServiceError error = errors.New("expecting a valid service definition")

+ var InvalidServiceFunctionError error = errors.New("expecting a valid service function")

+ var InvalidServiceIdentifierError error = errors.New("expecting a valid service identifier")

+ var InvalidStructBlockLCURError error = errors.New("expecting a starting '{' of struct block")

+ var InvalidStructBlockRCURError error = errors.New("expecting an ending '}' of struct block")

+ var InvalidStructError error = errors.New("expecting a valid struct definition")

+ var InvalidStructFieldError error = errors.New("expecting a valid struct field")

+ var InvalidStructIdentifierError error = errors.New("expecting a valid struct identifier")

+ var InvalidTypedefError error = errors.New("expecting a valid typedef definition")

+ var InvalidTypedefIdentifierError error = errors.New("expecting a valid typedef identifier")

+ var InvalidUnionBlockLCURError error = errors.New("expecting a starting '{' of union block")

+ var InvalidUnionBlockRCURError error = errors.New("expecting a ending '}' of union block")

+ var InvalidUnionError error = errors.New("expecting a valid union definition")

+ var InvalidUnionFieldError error = errors.New("expecting a valid union field")

+ var InvalidUnionIdentifierError error = errors.New("expecting a valid union identifier")

+ var RequiredError error = errors.New("expecting 'required' or 'optional'")

+ func Parse(filename string, b []byte, opts ...Option) (any, error)

+ func ParseFile(filename string, opts ...Option) (i any, err error)

+ func ParseReader(filename string, r io.Reader, opts ...Option) (any, error)

+ func StringPointer(s string) *string

+ type Annotation struct

+ BadNode bool

+ EqualKeyword *EqualKeyword

+ Identifier *Identifier

+ ListSeparatorKeyword *ListSeparatorKeyword

+ Value *Literal

+ func NewAnnotation(equalKeyword *EqualKeyword, listSeparatorKeyword *ListSeparatorKeyword, ...) *Annotation

+ func NewBadAnnotation(loc Location) *Annotation

+ func (a *Annotation) Children() []Node

+ func (a *Annotation) ChildrenBadNode() bool

+ func (a *Annotation) IsBadNode() bool

+ func (a *Annotation) Type() string

+ type Annotations struct

+ Annotations []*Annotation

+ BadNode bool

+ LParKeyword *LParKeyword

+ RParKeyword *RParKeyword

+ func NewAnnotations(lpar *LParKeyword, rpar *RParKeyword, annos []*Annotation, loc Location) *Annotations

+ func (a *Annotations) Children() []Node

+ func (a *Annotations) ChildrenBadNode() bool

+ func (a *Annotations) IsBadNode() bool

+ func (a *Annotations) Type() string

+ type BadDefinition struct

+ BadNode bool

+ func NewBadDefinition(loc Location) *BadDefinition

+ func (d *BadDefinition) Children() []Node

+ func (d *BadDefinition) ChildrenBadNode() bool

+ func (d *BadDefinition) IsBadNode() bool

+ func (d *BadDefinition) SetAnnotations(annos *Annotations)

+ func (d *BadDefinition) SetComments([]*Comment, []*Comment)

+ func (d *BadDefinition) SetLocation(loc Location)

+ func (d *BadDefinition) Type() string

+ type BadHeader struct

+ BadNode bool

+ func NewBadHeader(loc Location) *BadHeader

+ func (h *BadHeader) Children() []Node

+ func (h *BadHeader) ChildrenBadNode() bool

+ func (h *BadHeader) IsBadNode() bool

+ func (h *BadHeader) SetComments([]*Comment, []*Comment)

+ func (h *BadHeader) SetLocation(loc Location)

+ func (h *BadHeader) Type() string

+ type CPPInclude struct

+ BadNode bool

+ CPPIncludeKeyword *CPPIncludeKeyword

+ Comments []*Comment

+ EndLineComments []*Comment

+ Path *Literal

+ func NewBadCPPInclude(loc Location) *CPPInclude

+ func NewCPPInclude(keyword *CPPIncludeKeyword, path *Literal, loc Location) *CPPInclude

+ func (i *CPPInclude) Children() []Node

+ func (i *CPPInclude) ChildrenBadNode() bool

+ func (i *CPPInclude) IsBadNode() bool

+ func (i *CPPInclude) SetComments(comments []*Comment, endLineComments []*Comment)

+ func (i *CPPInclude) SetLocation(loc Location)

+ func (i *CPPInclude) Type() string

+ type CPPIncludeKeyword struct

+ func (c *CPPIncludeKeyword) Type() string

+ type Cloner interface

+ Clone func() any

+ type ColonKeyword struct

+ func (c *ColonKeyword) Type() string

+ type CommaKeyword struct

+ func (r *CommaKeyword) Type() string

+ type Comment struct

+ BadNode bool

+ Style CommentStyle

+ Text string

+ func NewBadComment(loc Location) *Comment

+ func NewComment(text string, style CommentStyle, loc Location) *Comment

+ func (c *Comment) Children() []Node

+ func (c *Comment) ChildrenBadNode() bool

+ func (c *Comment) IsBadNode() bool

+ func (c *Comment) Type() string

+ type CommentStyle string

+ const CommentStyleMultiLine

+ const CommentStyleShell

+ const CommentStyleSingleLine

+ type Const struct

+ Annotations *Annotations

+ BadNode bool

+ Comments []*Comment

+ ConstKeyword *ConstKeyword

+ ConstType *FieldType

+ EndLineComments []*Comment

+ EqualKeyword *EqualKeyword

+ ListSeparatorKeyword *ListSeparatorKeyword

+ Name *Identifier

+ Value *ConstValue

+ func NewBadConst(loc Location) *Const

+ func NewConst(constKeyword *ConstKeyword, equalKeyword *EqualKeyword, ...) *Const

+ func (c *Const) Children() []Node

+ func (c *Const) ChildrenBadNode() bool

+ func (c *Const) IsBadNode() bool

+ func (c *Const) SetAnnotations(annos *Annotations)

+ func (c *Const) SetComments(comments []*Comment, endLineComments []*Comment)

+ func (c *Const) SetLocation(loc Location)

+ func (c *Const) Type() string

+ type ConstKeyword struct

+ func (c *ConstKeyword) Type() string

+ type ConstValue struct

+ BadNode bool

+ ColonKeyword *ColonKeyword

+ Comments []*Comment

+ Key any

+ LBrkKeyword *LBrkKeyword

+ LCurKeyword *LCurKeyword

+ ListSeparatorKeyword *ListSeparatorKeyword

+ RBrkKeyword *RBrkKeyword

+ RCurKeyword *RCurKeyword

+ TypeName string

+ Value any

+ ValueInText string

+ func NewBadConstValue(loc Location) *ConstValue

+ func NewBadIntConstValue(loc Location) *ConstValue

+ func NewConstValue(typeName string, value any, loc Location) *ConstValue

+ func NewMapConstValue(key, value *ConstValue, loc Location) *ConstValue

+ func (c *ConstValue) Children() []Node

+ func (c *ConstValue) ChildrenBadNode() bool

+ func (c *ConstValue) IsBadNode() bool

+ func (c *ConstValue) SetComments(comments []*Comment)

+ func (c *ConstValue) Type() string

+ type CppType struct

+ BadNode bool

+ CppTypeKeyword *CppTypeKeyword

+ Literal *Literal

+ func NewCppType(cppTypeKeyword *CppTypeKeyword, literal *Literal, loc Location) *CppType

+ func (c *CppType) Children() []Node

+ func (c *CppType) ChildrenBadNode() bool

+ func (c *CppType) IsBadNode() bool

+ func (c *CppType) Type() string

+ type CppTypeKeyword struct

+ func (c *CppTypeKeyword) Type() string

+ type Definition interface

+ SetAnnotations func(annotations *Annotations)

+ SetComments func(comments []*Comment, endLineComments []*Comment)

+ SetLocation func(loc Location)

+ Type func() string

+ type Document struct

+ BadDefinitions []*BadDefinition

+ BadHeaders []*BadHeader

+ CPPIncludes []*CPPInclude

+ Comments []*Comment

+ Consts []*Const

+ Enums []*Enum

+ Exceptions []*Exception

+ Filename string

+ Includes []*Include

+ Namespaces []*Namespace

+ Nodes []Node

+ Services []*Service

+ Structs []*Struct

+ Typedefs []*Typedef

+ Unions []*Union

+ func NewDocument(headers []Header, defs []Definition, comments []*Comment, loc Location) *Document

+ func (d *Document) Children() []Node

+ func (d *Document) ChildrenBadNode() bool

+ func (d *Document) IsBadNode() bool

+ func (d *Document) Type() string

+ type Enum struct

+ Annotations *Annotations

+ BadNode bool

+ Comments []*Comment

+ EndLineComments []*Comment

+ EnumKeyword *EnumKeyword

+ LCurKeyword *LCurKeyword

+ Name *Identifier

+ RCurKeyword *RCurKeyword

+ Values []*EnumValue

+ func NewBadEnum(loc Location) *Enum

+ func NewEnum(enumKeyword *EnumKeyword, lCurKeyword *LCurKeyword, rCurKeyword *RCurKeyword, ...) *Enum

+ func (e *Enum) Children() []Node

+ func (e *Enum) ChildrenBadNode() bool

+ func (e *Enum) IsBadNode() bool

+ func (e *Enum) SetAnnotations(annos *Annotations)

+ func (e *Enum) SetComments(comments []*Comment, endlineComments []*Comment)

+ func (e *Enum) SetLocation(loc Location)

+ func (e *Enum) Type() string

+ type EnumKeyword struct

+ func (e *EnumKeyword) Type() string

+ type EnumValue struct

+ Annotations *Annotations

+ BadNode bool

+ Comments []*Comment

+ EndLineComments []*Comment

+ EqualKeyword *EqualKeyword

+ ListSeparatorKeyword *ListSeparatorKeyword

+ Name *Identifier

+ Value int64

+ ValueNode *ConstValue

+ func NewBadEnumValue(loc Location) *EnumValue

+ func NewEnumValue(listSeparatorKeyword *ListSeparatorKeyword, equalKeyword *EqualKeyword, ...) *EnumValue

+ func (e *EnumValue) Children() []Node

+ func (e *EnumValue) ChildrenBadNode() bool

+ func (e *EnumValue) IsBadNode() bool

+ func (e *EnumValue) SetComments(comments []*Comment, endLineComments []*Comment)

+ func (e *EnumValue) Type() string

+ type EqualKeyword struct

+ func NewBadEqualKeyword() *EqualKeyword

+ func (e *EqualKeyword) Type() string

+ type ErrorLister interface

+ Errors func() []error

+ type Exception struct

+ Annotations *Annotations

+ BadNode bool

+ Comments []*Comment

+ EndLineComments []*Comment

+ ExceptionKeyword *ExceptionKeyword

+ Fields []*Field

+ LCurKeyword *LCurKeyword

+ Name *Identifier

+ RCurKeyword *RCurKeyword

+ func NewBadException(loc Location) *Exception

+ func NewException(exceptionKeyword *ExceptionKeyword, lCurKeyword *LCurKeyword, ...) *Exception

+ func (e *Exception) Children() []Node

+ func (e *Exception) ChildrenBadNode() bool

+ func (e *Exception) IsBadNode() bool

+ func (e *Exception) SetAnnotations(annos *Annotations)

+ func (e *Exception) SetComments(comments []*Comment, endLineComments []*Comment)

+ func (e *Exception) SetLocation(loc Location)

+ func (e *Exception) Type() string

+ type ExceptionKeyword struct

+ func (e *ExceptionKeyword) Type() string

+ type ExtendsKeyword struct

+ func (s *ExtendsKeyword) Type() string

+ type Field struct

+ Annotations *Annotations

+ BadNode bool

+ Comments []*Comment

+ ConstValue *ConstValue

+ EndLineComments []*Comment

+ EqualKeyword *EqualKeyword

+ FieldType *FieldType

+ Identifier *Identifier

+ Index *FieldIndex

+ ListSeparatorKeyword *ListSeparatorKeyword

+ RequiredKeyword *RequiredKeyword

+ func NewBadField(loc Location) *Field

+ func NewField(equalKeyword *EqualKeyword, listSeparatorKeyword *ListSeparatorKeyword, ...) *Field

+ func (f *Field) Children() []Node

+ func (f *Field) ChildrenBadNode() bool

+ func (f *Field) IsBadNode() bool

+ func (f *Field) Type() string

+ type FieldIndex struct

+ BadNode bool

+ ColonKeyword *ColonKeyword

+ Comments []*Comment

+ Value int

+ func NewBadFieldIndex(loc Location) *FieldIndex

+ func NewFieldIndex(ColonKeyword *ColonKeyword, v int, comments []*Comment, loc Location) *FieldIndex

+ func (f *FieldIndex) Children() []Node

+ func (f *FieldIndex) ChildrenBadNode() bool

+ func (f *FieldIndex) IsBadNode() bool

+ func (f *FieldIndex) Type() string

+ type FieldType struct

+ Annotations *Annotations

+ BadNode bool

+ CommaKeyword *CommaKeyword

+ CppType *CppType

+ KeyType *FieldType

+ LPointKeyword *LPointKeyword

+ RPointKeyword *RPointKeyword

+ TypeName *TypeName

+ ValueType *FieldType

+ func NewFieldType(lpointKeyword *LPointKeyword, rpointKeyword *RPointKeyword, ...) *FieldType

+ func (c *FieldType) Children() []Node

+ func (c *FieldType) ChildrenBadNode() bool

+ func (c *FieldType) IsBadNode() bool

+ func (c *FieldType) Type() string

+ type Function struct

+ Annotations *Annotations

+ Arguments []*Field

+ BadNode bool

+ Comments []*Comment

+ EndLineComments []*Comment

+ FunctionType *FieldType

+ LParKeyword *LParKeyword

+ ListSeparatorKeyword *ListSeparatorKeyword

+ Name *Identifier

+ Oneway *OnewayKeyword

+ RParKeyword *RParKeyword

+ Throws *Throws

+ Void *VoidKeyword

+ func NewBadFunction(loc Location) *Function

+ func NewFunction(lParKeyword *LParKeyword, rParKeyword *RParKeyword, ...) *Function

+ func (f *Function) Children() []Node

+ func (f *Function) ChildrenBadNode() bool

+ func (f *Function) IsBadNode() bool

+ func (f *Function) Type() string

+ type Header interface

+ SetComments func(comments []*Comment, endLineComments []*Comment)

+ SetLocation func(loc Location)

+ Type func() string

+ type Identifier struct

+ BadNode bool

+ Comments []*Comment

+ Name *IdentifierName

+ func NewBadIdentifier(loc Location) *Identifier

+ func NewIdentifier(name *IdentifierName, comments []*Comment, loc Location) *Identifier

+ func (i *Identifier) Children() []Node

+ func (i *Identifier) ChildrenBadNode() bool

+ func (i *Identifier) IsBadNode() bool

+ func (i *Identifier) ToFieldType() *FieldType

+ func (i *Identifier) Type() string

+ type IdentifierName struct

+ BadNode bool

+ Text string

+ func NewIdentifierName(name string, loc Location) *IdentifierName

+ func (i *IdentifierName) Children() []Node

+ func (i *IdentifierName) ChildrenBadNode() bool

+ func (i *IdentifierName) IsBadNode() bool

+ func (i *IdentifierName) Type() string

+ type Include struct

+ BadNode bool

+ Comments []*Comment

+ EndLineComments []*Comment

+ IncludeKeyword *IncludeKeyword

+ Path *Literal

+ func NewBadInclude(loc Location) *Include

+ func NewInclude(keyword *IncludeKeyword, path *Literal, loc Location) *Include

+ func (i *Include) Children() []Node

+ func (i *Include) ChildrenBadNode() bool

+ func (i *Include) IsBadNode() bool

+ func (i *Include) Name() string

+ func (i *Include) SetComments(comments []*Comment, endLineComments []*Comment)

+ func (i *Include) SetLocation(loc Location)

+ func (i *Include) Type() string

+ type IncludeCall func(include string) (filename string, content []byte, err error)

+ type IncludeKeyword struct

+ func (i *IncludeKeyword) Type() string

+ type Keyword struct

+ BadNode bool

+ Comments []*Comment

+ Literal *KeywordLiteral

+ func NewKeyword(comments []*Comment, literal *KeywordLiteral, loc Location) Keyword

+ func (i *Keyword) Children() []Node

+ func (i *Keyword) ChildrenBadNode() bool

+ func (i *Keyword) IsBadNode() bool

+ type KeywordLiteral struct

+ BadNode bool

+ Text string

+ func NewBadKeywordLiteral(c *current) *KeywordLiteral

+ func NewKeywordLiteral(c *current) *KeywordLiteral

+ func (k *KeywordLiteral) Children() []Node

+ func (k *KeywordLiteral) ChildrenBadNode() bool

+ func (k *KeywordLiteral) IsBadNode() bool

+ func (k *KeywordLiteral) Type() string

+ type LBrkKeyword struct

+ func (l *LBrkKeyword) Type() string

+ type LCurKeyword struct

+ func (s *LCurKeyword) Type() string

+ type LParKeyword struct

+ func (l *LParKeyword) Type() string

+ type LPointKeyword struct

+ func (l *LPointKeyword) Type() string

+ type ListSeparatorKeyword struct

+ Text string

+ func (e *ListSeparatorKeyword) Type() string

+ type Literal struct

+ BadNode bool

+ Comments []*Comment

+ Quote string

+ Value *LiteralValue

+ func NewBadLiteral(loc Location) *Literal

+ func NewLiteral(comments []*Comment, v *LiteralValue, quote string, loc Location) *Literal

+ func (l *Literal) Children() []Node

+ func (l *Literal) ChildrenBadNode() bool

+ func (l *Literal) IsBadNode() bool

+ func (l *Literal) Type() string

+ type LiteralValue struct

+ BadNode bool

+ Text string

+ func NewBadLiteralValue(loc Location) *LiteralValue

+ func NewLiteralValue(text string, loc Location) *LiteralValue

+ func (l *LiteralValue) Children() []Node

+ func (l *LiteralValue) ChildrenBadNode() bool

+ func (l *LiteralValue) IsBadNode() bool

+ func (l *LiteralValue) Type() string

+ type Location struct

+ EndPos Position

+ StartPos Position

+ func NewLocation(startPos position, text string) Location

+ func NewLocationFromCurrent(c *current) Location

+ func NewLocationFromPos(start, end Position) Location

+ func (l *Location) Contains(pos Position) bool

+ func (l *Location) End() Position

+ func (l *Location) Pos() Position

+ func (l Location) MoveStartInLine(n int) Location

+ type Namespace struct

+ Annotations *Annotations

+ BadNode bool

+ Comments []*Comment

+ EndLineComments []*Comment

+ Language *NamespaceScope

+ Name *Identifier

+ NamespaceKeyword *NamespaceKeyword

+ func NewBadNamespace(loc Location) *Namespace

+ func NewNamespace(keyword *NamespaceKeyword, language *NamespaceScope, name *Identifier, ...) *Namespace

+ func (n *Namespace) Children() []Node

+ func (n *Namespace) ChildrenBadNode() bool

+ func (n *Namespace) IsBadNode() bool

+ func (n *Namespace) SetComments(comments []*Comment, endLineComments []*Comment)

+ func (n *Namespace) SetLocation(loc Location)

+ func (n *Namespace) Type() string

+ type NamespaceKeyword struct

+ func (n *NamespaceKeyword) Type() string

+ type NamespaceScope struct

+ type Node interface

+ Children func() []Node

+ ChildrenBadNode func() bool

+ Contains func(pos Position) bool

+ End func() Position

+ IsBadNode func() bool

+ Pos func() Position

+ Type func() string

+ func SearchNodePath(root Node, pos Position) []Node

+ type OnewayKeyword struct

+ func (o *OnewayKeyword) Type() string

+ type Option func(*parser) Option

+ func AllowInvalidUTF8(b bool) Option

+ func Debug(b bool) Option

+ func Entrypoint(ruleName string) Option

+ func GlobalStore(key string, value any) Option

+ func InitState(key string, value any) Option

+ func MaxExpressions(maxExprCnt uint64) Option

+ func Memoize(b bool) Option

+ func Recover(b bool) Option

+ func Statistics(stats *Stats, choiceNoMatch string) Option

+ type PEGParser struct

+ func (p *PEGParser) Parse(filename string, content []byte) (*Document, []error)

+ func (p *PEGParser) ParseRecursively(filename string, content []byte, maxDepth int, call IncludeCall) []*ParseResult

+ type ParseResult struct

+ Doc *Document

+ Errors []error

+ type Parser interface

+ Parse func(filename string, content []byte) *ParseResult

+ ParseRecursively func(filename string, content []byte, maxDepth int, call IncludeCall) []*ParseResult

+ type ParserError interface

+ Error func() string

+ Expected func() []string

+ InnerError func() error

+ Pos func() (int, int, int)

+ type Position struct

+ Col int

+ Line int

+ Offset int

+ func ConvertPosition(pos position) Position

+ func (p *Position) Equal(other Position) bool

+ func (p *Position) Greater(other Position) bool

+ func (p *Position) Invalid() bool

+ func (p *Position) Less(other Position) bool

+ type RBrkKeyword struct

+ func (l *RBrkKeyword) Type() string

+ type RCurKeyword struct

+ func (s *RCurKeyword) Type() string

+ type RParKeyword struct

+ func (r *RParKeyword) Type() string

+ type RPointKeyword struct

+ func (r *RPointKeyword) Type() string

+ type RequiredKeyword struct

+ func (r *RequiredKeyword) Type() string

+ type Service struct

+ Annotations *Annotations

+ BadNode bool

+ Comments []*Comment

+ EndLineComments []*Comment

+ Extends *Identifier

+ ExtendsKeyword *ExtendsKeyword

+ Functions []*Function

+ LCurKeyword *LCurKeyword

+ Name *Identifier

+ RCurKeyword *RCurKeyword

+ ServiceKeyword *ServiceKeyword

+ func NewBadService(loc Location) *Service

+ func NewService(serviceKeyword *ServiceKeyword, extendsKeyword *ExtendsKeyword, ...) *Service

+ func (s *Service) Children() []Node

+ func (s *Service) ChildrenBadNode() bool

+ func (s *Service) IsBadNode() bool

+ func (s *Service) SetAnnotations(annos *Annotations)

+ func (s *Service) SetComments(comments []*Comment, endLineComments []*Comment)

+ func (s *Service) SetLocation(loc Location)

+ func (s *Service) Type() string

+ type ServiceKeyword struct

+ func (s *ServiceKeyword) Type() string

+ type Stats struct

+ ChoiceAltCnt map[string]map[string]int

+ ExprCnt uint64

+ type Struct struct

+ Annotations *Annotations

+ BadNode bool

+ Comments []*Comment

+ EndLineComments []*Comment

+ Fields []*Field

+ Identifier *Identifier

+ LCurKeyword *LCurKeyword

+ RCurKeyword *RCurKeyword

+ StructKeyword *StructKeyword

+ func NewBadStruct(loc Location) *Struct

+ func NewStruct(structKeyword *StructKeyword, lCurKeyword *LCurKeyword, ...) *Struct

+ func (s *Struct) Children() []Node

+ func (s *Struct) ChildrenBadNode() bool

+ func (s *Struct) IsBadNode() bool

+ func (s *Struct) SetAnnotations(annos *Annotations)

+ func (s *Struct) SetComments(comments []*Comment, endLineComments []*Comment)

+ func (s *Struct) SetLocation(loc Location)

+ func (s *Struct) Type() string

+ type StructKeyword struct

+ func (s *StructKeyword) Type() string

+ type Throws struct

+ BadNode bool

+ Fields []*Field

+ LParKeyword *LParKeyword

+ RParKeyword *RParKeyword

+ ThrowsKeyword *ThrowsKeyword

+ func NewThrows(throwsKeyword *ThrowsKeyword, lparKeyword *LParKeyword, ...) *Throws

+ func (t *Throws) Children() []Node

+ func (t *Throws) ChildrenBadNode() bool

+ func (t *Throws) IsBadNode() bool

+ func (t *Throws) Type() string

+ type ThrowsKeyword struct

+ func (t *ThrowsKeyword) Type() string

+ type TypeName struct

+ BadNode bool

+ Comments []*Comment

+ Name string

+ func NewTypeName(name string, pos position) *TypeName

+ func (t *TypeName) Children() []Node

+ func (t *TypeName) ChildrenBadNode() bool

+ func (t *TypeName) IsBadNode() bool

+ func (t *TypeName) Type() string

+ type Typedef struct

+ Alias *Identifier

+ Annotations *Annotations

+ BadNode bool

+ Comments []*Comment

+ EndLineComments []*Comment

+ T *FieldType

+ TypedefKeyword *TypedefKeyword

+ func NewBadTypedef(loc Location) *Typedef

+ func NewTypedef(keyword *TypedefKeyword, t *FieldType, alias *Identifier, loc Location) *Typedef

+ func (t *Typedef) Children() []Node

+ func (t *Typedef) ChildrenBadNode() bool

+ func (t *Typedef) IsBadNode() bool

+ func (t *Typedef) SetAnnotations(annos *Annotations)

+ func (t *Typedef) SetComments(comments []*Comment, endLineComments []*Comment)

+ func (t *Typedef) SetLocation(loc Location)

+ func (t *Typedef) Type() string

+ type TypedefKeyword struct

+ func (t *TypedefKeyword) Type() string

+ type Union struct

+ Annotations *Annotations

+ BadNode bool

+ Comments []*Comment

+ EndLineComments []*Comment

+ Fields []*Field

+ LCurKeyword *LCurKeyword

+ Name *Identifier

+ RCurKeyword *RCurKeyword

+ UnionKeyword *UnionKeyword

+ func NewBadUnion(loc Location) *Union

+ func NewUnion(unionKeyword *UnionKeyword, lCurKeyword *LCurKeyword, rCurKeyword *RCurKeyword, ...) *Union

+ func (u *Union) Children() []Node

+ func (u *Union) ChildrenBadNode() bool

+ func (u *Union) IsBadNode() bool

+ func (u *Union) SetAnnotations(annos *Annotations)

+ func (u *Union) SetComments(comments []*Comment, endLineComments []*Comment)

+ func (u *Union) SetLocation(loc Location)

+ func (u *Union) Type() string

+ type UnionKeyword struct

+ func (u *UnionKeyword) Type() string

+ type VoidKeyword struct

+ func (v *VoidKeyword) Type() string

v0.0.6

Aug 12, 2023

v0.0.5

Aug 11, 2023

v0.0.4

Aug 10, 2023

v0.0.3

Aug 10, 2023

v0.0.2

Aug 10, 2023

v0.0.1

Aug 5, 2023

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL