SPTools

package
v0.0.0-...-52ce1c6 Latest Latest
Warning

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

 Go to latest Published: Jan 2, 2023 License: MIT Imports: 10 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	IsPublic = StorageClassFlags(1 << iota)
	IsConst
	IsNative
	IsForward
	IsStatic
	IsStock
	IsPrivate
	IsProtected
	IsReadOnly
	IsSealed
	IsVirtual
	MaxStorageClasses
)
View Source 
const (
	SP_GENFLAG_NEWLINE   = 1 << iota
	SP_GENFLAG_SEMICOLON = 1 << iota
	SP_GENFLAG_ALL       = -1
)
View Source 
const (
	// continue execution.
	FLOW_EXC = ControlFlow(iota)

	// doing loop 'continue'.
	FLOW_CNT

	// doing return.
	FLOW_RET

	// breaking out of loop.
	FLOW_BRK
)
View Source 
const (
	IN_THEN = condInclCtx(iota)
	IN_ELIF
	IN_ELSE
)
View Source 
const (
	COLOR_RED     = "\x1B[31m" // used for errors.
	COLOR_GREEN   = "\x1B[32m"
	COLOR_YELLOW  = "\x1B[33m"
	COLOR_BLUE    = "\x1B[34m"
	COLOR_MAGENTA = "\x1B[35m" // used for warnings.
	COLOR_CYAN    = "\x1B[36m"
	COLOR_WHITE   = "\x1B[37m"
	COLOR_RESET   = "\033[0m" // used to reset the color.
)

colorful strings for printing.

View Source 
const (
	// Runs preprocessor.
	LEXFLAG_PREPROCESS = (1 << iota)

	// Self explanatory, strips out all comment tokens.
	LEXFLAG_STRIP_COMMENTS = (1 << iota)

	// Keeps newlines.
	LEXFLAG_NEWLINES = (1 << iota)

	// Adds #include <sourcemod> automatically.
	LEXFLAG_SM_INCLUDE = (1 << iota)

	// Enable ALL the above flags.
	LEXFLAG_ALL = -1
)
View Source 
const (
	TKEoF = TokenKind(iota)
	TKComment

	// used for preprocessor, removed afterwards.
	TKNewline
	TKSpace
	TKTab
	TKBackSlash
	TKHashTok
	TKMacroArg

	// literal values
	TKIdent
	TKIntLit
	TKFloatLit
	TKStrLit
	TKCharLit

	// keywords
	// acquire, any, as, assert
	TKAcquire
	TKAs
	TKAssert

	// break, builtin
	TKBreak
	TKBuiltin

	// catch, case, cast_to, char, const, continue
	TKCatch
	TKCase
	TKCastTo
	TKChar
	TKConst
	TKContinue

	// decl, default, defined, delete, do, double
	TKDecl
	TKDefault
	TKDefined
	TKDelete
	TKDo
	TKDouble

	// else, enum, exit, explicit
	TKElse
	TKEnum
	TKExit
	TKExplicit

	// false, finally, for, foreach, forward, funcenum, functag, function
	TKFalse
	TKFinally
	TKFor
	TKForEach
	TKForward
	TKFuncEnum
	TKFuncTag
	TKFunction

	// goto
	TKGoto

	// if, implicit, import, in, int[8|16|32|64], intn, interface
	TKIf
	TKImplicit
	TKImport
	TKIn
	TKInt
	TKInt8
	TKInt16
	TKInt32
	TKInt64
	TKIntN
	TKInterface

	// let
	TKLet

	// methodmap
	TKMethodMap

	// namespace, native, new, null, __nullable__
	TKNameSpace
	TKNative
	TKNew
	TKNull
	TKNullable

	// object, operator
	TKObject
	TKOperator

	// package, private, property, protected, public
	TKPackage
	TKPrivate
	TKProperty
	TKProtected
	TKPublic

	// readonly, return
	TKReadOnly
	TKReturn

	// sealed, sizeof, static, static_assert, stock, struct, switch
	TKSealed
	TKSizeof
	TKStatic
	TKStaticAssert
	TKStock
	TKStruct
	TKSwitch

	// this, throw, true, try, typedef, typeof, typeset
	TKThis
	TKThrow
	TKTrue
	TKTry
	TKTypedef
	TKTypeof
	TKTypeset

	// uint(8|16|32|64|n), union, using
	TKUInt8
	TKUInt16
	TKUInt32
	TKUInt64
	TKUnion
	TKUsing

	// var, variant, view_as, virtual, void, volatile
	TKVar
	TKVariant
	TKViewAs
	TKVirtual
	TKVoid
	TKVolatile

	// while, with
	TKWhile
	TKWith

	// preproc keywords
	// #assert #define #if #else #elseif #endif #endinput #endscript #error #warning #include #line #pragma #tryinclude #file #undef
	TKPPAssert
	TKPPDefine
	TKPPIf
	TKPPElse
	TKPPElseIf
	TKPPEndIf
	TKPPEndInput
	TKPPErr
	TKPPWarn
	TKPPInclude
	TKPPLine
	TKPPPragma
	TKPPTryInclude
	TKPPFile
	TKPPUndef

	// delimiters
	// ( ) [ ] { } , : ; #
	TKLParen
	TKRParen
	TKLBrack
	TKRBrack
	TKLCurl
	TKRCurl
	TKComma
	TKColon
	TKSemi
	TKHash

	// operators
	// + - * / % ! . .. ...
	TKAdd
	TKSub
	TKMul
	TKDiv
	TKMod
	TKNot
	TKDot
	TK2Dots
	TKEllipses

	// & | ^ ~ << >> >>>
	TKAnd
	TKAndNot // &~ SPTools extension
	TKOr
	TKXor
	TKCompl
	TKShAL
	TKShAR
	TKShLR

	// < > >= <= != == && ||
	TKLess
	TKGreater
	TKGreaterE
	TKLessE
	TKNotEq
	TKEq
	TKAndL
	TKOrL

	// = += -= *= /= %= &= |= ^= <<= >>= >>>=
	TKAssign
	TKAddA
	TKSubA
	TKMulA
	TKDivA
	TKModA
	TKAndA
	TKAndNotA // &~= SPTools extension
	TKOrA
	TKXorA
	TKShALA
	TKShARA
	TKShLRA

	// ++ -- :: ?
	TKIncr
	TKDecr
	TK2Colons
	TKQMark

	TKMaxTokens
)
View Source 
const (
	TOKFLAG_IGNORE_NEWLINE = (1 << iota)
	TOKFLAG_IGNORE_TAB     = (1 << iota)
	TOKFLAG_IGNORE_SPACE   = (1 << iota)
	TOKFLAG_IGNORE_COMMENT = (1 << iota)
	TOKFLAG_IGNORE_ALL     = -1
)
View Source 
const (
	TYPE_VOID = BaseType(iota)
	TYPE_HANDLE
	TYPE_BOOL
	TYPE_INT
	TYPE_CHAR
	TYPE_FLOAT
	TYPE_ANY
)
View Source 
const DigitSep = '_'

DigitSep is used when lexing the various numeric literals SourcePawn can support such as hexadecimal, octal, binary, & decimal.

View Source 
const ERR_LIMIT = 5

Variables

View Source 
var (
	PreprocOne  = Token{Lexeme: "1", Path: nil, Span: MakeSpan(0, 0, 0, 0), Kind: TKIntLit}
	PreprocZero = Token{Lexeme: "0", Path: nil, Span: MakeSpan(0, 0, 0, 0), Kind: TKIntLit}
)
View Source 
var (
	Keywords = map[string]TokenKind{}/* 102 elements not displayed */

	Opers = map[string]TokenKind{
		"(":    TKLParen,
		")":    TKRParen,
		"[":    TKLBrack,
		"]":    TKRBrack,
		"{":    TKLCurl,
		"}":    TKRCurl,
		",":    TKComma,
		":":    TKColon,
		";":    TKSemi,
		"#":    TKHash,
		"+":    TKAdd,
		"-":    TKSub,
		"*":    TKMul,
		"/":    TKDiv,
		"%":    TKMod,
		"!":    TKNot,
		".":    TKDot,
		"..":   TK2Dots,
		"...":  TKEllipses,
		"&":    TKAnd,
		"&~":   TKAndNot,
		"|":    TKOr,
		"^":    TKXor,
		"~":    TKCompl,
		"<<":   TKShAL,
		">>":   TKShAR,
		">>>":  TKShLR,
		"<":    TKLess,
		">":    TKGreater,
		">=":   TKGreaterE,
		"<=":   TKLessE,
		"!=":   TKNotEq,
		"==":   TKEq,
		"&&":   TKAndL,
		"||":   TKOrL,
		"=":    TKAssign,
		"+=":   TKAddA,
		"-=":   TKSubA,
		"*=":   TKMulA,
		"/=":   TKDivA,
		"%=":   TKModA,
		"&=":   TKAndA,
		"&~=":  TKAndNotA,
		"|=":   TKOrA,
		"^=":   TKXorA,
		"<<=":  TKShALA,
		">>=":  TKShARA,
		">>>=": TKShLRA,
		"++":   TKIncr,
		"--":   TKDecr,
		"::":   TK2Colons,
		"?":    TKQMark,
	}
	TokenToStr = [...]string{}/* 165 elements not displayed */

)
View Source 
var LitKindToStr = [...]string{
	IntLit:    "int literal",
	FloatLit:  "float literal",
	CharLit:   "char literal",
	StringLit: "string literal",
	BoolLit:   "bool literal",
}
View Source 
var StorageClassToString = [...]string{
	IsPublic:    "public",
	IsConst:     "const",
	IsNative:    "native",
	IsForward:   "forward",
	IsStatic:    "static",
	IsStock:     "stock",
	IsPrivate:   "private",
	IsProtected: "protected",
	IsReadOnly:  "readonly",
	IsSealed:    "sealed",
	IsVirtual:   "virtual",
}

Functions

func AreSameType 

func AreSameType[T any](a, b any) bool

func AreTypeAndValCoercible 

func AreTypeAndValCoercible(a, b TypeAndVal) bool

* 1. Two expressions are convertible when their reduced forms are the same. E.g 2 + 2 is convertible to 4 * 2. Two expressions are coercible when you can safely cast one to the other. E.g 22 : int32 might be coercible to 22 : int64

func AreTypesCoercible 

func AreTypesCoercible(a, b Type) bool

* 1. Two expressions are convertible when their reduced forms are the same. E.g 2 + 2 is convertible to 4 * 2. Two expressions are coercible when you can safely cast one to the other. E.g 22 : int32 might be coercible to 22 : int64

func AstToString 

func AstToString(n Node) string

func DeclToString 

func DeclToString(e Decl) string

func ExprToString 

func ExprToString(e Expr) string

func GetBinaryTypes 

func GetBinaryTypes[T any](a, b any) (T, T)

for binary operations. please make sure they're both the same type by using 'AreSameType'.

func GetTypeAndValName 

func GetTypeAndValName(a TypeAndVal) string

func GetTypeName 

func GetTypeName(a Type) string

func IsArithmeticType 

func IsArithmeticType(a Type) bool

func IsArithmeticTypeAndVal 

func IsArithmeticTypeAndVal(a TypeAndVal) bool

func IsBaseType 

func IsBaseType(a Type) bool

func IsBaseTypeOfType 

func IsBaseTypeOfType(a Type, bt ...BaseType) bool

func IsDeclNode 

func IsDeclNode(n Node) bool

func IsExactType 

func IsExactType[T any](a any) bool

func IsExprNode 

func IsExprNode(n Node) bool

func IsPluginNode 

func IsPluginNode(n Node) bool

func IsSpecNode 

func IsSpecNode(n Node) bool

func IsStmtNode 

func IsStmtNode(n Node) bool

func PluginToString 

func PluginToString(e Node) string

func PrintNode 

func PrintNode(n Node, tabs int, w io.Writer)

func SpecToString 

func SpecToString(e Spec) string

func SpewReport 

func SpewReport(w io.Writer, message string, msg_cnt *uint32)

func StmtToString 

func StmtToString(e Stmt) string

func Ternary 

func Ternary[T any](cond bool, a, b T) T

func Walk 

func Walk(n, parent Node, visitor func(n, parent Node) bool)

Types

type ArrayType 

type ArrayType struct {
	ElemType Type
	Len      int
	Dynamic  bool
}

type ArrayTypeAndVal 

type ArrayTypeAndVal struct {
	Elems   []TypeAndVal
	Dynamic bool // dynamically stack allocated.
	// contains filtered or unexported fields
}

type AssertStmt 

type AssertStmt struct {
	X Expr
	// contains filtered or unexported fields
}

assert a;

type BadDecl 

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

Declarations here.

type BadExpr 

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

func (*BadExpr) Tag 

func (e *BadExpr) Tag() Type

type BadSpec 

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

Specifications here. Spec represents a constant or type definition.

type BadStmt 

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

statement nodes here. Statement syntax write here.

type BaseType 

type BaseType uint8

type BasicLit 

type BasicLit struct {
	Value string
	Kind  LitKind
	// contains filtered or unexported fields
}

1, 1.0, '1', "1"

func (*BasicLit) Tag 

func (e *BasicLit) Tag() Type

type BinExpr 

type BinExpr struct {
	L, R Expr
	Kind TokenKind
	// contains filtered or unexported fields
}

a # b

func (*BinExpr) Tag 

func (e *BinExpr) Tag() Type

type BlockStmt 

type BlockStmt struct {
	Stmts []Stmt
	// contains filtered or unexported fields
}

{ *Stmts }

type BracketExpr 

type BracketExpr struct {
	Exprs []Expr
	// contains filtered or unexported fields
}

{ a, b, c }

func (*BracketExpr) Tag 

func (e *BracketExpr) Tag() Type

type CallExpr 

type CallExpr struct {
	ArgList []Expr // nil means no arguments
	Func    Expr
	// contains filtered or unexported fields
}

f(a,b,...z)

func (*CallExpr) Tag 

func (e *CallExpr) Tag() Type

type CaseStmt 

type CaseStmt struct {
	Case Expr // single or comma expression.
	Body Stmt
	// contains filtered or unexported fields
}

case a[, b, ...z]:

type ChainExpr 

type ChainExpr struct {
	A     Expr
	Bs    []Expr
	Kinds []TokenKind
	// contains filtered or unexported fields
}

a # b [ # c ... z ]

func (*ChainExpr) Tag 

func (e *ChainExpr) Tag() Type

type CharTypeAndVal 

type CharTypeAndVal struct {
	Value byte
	// contains filtered or unexported fields
}

func ConvertToChar 

func ConvertToChar(a TypeAndVal) (CharTypeAndVal, bool)

type CommaExpr 

type CommaExpr struct {
	Exprs []Expr
	// contains filtered or unexported fields
}

a,b,c

func (*CommaExpr) Tag 

func (e *CommaExpr) Tag() Type

type ControlFlow 

type ControlFlow int8

type Decl 

type Decl interface {
	Node
	// contains filtered or unexported methods
}

Declarations here.

type DeclStmt 

type DeclStmt struct {
	D Decl // VarSpec, TypeDecl, or FuncDecl
	// contains filtered or unexported fields
}

Type i;

type DeleteStmt 

type DeleteStmt struct {
	X Expr
	// contains filtered or unexported fields
}

statement nodes here. Statement syntax write here.

type EllipsesExpr 

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

...

func (*EllipsesExpr) Tag 

func (e *EllipsesExpr) Tag() Type

type EnumSpec 

type EnumSpec struct {
	Ident  Expr // can be nil.
	Step   Expr // can be nil.
	StepOp TokenKind
	Names  []Expr
	Values []Expr
	// contains filtered or unexported fields
}

enum Name { ... } enum { ... } enum ( op= i ) { ... }

type Expr 

type Expr interface {
	Node

	Tag() Type
	// contains filtered or unexported methods
}

func ParseExpression 

func ParseExpression(code string, flags int, macros map[string]Macro, old bool) Expr

type ExprStmt 

type ExprStmt struct {
	X Expr
	// contains filtered or unexported fields
}

expr ';'

type FieldExpr 

type FieldExpr struct {
	X, Sel Expr
	// contains filtered or unexported fields
}

id.name

func (*FieldExpr) Tag 

func (e *FieldExpr) Tag() Type

type FloatTypeAndVal 

type FloatTypeAndVal struct {
	Value float32
	// contains filtered or unexported fields
}

func ConvertToFloat 

func ConvertToFloat(a TypeAndVal) (FloatTypeAndVal, bool)

type FlowStmt 

type FlowStmt struct {
	Kind TokenKind
	// contains filtered or unexported fields
}

break, continue

type ForStmt 

type ForStmt struct {
	Init       Node
	Cond, Post Expr
	Body       Stmt
	// contains filtered or unexported fields
}

for [init] ; [cond] ; [post] body

type FuncDecl 

type FuncDecl struct {
	RetType    Spec // *TypeSpec
	Ident      Expr
	Params     []Decl // []*VarDecl, *BadDecl if error.
	Body       Node   // Expr if alias, Stmt if body, nil if ';'.
	ClassFlags StorageClassFlags
	// contains filtered or unexported fields
}

class type name() {} class type name(); class type name1() = name2;

type FuncLit 

type FuncLit struct {
	Sig  Spec // *SignatureSpec
	Body Stmt // *BlockStmt
	// contains filtered or unexported fields
}

function type (args) {}

func (*FuncLit) Tag 

func (e *FuncLit) Tag() Type

type FuncType 

type FuncType struct {
	Params  map[*Name]Type
	RetType Type
}

type FuncTypeAndVal 

type FuncTypeAndVal struct {
	Params   map[string]TypeAndVal // empty/nill if no params.
	Ret      TypeAndVal            // nil == 'void'
	Variadic bool
	// contains filtered or unexported fields
}

type HandleTypeAndVal 

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

type IfStmt 

type IfStmt struct {
	Cond       Expr
	Then, Else Stmt
	// contains filtered or unexported fields
}

if cond body [else/else if body]

type IndexExpr 

type IndexExpr struct {
	X, Index Expr
	// contains filtered or unexported fields
}

a[i]

func (*IndexExpr) Tag 

func (e *IndexExpr) Tag() Type

type IntTypeAndVal 

type IntTypeAndVal struct {
	Value int32
	// contains filtered or unexported fields
}

also used as the `any` type.

func ConvertToInt 

func ConvertToInt(a TypeAndVal) (IntTypeAndVal, bool)

type Interp 

type Interp struct {
	MsgSpan
	Syms, Types map[string]TypeAndVal
}

func MakeInterpreter 

func MakeInterpreter(p Parser) Interp

func (Interp) DoMessage 

func (interp Interp) DoMessage(n Node, msgtype, color, msg string, args ...any) string

func (Interp) EvalExpr 

func (interp Interp) EvalExpr(e Expr) TypeAndVal

func (Interp) EvalStmt 

func (interp Interp) EvalStmt(s Stmt, flow *ControlFlow) TypeAndVal

type LitKind 

type LitKind uint8

expression nodes here. Expression syntax write here. 

const (
	IntLit LitKind = iota
	BoolLit
	FloatLit
	CharLit
	StringLit
)

type Macro 

type Macro struct {
	Iden     Token
	Params   map[string]int
	Body     []Token
	FuncLike bool
}

func MakeFuncMacro 

func MakeFuncMacro(tr *TokenReader) (Macro, bool)

func MakeObjMacro 

func MakeObjMacro(tr *TokenReader) Macro

func (Macro) Apply 

func (m Macro) Apply(tr *TokenReader) ([]Token, bool)

type MethodMapMethodSpec 

type MethodMapMethodSpec struct {
	Impl   Decl
	IsCtor bool
	// contains filtered or unexported fields
}

public Type name(params) {} public native Type name(params);

type MethodMapPropSpec 

type MethodMapPropSpec struct {
	Type, Ident              Expr
	SetterParams             []Decl
	GetterBlock, SetterBlock Stmt
	GetterClass, SetterClass StorageClassFlags
	// contains filtered or unexported fields
}
 property Type name {
	 *    public get() {}
	 *    public set(Type param) {}
	 *
	 *    public native get();
	 *    public native set(Type param);
	 * }

type MethodMapSpec 

type MethodMapSpec struct {
	Ident    Expr
	Parent   Expr   // TypeExpr
	Props    []Spec // []*MethodMapPropSpec
	Methods  []Spec // []*MethodMapMethodSpec
	Nullable bool
	// contains filtered or unexported fields
}

methodmap Name [< type] { ... };

type MsgSpan 

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

func MakeMsgSpan 

func MakeMsgSpan(lines *[]string) MsgSpan

func (*MsgSpan) PrepNote 

func (m *MsgSpan) PrepNote(span Span, note_fmt string, args ...any)

func (*MsgSpan) PurgeNotes 

func (m *MsgSpan) PurgeNotes()

func (*MsgSpan) Report 

func (m *MsgSpan) Report(msgtype, errcode, color, msg_fmt, filename string, line, col *uint16, args ...any) string

type Name 

type Name struct {
	Value string
	// contains filtered or unexported fields
}

i

func (*Name) Tag 

func (e *Name) Tag() Type

type NameSpaceExpr 

type NameSpaceExpr struct {
	N, Id Expr
	// contains filtered or unexported fields
}

name::id

func (*NameSpaceExpr) Tag 

func (e *NameSpaceExpr) Tag() Type

type NamedArg 

type NamedArg struct {
	X Expr
	// contains filtered or unexported fields
}

.a = expr

func (*NamedArg) Tag 

func (e *NamedArg) Tag() Type

type Node 

type Node interface {
	// line & col.
	Tok() Token
	Span() Span
	// contains filtered or unexported methods
}

func ParseFile 

func ParseFile(filename string, flags int, macros map[string]Macro, old bool) Node

func ParseString 

func ParseString(code string, flags int, macros map[string]Macro, old bool) Node

func ParseTokens 

func ParseTokens(tr *TokenReader, old bool) Node

type NullExpr 

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

null

func (*NullExpr) Tag 

func (e *NullExpr) Tag() Type

type Parser 

type Parser struct {
	*TokenReader
	Errs []string
}

func MakeParser 

func MakeParser(tr *TokenReader) Parser

func (*Parser) AbstractDecl 

func (parser *Parser) AbstractDecl() Spec

AbstractDecl = Type [ *'[]' | '&' ] .

func (*Parser) AddExpr 

func (parser *Parser) AddExpr() Expr

AddExpr = MulExpr *( ( '+' | '-' ) MulExpr ) .

func (*Parser) Advance 

func (parser *Parser) Advance(i int) Token

func (*Parser) AssignExpr 

func (parser *Parser) AssignExpr() Expr

AssignExpr = SubMainExpr *( '['+' | '-' | '*' | '/' | '%' | '&' | '&~' | '|' | '^' | '<<' | '>>' | '>>>' ] =' SubMainExpr ) .

func (*Parser) BitAndExpr 

func (parser *Parser) BitAndExpr() Expr

BitAndExpr = ShiftExpr *( ('&' | '&~') ShiftExpr ) .

func (*Parser) BitOrExpr 

func (parser *Parser) BitOrExpr() Expr

BitOrExpr = BitXorExpr *( '|' BitXorExpr ) .

func (*Parser) BitXorExpr 

func (parser *Parser) BitXorExpr() Expr

BitXorExpr = BitAndExpr *( '^' BitAndExpr ) .

func (*Parser) DoBlock 

func (parser *Parser) DoBlock() Stmt

BlockStmt = '{' *Statement '}' .

func (*Parser) DoEnumSpec 

func (parser *Parser) DoEnumSpec() Spec

EnumSpec = 'enum' [ ident [ ':' ] '(' operator PrimaryExpr ')' ] '{' +EnumEntry '}' [ ';' ] . EnumEntry = Ident [ '=' Expr ] .

func (*Parser) DoFor 

func (parser *Parser) DoFor() Stmt

ForStmt = 'for' '(' [ Decl | Expr ] ';' [ Expr ] ';' [ Expr ] ')' Statement .

func (*Parser) DoFuncDeclarator 

func (parser *Parser) DoFuncDeclarator(fdecl *FuncDecl)

FuncSpec = Ident ParamList ( Initializer | Block | ';' ) .

func (*Parser) DoFuncSignature 

func (parser *Parser) DoFuncSignature() Spec

SignatureSpec = 'function' AbstractDecl ParamsList .

func (*Parser) DoIf 

func (parser *Parser) DoIf() Stmt

IfStmt = 'if' '(' Expr ')' Statement [ 'else' Statement ] .

func (*Parser) DoMethodMap 

func (parser *Parser) DoMethodMap() Spec

MethodMapSpec = 'methodmap' Ident [ '__nullable__' ] [ '<' TypeExpr ] '{' [ MethodCtor ] *MethodMapEntry '}' [ ';' ] . MethodCtor = 'public' Ident ParamList ( Block | ';' ) . MethodMapEntry = MethodMapProp | FuncDecl . MethodMapProp = 'property' TypeExpr Ident '{' PropGetter [ PropSetter ] | PropSetter '}' . PropGetter = 'public' [ 'native' ] 'get' '(' ')' ( Block | ';' ) . PropSetter = 'public' [ 'native' ] 'set' ParamList ( Block | ';' ) .

func (*Parser) DoMethodMapProperty 

func (parser *Parser) DoMethodMapProperty(prop *MethodMapPropSpec) *BadSpec

func (*Parser) DoOldBlock 

func (parser *Parser) DoOldBlock() Stmt

OldBlockStmt = '{' *OldStatement '}' .

func (*Parser) DoOldFor 

func (parser *Parser) DoOldFor() Stmt

OldForStmt = 'for' '(' [ OldDecl | OldExpr ] ';' [ OldExpr ] ';' [ OldExpr ] ')' OldStatement .

func (*Parser) DoOldIf 

func (parser *Parser) DoOldIf() Stmt

IfStmt = 'if' '(' Expr ')' OldStatement [ 'else' OldStatement ] .

func (*Parser) DoOldTernary 

func (parser *Parser) DoOldTernary(a Expr) Expr

OldTernaryExpr = '?' OldSubMainExpr ':' Expr .

func (*Parser) DoParamList 

func (parser *Parser) DoParamList() []Decl

ParamList = '(' *VarDecl ')' .

func (*Parser) DoStruct 

func (parser *Parser) DoStruct(is_enum bool) Spec

StructSpec = 'struct' Ident '{' *Field '}' [ ';' ] . Field = VarDecl ';' | FuncDecl .

func (*Parser) DoTernary 

func (parser *Parser) DoTernary(a Expr) Expr

TernaryExpr = '?' SubMainExpr ':' Expr .

func (*Parser) DoTypeSet 

func (parser *Parser) DoTypeSet() Spec

TypeSetSpec = 'typeset' Ident '{' *( SignatureSpec ';' ) '}' [ ';' ] .

func (*Parser) DoTypedef 

func (parser *Parser) DoTypedef() Spec

TypeDefSpec = 'typedef' Ident '=' SignatureSpec ';' .

func (*Parser) DoUsingSpec 

func (parser *Parser) DoUsingSpec() Spec

UsingSpec = 'using' Expr ';' .

func (*Parser) DoVarDeclarator 

func (parser *Parser) DoVarDeclarator(vdecl *VarDecl, param bool)

VarDeclarator = Ident [ IndexExpr ] [ Initializer ] *( ',' VarDeclarator ) . Initializer = '=' SubMainExpr | '{' Expr [ ',' ( '...' | *Expr ) ] '}' .

func (*Parser) DoVarOrFuncDecl 

func (parser *Parser) DoVarOrFuncDecl(param bool) Decl

VarDecl = VarOrFuncSpec VarDeclarator . FuncDecl = VarOrFuncSpec FuncDeclarator .

func (*Parser) EqualExpr 

func (parser *Parser) EqualExpr() Expr

EqualExpr = RelExpr *( ( '==' | '!=' ) RelExpr ) .

func (*Parser) ExprList 

func (parser *Parser) ExprList(end, sep TokenKind, sep_at_end bool) []Expr

NamedArgExpr = '.' AssignExpr . ExprList = START ListedExpr *( SEP ListedExpr ) END . ListedExpr = NamedArgExpr | AssignExpr .

func (*Parser) GetToken 

func (parser *Parser) GetToken(offset int) Token

func (*Parser) HasTokenKindSeq 

func (parser *Parser) HasTokenKindSeq(kinds ...TokenKind) bool

func (*Parser) LogicalAndExpr 

func (parser *Parser) LogicalAndExpr() Expr

LogicalAndExpr = EqualExpr *( '&&' EqualExpr ) .

func (*Parser) LogicalOrExpr 

func (parser *Parser) LogicalOrExpr() Expr

LogicalOrExpr = LogicalAndExpr *( '||' LogicalAndExpr ) .

func (*Parser) MainExpr 

func (parser *Parser) MainExpr() Expr

Expr = AssignExpr *( ',' AssignExpr ) .

func (*Parser) MulExpr 

func (parser *Parser) MulExpr() Expr

MulExpr = PrefixExpr *( ( '*' | '/' | '%' ) PrefixExpr ) .

func (*Parser) OldAddExpr 

func (parser *Parser) OldAddExpr() Expr

OldAddExpr = OldMulExpr *( ( '+' | '-' ) OldMulExpr ) .

func (*Parser) OldAssignExpr 

func (parser *Parser) OldAssignExpr() Expr

OldAssignExpr = OldSubMainExpr *( '['+' | '-' | '*' | '/' | '%' | '&' | '|' | '^' | '<<' | '>>' | '>>>' ] =' OldSubMainExpr ) .

func (*Parser) OldBitAndExpr 

func (parser *Parser) OldBitAndExpr() Expr

OldBitAndExpr = OldShiftExpr *( '&' OldShiftExpr ) .

func (*Parser) OldBitOrExpr 

func (parser *Parser) OldBitOrExpr() Expr

OldBitOrExpr = OldBitXorExpr *( '|' OldBitXorExpr ) .

func (*Parser) OldBitXorExpr 

func (parser *Parser) OldBitXorExpr() Expr

OldBitXorExpr = OldBitAndExpr *( '^' OldBitAndExpr ) .

func (*Parser) OldEqualExpr 

func (parser *Parser) OldEqualExpr() Expr

OldEqualExpr = OldRelExpr *( ( '==' | '!=' ) OldRelExpr ) .

func (*Parser) OldExprList 

func (parser *Parser) OldExprList(end, sep TokenKind, sep_at_end bool) []Expr

OldNamedArgExpr = '.' OldAssignExpr . OldExprList = START OldListedExpr *( SEP OldListedExpr ) END . OldListedExpr = NamedArgExpr | OldAssignExpr .

func (*Parser) OldLogicalAndExpr 

func (parser *Parser) OldLogicalAndExpr() Expr

OldLogicalAndExpr = OldEqualExpr *( '&&' OldEqualExpr ) .

func (*Parser) OldLogicalOrExpr 

func (parser *Parser) OldLogicalOrExpr() Expr

OldLogicalOrExpr = OldLogicalAndExpr *( '||' OldLogicalAndExpr ) .

func (*Parser) OldMainExpr 

func (parser *Parser) OldMainExpr() Expr

********************************************************************************* 

Start Expressions

********************************************************************************* OldExpr = OldAssignExpr *( ',' OldAssignExpr ) .

func (*Parser) OldMulExpr 

func (parser *Parser) OldMulExpr() Expr

OldMulExpr = OldPrefixExpr *( ( '*' | '/' | '%' ) OldPrefixExpr ) .

func (*Parser) OldPostfixExpr 

func (parser *Parser) OldPostfixExpr() Expr

OldPostfixExpr = OldPrimaryExpr *( ':' OldPrefixExpr | '[' Expr ']' | '(' [ OldExprList ] ')' | '++' | '--' ) .

func (*Parser) OldPrefixExpr 

func (parser *Parser) OldPrefixExpr() Expr

OldPrefixExpr = *( '!' | '~' | '-' | '++' | '--' | 'sizeof' | 'defined' ) OldPostfixExpr .

func (*Parser) OldPrimaryExpr 

func (parser *Parser) OldPrimaryExpr() Expr

BoolLit = 'true' | 'false' . BasicLit = int_lit | rune_lit | string_lit . OldPrimary = BasicLit | identifier | 'operator' op | BoolLit | '...' | '(' Expr ')' | '{' OldExprList '}' .

func (*Parser) OldRelExpr 

func (parser *Parser) OldRelExpr() Expr

OldRelExpr = OldBitOrExpr *( ( '<[=]' | '>[=]' ) OldBitOrExpr ) .

func (*Parser) OldShiftExpr 

func (parser *Parser) OldShiftExpr() Expr

OldShiftExpr = OldAddExpr *( ( '<<' | '>>' | '>>>' ) OldAddExpr ) .

func (*Parser) OldStart 

func (parser *Parser) OldStart() Node

func (*Parser) OldStatement 

func (parser *Parser) OldStatement() Stmt

* OldStatement = OldIfStmt | OldWhileStmt | OldForStmt | OldSwitchStmt | OldBlockStmt | * OldRetStmt | OldAssertStmt | OldDeclStmt | OldExprStmt .

func (*Parser) OldSubMainExpr 

func (parser *Parser) OldSubMainExpr() Expr

OldSubMainExpr = OldLogicalOrExpr [ TernaryExpr ] .

func (*Parser) OldSwitch 

func (parser *Parser) OldSwitch() Stmt

OldSwitchStmt = 'switch' '(' OldExpr ')' '{' *OldCaseClause '}' . OldCaseClause = 'case' OldExprList ':' OldStatement | 'default' ':' OldStatement .

func (*Parser) OldTypeExpr 

func (parser *Parser) OldTypeExpr() Expr

OldTypeExpr = ident | 'Float' | 'String' | 'bool' .

func (*Parser) OldWhile 

func (parser *Parser) OldWhile(t Token) Stmt

DoStmt = 'do' OldStatement 'while' '(' Expr ')' ';' . WhileStmt = 'while' '(' Expr ')' OldStatement .

func (*Parser) PostfixExpr 

func (parser *Parser) PostfixExpr() Expr

PostfixExpr = Primary *( '.' identifier | '[' Expr ']' | '(' [ ExprList ] ')' | '::' identifier | '++' | '--' ) .

func (*Parser) PrefixExpr 

func (parser *Parser) PrefixExpr() Expr

PrefixExpr = *( '!' | '~' | '-' | '++' | '--' | 'sizeof' | 'new' ) PostfixExpr .

func (*Parser) PrimaryExpr 

func (parser *Parser) PrimaryExpr() Expr

BoolLit = 'true' | 'false' . BasicLit = int_lit | rune_lit | string_lit . BracketExpr = '{' ExprList '}' . Primary = BasicLit | identifier | 'operator' op | BoolLit | 'this' | 'null' | '...' | '(' Expr ')' | BracketExpr .

func (*Parser) RelExpr 

func (parser *Parser) RelExpr() Expr

RelExpr = BitOrExpr *( ( '<[=]' | '>[=]' ) BitOrExpr ) .

func (*Parser) ReportErrs 

func (parser *Parser) ReportErrs() bool

func (*Parser) ShiftExpr 

func (parser *Parser) ShiftExpr() Expr

ShiftExpr = AddExpr *( ( '<<' | '>>' | '>>>' ) AddExpr ) .

func (*Parser) Start 

func (parser *Parser) Start() Node

func (*Parser) Statement 

func (parser *Parser) Statement() Stmt

* Statement = IfStmt | WhileStmt | ForStmt | SwitchStmt | BlockStmt | * RetStmt | AssertStmt | StaticAssertStmt | DeclStmt | DeleteStmt | ExprStmt .

func (*Parser) StorageClass 

func (parser *Parser) StorageClass() StorageClassFlags

StorageClass = 'native' | 'forward' | 'const' | 'static' | 'stock' | 'public' | 'private' | 'protected' | 'readonly' | 'sealed' | 'virtual' .

func (*Parser) SubMainExpr 

func (parser *Parser) SubMainExpr() Expr

SubMainExpr = LogicalOrExpr [ TernaryExpr ] .

func (*Parser) Switch 

func (parser *Parser) Switch() Stmt

SwitchStmt = 'switch' '(' Expr ')' '{' *CaseClause '}' . CaseClause = 'case' ExprList ':' Statement | 'default' ':' Statement .

func (*Parser) TopDecl 

func (parser *Parser) TopDecl() Node

Plugin = +TopDecl . TopDecl = FuncDecl | TypeDecl | VarDecl | StaticAssertion .

func (*Parser) TypeExpr 

func (parser *Parser) TypeExpr(need_carots bool) Expr

TypeExpr = '<' ( ident | '[u]int[8|16|32|64|n]' | 'float' | 'char' | 'bool' ) '>' .

func (*Parser) VarOrFuncSpec 

func (parser *Parser) VarOrFuncSpec() (StorageClassFlags, Spec)

VarOrFuncSpec = *StorageClass AbstractDecl .

func (*Parser) ViewAsExpr 

func (parser *Parser) ViewAsExpr() Expr

ViewAsExpr = TypeExpr '(' MainExpr ')' .

func (*Parser) While 

func (parser *Parser) While(t Token) Stmt

DoStmt = 'do' Statement 'while' '(' Expr ')' ';' . WhileStmt = 'while' '(' Expr ')' Statement .

type Plugin 

type Plugin struct {
	Decls []Decl
	// contains filtered or unexported fields
}

top-level plugin.

func (*Plugin) Span 

func (n *Plugin) Span() Span

func (*Plugin) Tok 

func (n *Plugin) Tok() Token

type RefType 

type RefType struct {
	Base BaseType
}

type RefTypeAndVal 

type RefTypeAndVal struct {
	Ref TypeAndVal
	// contains filtered or unexported fields
}

type RetStmt 

type RetStmt struct {
	X Expr
	// contains filtered or unexported fields
}

return i; return;

type Scanner 

type Scanner struct {
	MsgSpan
	// contains filtered or unexported fields
}

func (*Scanner) Advance 

func (s *Scanner) Advance(i int)

func (Scanner) Col 

func (s Scanner) Col() uint16

func (Scanner) HasRuneSeq 

func (s Scanner) HasRuneSeq(runes ...rune) bool

func (*Scanner) LexBinary 

func (s *Scanner) LexBinary() (string, bool)

func (*Scanner) LexDecimal 

func (s *Scanner) LexDecimal() (string, bool, bool)

returns the lexeme, result, and if it's a float.

func (*Scanner) LexFloat 

func (s *Scanner) LexFloat(starter int, has_num bool) (string, bool, bool)

func (*Scanner) LexHex 

func (s *Scanner) LexHex() (string, bool)

func (*Scanner) LexOctal 

func (s *Scanner) LexOctal() (string, bool)

func (*Scanner) LexString 

func (s *Scanner) LexString(quote rune) (Token, bool)

func (Scanner) Line 

func (s Scanner) Line() uint16

func (Scanner) NumMsgs 

func (s Scanner) NumMsgs() uint32

func (Scanner) Read 

func (s Scanner) Read(i int) rune

func (*Scanner) SkipSpace 

func (s *Scanner) SkipSpace()

type Scope 

type Scope struct {
	MsgSpan
	Syms   map[*Name]Decl
	Parent *Scope
}

func MakeScope 

func MakeScope(ms MsgSpan, parent *Scope) *Scope

func (*Scope) CollectFuncAndTypeNames 

func (s *Scope) CollectFuncAndTypeNames(n Node)

func (*Scope) DoMessage 

func (s *Scope) DoMessage(n Node, msgtype, color, msg string, args ...any) string

func (*Scope) FindSym 

func (s *Scope) FindSym(name *Name) Decl

func (*Scope) VisitDecl 

func (s *Scope) VisitDecl(d Decl)

func (*Scope) VisitExpr 

func (s *Scope) VisitExpr(e Expr)

func (*Scope) VisitStmt 

func (s *Scope) VisitStmt(s Stmt)

type SignatureSpec 

type SignatureSpec struct {
	Type   Spec
	Params []Decl // array of []*VarDecl, *BadDecl if error.
	// contains filtered or unexported fields
}

function type params;

type Span 

type Span struct {
	LineStart, ColStart, LineEnd, ColEnd uint16
}

func MakeSpan 

func MakeSpan(line_start, col_start, line_end, col_end uint16) Span

func (Span) AdjustLines 

func (a Span) AdjustLines(b Span) Span

type Spec 

type Spec interface {
	Node
	// contains filtered or unexported methods
}

Specifications here. Spec represents a constant or type definition.

type StaticAssert 

type StaticAssert struct {
	A, B Expr
	// contains filtered or unexported fields
}

Declarations here.

type StaticAssertStmt 

type StaticAssertStmt struct {
	A Decl
	// contains filtered or unexported fields
}

static_assert(a, b);

type Stmt 

type Stmt interface {
	Node
	// contains filtered or unexported methods
}

statement nodes here. Statement syntax write here.

func ParseStatement 

func ParseStatement(code string, flags int, macros map[string]Macro, old bool) Stmt

type StorageClassFlags 

type StorageClassFlags uint16

func (StorageClassFlags) String 

func (sc StorageClassFlags) String() string

type StructSpec 

type StructSpec struct {
	Ident   Expr
	IsEnum  bool
	Fields  []Decl // []*VarDecl
	Methods []Decl // []*FuncDecl
	// contains filtered or unexported fields
}

struct Name { ... } enum struct Name { ... }

type SwitchStmt 

type SwitchStmt struct {
	Cases   []Stmt
	Default Stmt
	Cond    Expr
	// contains filtered or unexported fields
}

switch cond body

type TernaryExpr 

type TernaryExpr struct {
	A, B, C Expr
	// contains filtered or unexported fields
}

a? b : c

func (*TernaryExpr) Tag 

func (e *TernaryExpr) Tag() Type

type ThisExpr 

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

this.a

func (*ThisExpr) Tag 

func (e *ThisExpr) Tag() Type

type Token 

type Token struct {
	Span
	Lexeme string
	Path   *string
	Kind   TokenKind
}

func (Token) IsDelimiter 

func (tok Token) IsDelimiter() bool

func (Token) IsKeyword 

func (tok Token) IsKeyword() bool

func (Token) IsLiteral 

func (tok Token) IsLiteral() bool

func (Token) IsOperator 

func (tok Token) IsOperator() bool

func (Token) IsPreprocDirective 

func (tok Token) IsPreprocDirective() bool

func (Token) IsStorageClass 

func (tok Token) IsStorageClass() bool

func (Token) IsType 

func (tok Token) IsType() bool

func (Token) KindToString 

func (tok Token) KindToString() string

func (Token) String 

func (tok Token) String() string

returns either the lexeme or operator string.

func (Token) ToString 

func (tok Token) ToString() string

type TokenKind 

type TokenKind uint16

Represents a token's kind/class.

type TokenReader 

type TokenReader struct {
	MsgSpan
	Tokens []Token
	Idx    int
}

func ConcatStringLiterals 

func ConcatStringLiterals(tr *TokenReader) *TokenReader

func LexCodeString 

func LexCodeString(code string, flags int, macros map[string]Macro) (*TokenReader, bool)

func LexFile 

func LexFile(filename string, flags int, macros map[string]Macro) (*TokenReader, bool)

Lexes and preprocesses a file, returning its token array.

func MakeTokenReader 

func MakeTokenReader(tokens []Token, lines *[]string) TokenReader

func Preprocess 

func Preprocess(tr *TokenReader, flags int, macros map[string]Macro) (*TokenReader, bool)

func RemoveComments 

func RemoveComments(tr *TokenReader) *TokenReader

func StripSpaceTokens 

func StripSpaceTokens(tr *TokenReader, allow_newlines bool) *TokenReader

func Tokenize 

func Tokenize(src, filename string) *TokenReader

func (*TokenReader) Advance 

func (tr *TokenReader) Advance(i int)

func (*TokenReader) Get 

func (tr *TokenReader) Get(offset, ignore_flag int) Token

func (*TokenReader) HasTokenKindSeq 

func (tr *TokenReader) HasTokenKindSeq(ignore_flag int, kinds ...TokenKind) bool

func (*TokenReader) Len 

func (tr *TokenReader) Len() int

func (*TokenReader) Reset 

func (tr *TokenReader) Reset()

func (*TokenReader) SkipTokenKinds 

func (tr *TokenReader) SkipTokenKinds(kinds ...TokenKind)

does NOT skip whitespace or comments.

type Type 

type Type interface {
	// contains filtered or unexported methods
}

type TypeAndVal 

type TypeAndVal interface {
	// contains filtered or unexported methods
}

func EvalExpression 

func EvalExpression(code string, flags int, macros map[string]Macro, old bool) TypeAndVal

type TypeChecker 

type TypeChecker struct {
	MsgSpan
	Syms, Types map[string]Type
}

func MakeTypeChecker 

func MakeTypeChecker(p Parser) TypeChecker

func (*TypeChecker) CheckExpr 

func (c *TypeChecker) CheckExpr(e Expr)

func (*TypeChecker) CheckStmt 

func (c *TypeChecker) CheckStmt(s Stmt)

func (TypeChecker) DoMessage 

func (c TypeChecker) DoMessage(n Node, msgtype, color, msg string, args ...any) string

type TypeDecl 

type TypeDecl struct {
	Type Spec // anything not Func or Var Decl.
	// contains filtered or unexported fields
}

Declarations here.

type TypeDefSpec 

type TypeDefSpec struct {
	Ident Expr
	Sig   Spec // *SignatureSpec
	// contains filtered or unexported fields
}

typedef name = function type params;

type TypeSetSpec 

type TypeSetSpec struct {
	Ident      Expr
	Signatures []Spec // []*SignatureSpec
	// contains filtered or unexported fields
}

typeset name {};

type TypeSpec 

type TypeSpec struct {
	Type  Expr
	Dims  int
	IsRef bool
	// contains filtered or unexported fields
}

type[]&

type TypedExpr 

type TypedExpr struct {
	TypeName Token
	// contains filtered or unexported fields
}

<T>

func (*TypedExpr) Tag 

func (e *TypedExpr) Tag() Type

type UnaryExpr 

type UnaryExpr struct {
	X    Expr
	Kind TokenKind
	Post bool
	// contains filtered or unexported fields
}

++i, i++ sizeof new

func (*UnaryExpr) Tag 

func (e *UnaryExpr) Tag() Type

type UsingSpec 

type UsingSpec struct {
	Namespace Expr
	// contains filtered or unexported fields
}

using name;

type VarDecl 

type VarDecl struct {
	Type         Spec // *TypeSpec
	Names, Inits []Expr
	Dims         [][]Expr // a var can have multiple dims, account for em all.
	// valid dim index but empty means [] auto counting.
	// nil index if there was no initializer.
	ClassFlags StorageClassFlags
	// contains filtered or unexported fields
}

name1, name2[n], name3=expr;

type ViewAsExpr 

type ViewAsExpr struct {
	Type Expr // *TypedExpr
	X    Expr
	// contains filtered or unexported fields
}

view_as<T>(expr)

func (*ViewAsExpr) Tag 

func (e *ViewAsExpr) Tag() Type

type VoidTypeAndVal 

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

type WhileStmt 

type WhileStmt struct {
	Cond Expr
	Body Stmt
	Do   bool // do-while version.
	// contains filtered or unexported fields
}

while cond body

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.