grammar

package
v0.0.0-...-b9e2bad Latest Latest
Warning

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

Go to latest
Published: Oct 13, 2022 License: MPL-2.0 Imports: 9 Imported by: 0

Documentation

Index

Constants

View Source
const (
	ModPublic = 0x1

	ModPrivate = 0x4

	ModFinal  = 0x10
	ModStatic = 0x20
)
View Source
const (
	TS_NONE = iota
	TS_EXTENDS
	TS_SUPER
	TS_PLAIN
)
View Source
const ABSTRACT = 57366
View Source
const ASSERT = 57367
View Source
const ASS_ADD = 57357
View Source
const ASS_AND = 57361
View Source
const ASS_DIV = 57360
View Source
const ASS_MOD = 57364
View Source
const ASS_MUL = 57359
View Source
const ASS_OR = 57362
View Source
const ASS_SUB = 57358
View Source
const ASS_XOR = 57363
View Source
const BOOLEAN = 57368
View Source
const BOOLLIT = 57348
View Source
const BREAK = 57369
View Source
const BYTE = 57370
View Source
const CASE = 57371
View Source
const CATCH = 57372
View Source
const CHAR = 57373
View Source
const CLASS = 57374
View Source
const CONTINUE = 57375
View Source
const DEFAULT = 57376
View Source
const DO = 57377
View Source
const DOUBLE = 57378
View Source
const ELSE = 57379
View Source
const ENUM = 57380
View Source
const EXTENDS = 57381
View Source
const FINAL = 57382
View Source
const FINALLY = 57383
View Source
const FLOAT = 57384
View Source
const FOR = 57385
View Source
const IDENTIFIER = 57346
View Source
const IF = 57386
View Source
const IMPLEMENTS = 57387
View Source
const IMPORT = 57388
View Source
const INSTANCEOF = 57389
View Source
const INT = 57390
View Source
const INTERFACE = 57391
View Source
const JNULL = 57395
View Source
const JulyEofCode = 1
View Source
const JulyErrCode = 2
View Source
const JulyFlag = -1000
View Source
const JulyLast = 2631
View Source
const JulyMaxDepth = 200
View Source
const JulyNprod = 444
View Source
const JulyPrivate = 57344
View Source
const LITERAL = 57347
View Source
const LONG = 57392
View Source
const NATIVE = 57393
View Source
const NEW = 57394
View Source
const OP_DEC = 57354
View Source
const OP_DIM = 57365
View Source
const OP_EQ = 57349
View Source
const OP_INC = 57353
View Source
const OP_LAND = 57352
View Source
const OP_LOR = 57351
View Source
const OP_NE = 57350
View Source
const OP_SHL = 57355
View Source
const OP_SHRR = 57356
View Source
const PACKAGE = 57396
View Source
const PRIVATE = 57397
View Source
const PROTECTED = 57398
View Source
const PUBLIC = 57399
View Source
const RETURN = 57400
View Source
const SHORT = 57401
View Source
const STATIC = 57402
View Source
const SUPER = 57403
View Source
const SWITCH = 57404
View Source
const SYNCHRONIZED = 57405
View Source
const THIS = 57406
View Source
const THROW = 57407
View Source
const THROWS = 57408
View Source
const TRANSIENT = 57409
View Source
const TRY = 57410
View Source
const VOID = 57411
View Source
const VOLATILE = 57412
View Source
const WHILE = 57413

Variables

View Source
var JulyAct = []int{}/* 2631 elements not displayed */
View Source
var JulyChk = []int{}/* 748 elements not displayed */
View Source
var JulyDebug = 0
View Source
var JulyDef = []int{}/* 748 elements not displayed */
View Source
var JulyExca = []int{}/* 132 elements not displayed */
View Source
var JulyPact = []int{}/* 748 elements not displayed */
View Source
var JulyPgo = []int{}/* 149 elements not displayed */
View Source
var JulyR1 = []int{}/* 444 elements not displayed */
View Source
var JulyR2 = []int{}/* 444 elements not displayed */
View Source
var JulyStatenames = []string{}
View Source
var JulyStates []string
View Source
var JulyTok1 = []int{}/* 127 elements not displayed */
View Source
var JulyTok2 = []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,
}
View Source
var JulyTok3 = []int{
	0,
}
View Source
var JulyTokenNames []string
View Source
var JulyToknames = []string{
	"IDENTIFIER",
	"LITERAL",
	"BOOLLIT",
	"OP_EQ",
	"OP_NE",
	"OP_LOR",
	"OP_LAND",
	"OP_INC",
	"OP_DEC",
	"OP_SHL",
	"OP_SHRR",
	"ASS_ADD",
	"ASS_SUB",
	"ASS_MUL",
	"ASS_DIV",
	"ASS_AND",
	"ASS_OR",
	"ASS_XOR",
	"ASS_MOD",
	"OP_DIM",
	"ABSTRACT",
	"ASSERT",
	"BOOLEAN",
	"BREAK",
	"BYTE",
	"CASE",
	"CATCH",
	"CHAR",
	"CLASS",
	"CONTINUE",
	"DEFAULT",
	"DO",
	"DOUBLE",
	"ELSE",
	"ENUM",
	"EXTENDS",
	"FINAL",
	"FINALLY",
	"FLOAT",
	"FOR",
	"IF",
	"IMPLEMENTS",
	"IMPORT",
	"INSTANCEOF",
	"INT",
	"INTERFACE",
	"LONG",
	"NATIVE",
	"NEW",
	"JNULL",
	"PACKAGE",
	"PRIVATE",
	"PROTECTED",
	"PUBLIC",
	"RETURN",
	"SHORT",
	"STATIC",
	"SUPER",
	"SWITCH",
	"SYNCHRONIZED",
	"THIS",
	"THROW",
	"THROWS",
	"TRANSIENT",
	"TRY",
	"VOID",
	"VOLATILE",
	"WHILE",
}

Functions

func JulyParse

func JulyParse(Julylex JulyLexer) int

func JulyStatname

func JulyStatname(s int) string

func JulyTokname

func JulyTokname(c int) string

func Julylex1

func Julylex1(lex JulyLexer, lval *JulySymType) int

func NewFileLexer

func NewFileLexer(path string, debugLex bool) (y *myLexer)

func NewLexer

func NewLexer(src ByteReader, debugLex bool) (y *myLexer)

func ReportCastError

func ReportCastError(expName string, obj interface{})

func ReportError

func ReportError(msg string)

Types

type ByteReader

type ByteReader interface {
	ReadByte() (byte, error)
}

type JAnnotation

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

func NewJAnnotation

func NewJAnnotation(name *JTypeName, elem []JObject,
	has_parens bool) *JAnnotation

type JArrayAlloc

type JArrayAlloc struct {
	Typename *JTypeName
	Dimexprs []JObject
	Dims     int
	Init     []*JVariableInit
}

func NewJArrayAlloc

func NewJArrayAlloc(typename *JTypeName, dimexprs []JObject,
	dims int) *JArrayAlloc

func (*JArrayAlloc) SetInitializers

func (j *JArrayAlloc) SetInitializers(init []*JVariableInit)

type JArrayReference

type JArrayReference struct {
	Name *JTypeName
	Obj  JObject
	Expr JObject
}

func NewJArrayReference

func NewJArrayReference(name *JTypeName, obj JObject, expr JObject) *JArrayReference

type JAssignmentExpr

type JAssignmentExpr struct {
	Left  JObject
	Op    string
	Right JObject
}

func NewJAssignmentExpr

func NewJAssignmentExpr(left JObject, op string, right JObject) *JAssignmentExpr

type JBinaryExpr

type JBinaryExpr struct {
	Obj1 JObject
	Op   string
	Obj2 JObject
}

func NewJBinaryExpr

func NewJBinaryExpr(obj1 JObject, op string, obj2 JObject) *JBinaryExpr

type JBlock

type JBlock struct {
	List []JObject
	// contains filtered or unexported fields
}

func NewJBlock

func NewJBlock(list []JObject) *JBlock

func (*JBlock) SetStatic

func (j *JBlock) SetStatic()

type JCastExpr

type JCastExpr struct {
	Reftype *JReferenceType
	Target  JObject
}

func NewJCastExpr

func NewJCastExpr(reftype *JReferenceType, target JObject) *JCastExpr

type JCatch

type JCatch struct {
	Modifiers *JModifiers
	TypeList  []*JTypeName
	Name      string
	Block     *JBlock
}

func NewJCatch

func NewJCatch(modifiers *JModifiers, typelist []*JTypeName, name string,
	block *JBlock) *JCatch

type JClassAllocationExpr

type JClassAllocationExpr struct {
	Name     *JTypeName
	TypeArgs []*JTypeArgument
	Arglist  []JObject
	Body     []JObject
}

func NewJClassAllocationExpr

func NewJClassAllocationExpr(name *JTypeName, obj_args []JObject,
	arglist []JObject) *JClassAllocationExpr

func (*JClassAllocationExpr) SetBody

func (j *JClassAllocationExpr) SetBody(body []JObject)

type JClassBody

type JClassBody struct {
	List []JObject
}

func NewJClassBody

func NewJClassBody(list []JObject) *JClassBody

type JClassDecl

type JClassDecl struct {
	Name string

	Extends    *JReferenceType
	Interfaces []*JTypeName
	Body       []JObject
	// contains filtered or unexported fields
}

func NewJClassDecl

func NewJClassDecl(modifiers *JModifiers, name string, type_params []JObject,
	extends *JReferenceType, interfaces []*JTypeName, body []JObject) *JClassDecl

type JConditionalExpr

type JConditionalExpr struct {
	CondExpr JObject
	IfExpr   JObject
	ElseExpr JObject
}

func NewJConditionalExpr

func NewJConditionalExpr(condexpr JObject, ifexpr JObject, elseexpr JObject) *JConditionalExpr

type JConstantDecl

type JConstantDecl struct {
	TypeSpec *JReferenceType
	Name     string
	Dims     int
	Init     *JVariableInit
	// contains filtered or unexported fields
}

func NewJConstantDecl

func NewJConstantDecl(name string, dims int,
	init *JVariableInit) *JConstantDecl

func (*JConstantDecl) HasName

func (j *JConstantDecl) HasName() bool

func (*JConstantDecl) SetModifiers

func (j *JConstantDecl) SetModifiers(modifiers *JModifiers)

func (*JConstantDecl) SetName

func (j *JConstantDecl) SetName(name string)

func (*JConstantDecl) SetType

func (j *JConstantDecl) SetType(typespec *JReferenceType)

type JElementValuePair

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

func NewJElementValuePair

func NewJElementValuePair(name string, value JObject) *JElementValuePair

type JEmpty

type JEmpty struct {
}

func NewJEmpty

func NewJEmpty() *JEmpty

type JEnumBody

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

func NewJEnumBody

func NewJEnumBody(clist []JObject, bodydecl []JObject) *JEnumBody

type JEnumConstant

type JEnumConstant struct {
	Annotations []*JAnnotation
	Name        string
	ArgList     []JObject
	Body        []JObject
}

func NewJEnumConstant

func NewJEnumConstant(alist []JObject, name string, arglist []JObject,
	body []JObject) *JEnumConstant

type JEnumDecl

type JEnumDecl struct {
	Name       string
	Interfaces []*JTypeName
	Constants  []*JEnumConstant
	BodyDecl   []JObject
	// contains filtered or unexported fields
}

func NewJEnumDecl

func NewJEnumDecl(modifiers *JModifiers, name string, interfaces []*JTypeName,
	body *JEnumBody) *JEnumDecl

type JForColon

type JForColon struct {
	VarDecl *JVariableDecl
	Expr    JObject
	Body    JObject
}

func NewJForColon

func NewJForColon(modifiers *JModifiers, typespec *JReferenceType,
	name string, dims int, expr JObject) *JForColon

func (*JForColon) SetBody

func (j *JForColon) SetBody(body JObject)

type JForExpr

type JForExpr struct {
	Init []JObject
	Expr JObject
	Incr []JObject
	Body JObject
}

func NewJForExpr

func NewJForExpr(init []JObject, expr JObject, incr []JObject) *JForExpr

func (*JForExpr) SetBody

func (j *JForExpr) SetBody(body JObject)

type JForVar

type JForVar struct {
	VarDecl *JVariableDecl
	Decl    JObject
	Expr    JObject
	Incr    []JObject
	Body    JObject
}

func NewJForVar

func NewJForVar(modifiers *JModifiers, typespec *JReferenceType,
	name string, dims int) *JForVar

func (*JForVar) SetBody

func (j *JForVar) SetBody(body JObject)

func (*JForVar) SetDecl

func (j *JForVar) SetDecl(decl JObject)

func (*JForVar) SetExpr

func (j *JForVar) SetExpr(expr JObject)

func (*JForVar) SetIncr

func (j *JForVar) SetIncr(incr []JObject)

func (*JForVar) SetInit

func (j *JForVar) SetInit(init *JVariableInit)

type JFormalParameter

type JFormalParameter struct {
	Modifiers *JModifiers
	TypeSpec  *JReferenceType
	DotDotDot bool
	Name      string
	Dims      int
}

func NewJFormalParameter

func NewJFormalParameter(typespec *JReferenceType, dotdotdot bool,
	name string, dims int) *JFormalParameter

func (*JFormalParameter) SetModifiers

func (j *JFormalParameter) SetModifiers(modifiers *JModifiers)

type JIfElseStmt

type JIfElseStmt struct {
	Cond      JObject
	IfBlock   JObject
	ElseBlock JObject
}

func NewJIfElseStmt

func NewJIfElseStmt(cond JObject, ifblock JObject, elseblock JObject) *JIfElseStmt

type JImportStmt

type JImportStmt struct {
	Name *JTypeName
	// contains filtered or unexported fields
}

func NewJImportStmt

func NewJImportStmt(name *JTypeName, is_wild bool, is_static bool) *JImportStmt

type JInstanceOf

type JInstanceOf struct {
	Obj      JObject
	TypeSpec *JReferenceType
}

func NewJInstanceOf

func NewJInstanceOf(obj JObject, typespec *JReferenceType) *JInstanceOf

type JInterfaceDecl

type JInterfaceDecl struct {
	Name *JTypeName

	Body []JObject
	// contains filtered or unexported fields
}

func NewJInterfaceDecl

func NewJInterfaceDecl(modifiers *JModifiers, name *JTypeName,
	type_params []JObject, extends []*JTypeName,
	body []JObject) *JInterfaceDecl

type JInterfaceMethodDecl

type JInterfaceMethodDecl struct {
	TypeSpec     *JReferenceType
	Name         string
	FormalParams []*JFormalParameter
	// contains filtered or unexported fields
}

func NewJInterfaceMethodDecl

func NewJInterfaceMethodDecl(formal_params []*JFormalParameter, dims int,
	throws []*JTypeName) *JInterfaceMethodDecl

func (*JInterfaceMethodDecl) SetModifiers

func (j *JInterfaceMethodDecl) SetModifiers(modifiers *JModifiers)

func (*JInterfaceMethodDecl) SetName

func (j *JInterfaceMethodDecl) SetName(name string)

func (*JInterfaceMethodDecl) SetType

func (j *JInterfaceMethodDecl) SetType(typespec *JReferenceType)

func (*JInterfaceMethodDecl) SetTypeParameters

func (j *JInterfaceMethodDecl) SetTypeParameters(type_params []JObject)

type JJumpToLabel

type JJumpToLabel struct {
	IsContinue bool
	Label      string
}

func NewJJumpToLabel

func NewJJumpToLabel(token int, label string) *JJumpToLabel

type JKeyword

type JKeyword struct {
	Token int
	Name  string
}

func NewJKeyword

func NewJKeyword(token int, name string) *JKeyword

type JLabeledStatement

type JLabeledStatement struct {
	Label string
	Stmt  JObject
}

func NewJLabeledStatement

func NewJLabeledStatement(label string, stmt JObject) *JLabeledStatement

type JLiteral

type JLiteral struct {
	Text string
}

func NewJLiteral

func NewJLiteral(text string) *JLiteral

type JLocalVariableDecl

type JLocalVariableDecl struct {
	Modifiers *JModifiers
	TypeSpec  *JReferenceType
	Vars      []*JVariableDecl
}

func NewJLocalVariableDecl

func NewJLocalVariableDecl(modifiers *JModifiers, typespec *JReferenceType,
	vars []*JVariableDecl) *JLocalVariableDecl

type JMethodAccess

type JMethodAccess struct {
	NameObj  JObject
	NameKey  *JKeyword
	NameType *JTypeName
	Method   string
	ArgList  []JObject
}

func NewJMethodAccessComplex

func NewJMethodAccessComplex(obj JObject, name string,
	arglist []JObject) *JMethodAccess

func NewJMethodAccessKeyword

func NewJMethodAccessKeyword(token int, name string, arglist []JObject) *JMethodAccess

func NewJMethodAccessName

func NewJMethodAccessName(nametyp *JTypeName,
	arglist []JObject) *JMethodAccess

type JMethodDecl

type JMethodDecl struct {
	Modifiers *JModifiers

	TypeSpec     *JReferenceType
	Name         string
	FormalParams []*JFormalParameter

	Block *JBlock
	// contains filtered or unexported fields
}

func NewJMethodDecl

func NewJMethodDecl(formal_params []*JFormalParameter, dims int,
	throws []*JTypeName, block *JBlock) *JMethodDecl

func (*JMethodDecl) SetModifiers

func (j *JMethodDecl) SetModifiers(modifiers *JModifiers)

func (*JMethodDecl) SetName

func (j *JMethodDecl) SetName(name string)

func (*JMethodDecl) SetType

func (j *JMethodDecl) SetType(typespec *JReferenceType)

func (*JMethodDecl) SetTypeParameters

func (j *JMethodDecl) SetTypeParameters(type_params []JObject)

type JModifiers

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

func NewJModifiers

func NewJModifiers(name string, annotation *JAnnotation) *JModifiers

func (*JModifiers) AddAnnotation

func (j *JModifiers) AddAnnotation(annotation *JAnnotation) *JModifiers

func (*JModifiers) AddModifier

func (j *JModifiers) AddModifier(name string) *JModifiers

func (*JModifiers) HasAnnotation

func (j *JModifiers) HasAnnotation(name string) bool

func (*JModifiers) IsSet

func (j *JModifiers) IsSet(modbit int) bool

func (*JModifiers) String

func (j *JModifiers) String() string

type JNameDotObject

type JNameDotObject struct {
	Name *JTypeName
	Obj  JObject
}

func NewJNameDotObject

func NewJNameDotObject(name *JTypeName, obj JObject) *JNameDotObject

type JObject

type JObject interface {
}

type JObjectDotName

type JObjectDotName struct {
	Obj  JObject
	Name *JTypeName
}

func NewJObjectDotName

func NewJObjectDotName(obj JObject, name *JTypeName) *JObjectDotName

type JPackageStmt

type JPackageStmt struct {
	Name *JTypeName
}

func NewJPackageStmt

func NewJPackageStmt(name *JTypeName) *JPackageStmt

type JParens

type JParens struct {
	Expr JObject
}

func NewJParens

func NewJParens(expr JObject) *JParens

type JProgramFile

type JProgramFile struct {
	Pkg       *JPackageStmt
	Imports   []JObject
	TypeDecls []JObject
}

func NewJProgramFile

func NewJProgramFile(pobj JObject, imports []JObject,
	type_decls []JObject) *JProgramFile

type JReferenceType

type JReferenceType struct {
	Name     *JTypeName
	TypeArgs []*JTypeArgument
	Dims     int
}

func NewJReferenceType

func NewJReferenceType(name *JTypeName, obj_args []JObject,
	dims int) *JReferenceType

type JSimpleStatement

type JSimpleStatement struct {
	Keyword *JKeyword
	Object  JObject
}

func NewJSimpleStatement

func NewJSimpleStatement(keyword *JKeyword, object JObject) *JSimpleStatement

type JSwitch

type JSwitch struct {
	Expr   JObject
	Groups []*JSwitchGroup
}

func NewJSwitch

func NewJSwitch(expr JObject, grouplist []JObject) *JSwitch

type JSwitchGroup

type JSwitchGroup struct {
	Labels []*JSwitchLabel
	Stmts  []JObject
}

func NewJSwitchGroup

func NewJSwitchGroup(labellist []JObject, stmtlist []JObject) *JSwitchGroup

type JSwitchLabel

type JSwitchLabel struct {
	Name      string
	Expr      JObject
	IsDefault bool
}

func NewJSwitchLabel

func NewJSwitchLabel(name string, expr JObject, is_default bool) *JSwitchLabel

type JSynchronized

type JSynchronized struct {
	Expr  JObject
	Block *JBlock
}

func NewJSynchronized

func NewJSynchronized(expr JObject, block *JBlock) *JSynchronized

type JTry

type JTry struct {
	Block   *JBlock
	Catches []*JCatch
	Finally *JBlock
}

func NewJTry

func NewJTry(block *JBlock, clist []JObject, finally *JBlock) *JTry

type JTypeArgument

type JTypeArgument struct {
	TypeSpec *JReferenceType
	Ts_type  int
}

func NewJTypeArgument

func NewJTypeArgument(typespec *JReferenceType, ts_type int) *JTypeArgument

type JTypeName

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

func NewJTypeName

func NewJTypeName(name string, is_primitive bool) *JTypeName

func (*JTypeName) Add

func (qn *JTypeName) Add(name string)

func (*JTypeName) FirstType

func (qn *JTypeName) FirstType() string

func (*JTypeName) IsDotted

func (qn *JTypeName) IsDotted() bool

func (*JTypeName) IsPrimitive

func (qn *JTypeName) IsPrimitive() bool

func (*JTypeName) LastType

func (qn *JTypeName) LastType() string

func (*JTypeName) NotFirst

func (qn *JTypeName) NotFirst() *JTypeName

func (*JTypeName) NotLast

func (qn *JTypeName) NotLast() *JTypeName

func (*JTypeName) PackageString

func (qn *JTypeName) PackageString() string

func (*JTypeName) String

func (qn *JTypeName) String() string

type JTypeParameter

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

func NewJTypeParameter

func NewJTypeParameter(name string, bounds []JObject) *JTypeParameter

type JUnaryExpr

type JUnaryExpr struct {
	Op  string
	Obj JObject
	// contains filtered or unexported fields
}

func NewJUnaryExpr

func NewJUnaryExpr(op string, obj JObject, is_prefix bool) *JUnaryExpr

type JUnimplemented

type JUnimplemented struct {
	TypeStr string
}

func NewJUnimplemented

func NewJUnimplemented(typestr string) *JUnimplemented

type JVariableDecl

type JVariableDecl struct {
	Modifiers *JModifiers
	TypeSpec  *JReferenceType
	Name      string
	Dims      int
	Init      *JVariableInit
}

func NewJVariableDecl

func NewJVariableDecl(name string, dims int,
	init *JVariableInit) *JVariableDecl

func (*JVariableDecl) SetInit

func (j *JVariableDecl) SetInit(init *JVariableInit)

func (*JVariableDecl) SetModifiers

func (j *JVariableDecl) SetModifiers(modifiers *JModifiers)

func (*JVariableDecl) SetType

func (j *JVariableDecl) SetType(typespec *JReferenceType)

type JVariableInit

type JVariableInit struct {
	Expr      JObject
	ArrayList []*JVariableInit
}

func NewJVariableInit

func NewJVariableInit(expr JObject, arraylist []*JVariableInit) *JVariableInit

type JWhile

type JWhile struct {
	Expr      JObject
	Stmt      JObject
	IsDoWhile bool
}

func NewJWhile

func NewJWhile(expr JObject, stmt JObject, is_do_while bool) *JWhile

type JulyLexer

type JulyLexer interface {
	Lex(lval *JulySymType) int
	Error(s string)
}

type JulySymType

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

type StringReader

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

func NewStringReader

func NewStringReader(str string) *StringReader

func (*StringReader) ReadByte

func (rdr *StringReader) ReadByte() (byte, error)

Jump to

Keyboard shortcuts

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