parser

Documentation

Index

• Constants
• Variables
• func NewNonEmitingLexer(l StatefulRubyLexer) *nonEmitingLexer
• func Reset()
• func RubyErrorMessage(state, lookAhead int) string
• func RubyParse(Rubylex RubyLexer) int
• func RubyStatname(s int) string
• func RubyTokname(c int) string
• func Rubylex1(lex RubyLexer, lval *RubySymType) (char, token int)
• type ConcreteStatefulRubyLexer
  • func (l *ConcreteStatefulRubyLexer) CurrentLineNumber() int
  • func (lexer *ConcreteStatefulRubyLexer) Error(error string)
  • func (lexer *ConcreteStatefulRubyLexer) Lex(lval *RubySymType) int
• type RubyLexer
• type RubyParser
  • func RubyNewParser() RubyParser
• type RubyParserImpl
  • func (p *RubyParserImpl) Lookahead() int
  • func (Rubyrcvr *RubyParserImpl) Parse(Rubylex RubyLexer) int
• type RubySymType
• type StatefulRubyLexer
  • func NewLexer(input string) StatefulRubyLexer

Constants

const ALIAS = 57388

const AMPERSAND = 57414

const AND = 57383

const AND_EQUALS = 57406

const BANG = 57396

const BEGIN = 57374

const BINARY_MINUS = 57400

const BINARY_PLUS = 57398

const BREAK = 57377

const CARET = 57416

const CASE = 57386

const CLASS = 57369

const COLON = 57410

const COMMA = 57358

const COMPLEMENT = 57397

const CONSTANT = 57352

const DEF = 57363

const DEFINED = 57392

const DO = 57362

const DOT = 57411

const ELSE = 57366

const ELSIF = 57367

const END = 57364

const ENSURE = 57376

const EOF = 57423

const EQUALTO = 57395

const EXCLUSIVE_RANGE = 57404

const FILE_CONST_REF = 57421

const FOR = 57371

const GLOBAL_VARIABLE = 57354

const GREATERTHAN = 57394

const HASH_ROCKET = 57347

const IF = 57365

const IVAR_OR_CLASS_VARIABLE = 57355

const LAMBDA = 57385

const LBRACE = 57419

const LBRACKET = 57417

const LESSTHAN = 57393

const LINE_CONST_REF = 57422

const LPAREN = 57356

const MODULE = 57370

const NAMESPACED_CAPITAL_REF = 57353

const NEWLINE = 57408

const NEXT = 57378

const NIL = 57391

const NODE = 57348

const NamespacedModule = 57360

const OPERATOR = 57346

const OR = 57384

const OR_EQUALS = 57405

const PIPE = 57412

const ProcArg = 57361

const QUESTIONMARK = 57415

const RANGE = 57403

const RBRACE = 57420

const RBRACKET = 57418

const REDO = 57379

const REF = 57349

const RESCUE = 57375

const RETRY = 57380

const RETURN = 57381

const RPAREN = 57357

const RubyEofCode = 1

const RubyErrCode = 2

const RubyFlag = -1000

const RubyLast = 4877

const RubyMaxDepth = 200

const RubyNprod = 330

const RubyPrivate = 57344

const SELF = 57390

const SEMICOLON = 57409

const SLASH = 57413

const SPECIAL_CHAR_REF = 57351

const STAR = 57402

const STRING = 57359

const SUPER = 57389

const SYMBOL = 57350

const UNARY_MINUS = 57401

const UNARY_PLUS = 57399

const UNLESS = 57368

const UNTIL = 57373

const WHEN = 57387

const WHILE = 57372

const WHITESPACE = 57407

const YIELD = 57382

Variables

var (
	RubyDebug        = 0
	RubyErrorVerbose = false
)

var DebugStatements = []string{}

var RubyAct = [...]int{}/* 4877 elements not displayed */

var RubyChk = [...]int{}/* 675 elements not displayed */

var RubyDef = [...]int{}/* 675 elements not displayed */

var RubyErrorMessages = [...]struct {
	state int
	token int
	msg   string
}{}

var RubyExca = [...]int{}/* 238 elements not displayed */

var RubyPact = [...]int{}/* 675 elements not displayed */

var RubyPgo = [...]int{

	0, 626, 0, 302, 621, 39, 8, 620, 619, 618,
	617, 616, 3, 608, 1, 607, 11, 606, 143, 602,
	599, 597, 830, 266, 12, 474, 594, 593, 591, 586,
	584, 581, 573, 571, 565, 558, 557, 556, 995, 15,
	26, 555, 553, 22, 551, 550, 6, 17, 548, 546,
	544, 543, 542, 541, 540, 537, 536, 534, 1055, 533,
	19, 18, 13, 532, 24, 4, 531, 14, 9, 525,
	106, 25, 519, 463, 10, 16, 31, 20, 7, 5,
	69,
}

var RubyR1 = [...]int{}/* 330 elements not displayed */

var RubyR2 = [...]int{}/* 330 elements not displayed */

var RubyStatenames = [...]string{}

var RubyStates []string

var RubyTok1 = [...]int{

	1,
}

var RubyTok2 = [...]int{

	2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
	12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
	22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
	32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
	42, 43, 44, 45, 46, 47, 48, 49, 50, 51,
	52, 53, 54, 55, 56, 57, 58, 59, 60, 61,
	62, 63, 64, 65, 66, 67, 68, 69, 70, 71,
	72, 73, 74, 75, 76, 77, 78, 79, 80, 81,
}

var RubyTok3 = [...]int{
	0,
}

var RubyTokenNames []string

var RubyToknames = [...]string{
	"$end",
	"error",
	"$unk",
	"OPERATOR",
	"HASH_ROCKET",
	"NODE",
	"REF",
	"SYMBOL",
	"SPECIAL_CHAR_REF",
	"CONSTANT",
	"NAMESPACED_CAPITAL_REF",
	"GLOBAL_VARIABLE",
	"IVAR_OR_CLASS_VARIABLE",
	"LPAREN",
	"RPAREN",
	"COMMA",
	"STRING",
	"NamespacedModule",
	"ProcArg",
	"DO",
	"DEF",
	"END",
	"IF",
	"ELSE",
	"ELSIF",
	"UNLESS",
	"CLASS",
	"MODULE",
	"FOR",
	"WHILE",
	"UNTIL",
	"BEGIN",
	"RESCUE",
	"ENSURE",
	"BREAK",
	"NEXT",
	"REDO",
	"RETRY",
	"RETURN",
	"YIELD",
	"AND",
	"OR",
	"LAMBDA",
	"CASE",
	"WHEN",
	"ALIAS",
	"SUPER",
	"SELF",
	"NIL",
	"DEFINED",
	"LESSTHAN",
	"GREATERTHAN",
	"EQUALTO",
	"BANG",
	"COMPLEMENT",
	"BINARY_PLUS",
	"UNARY_PLUS",
	"BINARY_MINUS",
	"UNARY_MINUS",
	"STAR",
	"RANGE",
	"EXCLUSIVE_RANGE",
	"OR_EQUALS",
	"AND_EQUALS",
	"WHITESPACE",
	"NEWLINE",
	"SEMICOLON",
	"COLON",
	"DOT",
	"PIPE",
	"SLASH",
	"AMPERSAND",
	"QUESTIONMARK",
	"CARET",
	"LBRACKET",
	"RBRACKET",
	"LBRACE",
	"RBRACE",
	"FILE_CONST_REF",
	"LINE_CONST_REF",
	"EOF",
}

var Statements []ast.Node

Functions

func NewNonEmitingLexer

func NewNonEmitingLexer(l StatefulRubyLexer) *nonEmitingLexer

func Reset

func Reset()

func RubyErrorMessage

func RubyErrorMessage(state, lookAhead int) string

func RubyParse

func RubyParse(Rubylex RubyLexer) int

func RubyStatname

func RubyStatname(s int) string

func RubyTokname

func RubyTokname(c int) string

func Rubylex1

func Rubylex1(lex RubyLexer, lval *RubySymType) (char, token int)

Types

type ConcreteStatefulRubyLexer

type ConcreteStatefulRubyLexer struct {
	LastError error
	// contains filtered or unexported fields
}

func (*ConcreteStatefulRubyLexer) CurrentLineNumber

func (l *ConcreteStatefulRubyLexer) CurrentLineNumber() int

func (*ConcreteStatefulRubyLexer) Error

func (lexer *ConcreteStatefulRubyLexer) Error(error string)

func (*ConcreteStatefulRubyLexer) Lex

func (lexer *ConcreteStatefulRubyLexer) Lex(lval *RubySymType) int

type RubyLexer

type RubyLexer interface {
	Lex(lval *RubySymType) int
	Error(s string)
}

type RubyParser

type RubyParser interface {
	Parse(RubyLexer) int
	Lookahead() int
}

func RubyNewParser

func RubyNewParser() RubyParser

type RubyParserImpl

type RubyParserImpl struct {
	// contains filtered or unexported fields
}

func (*RubyParserImpl) Lookahead

func (p *RubyParserImpl) Lookahead() int

func (*RubyParserImpl) Parse

func (Rubyrcvr *RubyParserImpl) Parse(Rubylex RubyLexer) int

type RubySymType

type RubySymType struct {
	// contains filtered or unexported fields
}

type StatefulRubyLexer

type StatefulRubyLexer interface {
	CurrentLineNumber() int

	RubyLexer
	// contains filtered or unexported methods
}

func NewLexer

func NewLexer(input string) StatefulRubyLexer