parser

type Action ¶

type Action struct {
	Values []*ActionValue // For backward compatibility.
	Token  *Token
	Token2 *Token
}

Action represents data reduced by production:

Action:
        '{' '}'

func (n *Action) Pos() token.Pos

func (n *Action) String() string

type ActionValue ¶

type ActionValue struct {
	Num  int       // The number in $num.
	Pos  token.Pos // Position of the start of the ActionValue.
	Src  string    // Source for this value.
	Tag  string    // The tag in $<tag>$ or $<tag>num.
	Type int       // One of ActionValue{Go,DlrDlr,DlrTagDlr,DlrNum,DlrTagNum} constants.
}

ActionValue is an item of Action.Value

type Definition ¶

type Definition struct {
	Nlist        []*Name // For backward compatibility.
	Value        string
	Case         int
	NameList     *NameList
	ReservedWord *ReservedWord
	Tag          *Tag
	Token        *Token
	Token2       *Token
}

Definition represents data reduced by productions:

Definition:
        START IDENTIFIER
|       UNION                      // Case 1
|       LCURL RCURL                // Case 2
|       ReservedWord Tag NameList  // Case 3
|       ReservedWord Tag           // Case 4
|       ERROR_VERBOSE              // Case 5

func (n *Definition) Pos() token.Pos

func (n *Definition) String() string

type DefinitionList ¶

type DefinitionList struct {
	Definition     *Definition
	DefinitionList *DefinitionList
}

DefinitionList represents data reduced by productions:

DefinitionList:
        /* empty */
|       DefinitionList Definition  // Case 1

func (n *DefinitionList) Pos() token.Pos

func (n *DefinitionList) String() string

type LiteralStringOpt ¶

type LiteralStringOpt struct {
	Token *Token
}

LiteralStringOpt represents data reduced by productions:

LiteralStringOpt:
        /* empty */
|       STRING_LITERAL  // Case 1

func (n *LiteralStringOpt) Pos() token.Pos

func (n *LiteralStringOpt) String() string

type Name ¶

type Name struct {
	Identifier       interface{} // For backward compatibility.
	Number           int         // For backward compatibility.
	Case             int
	LiteralStringOpt *LiteralStringOpt
	Token            *Token
	Token2           *Token
}

Name represents data reduced by productions:

Name:
        IDENTIFIER LiteralStringOpt
|       IDENTIFIER NUMBER LiteralStringOpt  // Case 1

func (n *Name) Pos() token.Pos

func (n *Name) String() string

type NameList ¶

type NameList struct {
	Case     int
	Name     *Name
	NameList *NameList
	Token    *Token
}

NameList represents data reduced by productions:

NameList:
        Name
|       NameList Name      // Case 1
|       NameList ',' Name  // Case 2

func (n *NameList) Pos() token.Pos

func (n *NameList) String() string

type Node ¶

type Node interface {
	Pos() token.Pos
}

Node represents an AST node.

type Precedence ¶

type Precedence struct {
	Identifier interface{} // Name string or literal int.
	Action     *Action
	Case       int
	Precedence *Precedence
	Token      *Token
	Token2     *Token
}

Precedence represents data reduced by productions:

Precedence:
        /* empty */
|       PREC IDENTIFIER         // Case 1
|       PREC IDENTIFIER Action  // Case 2
|       Precedence ';'          // Case 3

func (n *Precedence) Pos() token.Pos

func (n *Precedence) String() string

type ReservedWord ¶

type ReservedWord struct {
	Case  int
	Token *Token
}

ReservedWord represents data reduced by productions:

ReservedWord:
        TOKEN
|       LEFT        // Case 1
|       RIGHT       // Case 2
|       NONASSOC    // Case 3
|       TYPE        // Case 4
|       PRECEDENCE  // Case 5

func (n *ReservedWord) Pos() token.Pos

func (n *ReservedWord) String() string

type Rule ¶

type Rule struct {
	Body         []interface{} // For backward compatibility.
	Name         *Token
	Case         int
	Precedence   *Precedence
	RuleItemList *RuleItemList
	Token        *Token
}

Rule represents data reduced by productions:

Rule:
        C_IDENTIFIER RuleItemList Precedence
|       '|' RuleItemList Precedence           // Case 1

func (n *Rule) Pos() token.Pos

func (n *Rule) String() string

type RuleItemList ¶

type RuleItemList struct {
	Action       *Action
	Case         int
	RuleItemList *RuleItemList
	Token        *Token
}

RuleItemList represents data reduced by productions:

RuleItemList:
        /* empty */
|       RuleItemList IDENTIFIER      // Case 1
|       RuleItemList Action          // Case 2
|       RuleItemList STRING_LITERAL  // Case 3

func (n *RuleItemList) Pos() token.Pos

func (n *RuleItemList) String() string

type RuleList ¶

type RuleList struct {
	Case         int
	Precedence   *Precedence
	Rule         *Rule
	RuleItemList *RuleItemList
	RuleList     *RuleList
	Token        *Token
}

RuleList represents data reduced by productions:

RuleList:
        C_IDENTIFIER RuleItemList Precedence
|       RuleList Rule                         // Case 1

func (n *RuleList) Pos() token.Pos

func (n *RuleList) String() string

type Specification ¶

type Specification struct {
	Defs           []*Definition // For backward compatibility.
	Rules          []*Rule       // For backward compatibility.
	DefinitionList *DefinitionList
	RuleList       *RuleList
	Tail           *Tail
	Token          *Token
}

Specification represents data reduced by production:

Specification:
        DefinitionList "%%" RuleList Tail

func Parse(fset *token.FileSet, fname string, src []byte) (s *Specification, err error)

func (n *Specification) Pos() token.Pos

func (n *Specification) String() string

type Tag ¶

type Tag struct {
	Token  *Token
	Token2 *Token
	Token3 *Token
}

Tag represents data reduced by productions:

Tag:
        /* empty */
|       '<' IDENTIFIER '>'  // Case 1

func (n *Tag) Pos() token.Pos

func (n *Tag) String() string

type Tail ¶

type Tail struct {
	Value string
	Token *Token
}

Tail represents data reduced by productions:

Tail:
        "%%"
|       /* empty */  // Case 1

func (n *Tail) Pos() token.Pos

func (n *Tail) String() string

type Token ¶

type Token struct {
	Comments []string
	Val      string
	File     *token.File
	lex.Char
}

Token captures a lexem with position, value and comments, if any.

func (t *Token) Pos() token.Pos

func (t *Token) Position() token.Position

func (t *Token) String() string