builtins

README

ReCT Built-ins

This package contains any datatypes or functions that are built right into ReCT.
These are things like:

Datatypes: void, bool, int, float, string

Functions:

Function	Done
Print()	✅
Write()	✅
Input()	✅
InputKey()	✅
Clear()	✅
SetCursor()	✅
GetSizeX()	✅
GetSizeY()	✅
SetSize()	✅
SetCursorVisible()	✅
GetCursorVisible()	✅
Random()	✅
Sleep()	✅
Version()	✅

Documentation

Index

• Variables

Variables

var (
	GetLength = symbols.CreateBuiltInTypeFunctionSymbol(
		"GetLength",
		[]symbols.ParameterSymbol{},
		Int,
		nodes.FunctionDeclarationMember{},
		String,
	)

	GetBuffer = symbols.CreateBuiltInTypeFunctionSymbol(
		"GetBuffer",
		[]symbols.ParameterSymbol{},
		symbols.CreateTypeSymbol("pointer", []symbols.TypeSymbol{Byte}, false, false, false, symbols.PackageSymbol{}, nil),
		nodes.FunctionDeclarationMember{},
		String,
	)

	GetArrayLength = symbols.CreateBuiltInTypeFunctionSymbol(
		"GetLength",
		[]symbols.ParameterSymbol{},
		Int,
		nodes.FunctionDeclarationMember{},
		Array,
	)

	Substring = symbols.CreateBuiltInTypeFunctionSymbol(
		"Substring",
		[]symbols.ParameterSymbol{
			symbols.CreateParameterSymbol("startingIndex", 0, Int),
			symbols.CreateParameterSymbol("length", 1, Int),
		},
		String,
		nodes.FunctionDeclarationMember{},
		String,
	)

	Push = symbols.CreateBuiltInTypeFunctionSymbol(
		"Push",
		[]symbols.ParameterSymbol{
			symbols.CreateParameterSymbol("object", 0, Any),
		},
		Void,
		nodes.FunctionDeclarationMember{},
		Array,
	)

	PPush = symbols.CreateBuiltInTypeFunctionSymbol(
		"PPush",
		[]symbols.ParameterSymbol{
			symbols.CreateParameterSymbol("element", 0, Identity),
		},
		Void,
		nodes.FunctionDeclarationMember{},
		Array,
	)

	Start = symbols.CreateBuiltInTypeFunctionSymbol(
		"Start",
		[]symbols.ParameterSymbol{},
		Void,
		nodes.FunctionDeclarationMember{},
		Thread,
	)

	Join = symbols.CreateBuiltInTypeFunctionSymbol(
		"Join",
		[]symbols.ParameterSymbol{},
		Void,
		nodes.FunctionDeclarationMember{},
		Thread,
	)

	Kill = symbols.CreateBuiltInTypeFunctionSymbol(
		"Kill",
		[]symbols.ParameterSymbol{},
		Void,
		nodes.FunctionDeclarationMember{},
		Thread,
	)

	Run = symbols.CreateBuiltInTypeFunctionSymbol(
		"Run",
		[]symbols.ParameterSymbol{},
		Void,
		nodes.FunctionDeclarationMember{},
		Action,
	)

	RunThread = symbols.CreateBuiltInTypeFunctionSymbol(
		"RunThread",
		[]symbols.ParameterSymbol{},
		Thread,
		nodes.FunctionDeclarationMember{},
		Action,
	)
)

var (
	Void   = symbols.CreateTypeSymbol("void", make([]symbols.TypeSymbol, 0), false, false, false, symbols.PackageSymbol{}, nil)
	Bool   = symbols.CreateTypeSymbol("bool", make([]symbols.TypeSymbol, 0), false, false, false, symbols.PackageSymbol{}, nil)
	Byte   = symbols.CreateTypeSymbol("byte", make([]symbols.TypeSymbol, 0), false, false, false, symbols.PackageSymbol{}, nil)
	Int    = symbols.CreateTypeSymbol("int", make([]symbols.TypeSymbol, 0), false, false, false, symbols.PackageSymbol{}, nil)
	UInt   = symbols.CreateTypeSymbol("uint", make([]symbols.TypeSymbol, 0), false, false, false, symbols.PackageSymbol{}, nil)
	Long   = symbols.CreateTypeSymbol("long", make([]symbols.TypeSymbol, 0), false, false, false, symbols.PackageSymbol{}, nil)
	ULong  = symbols.CreateTypeSymbol("ulong", make([]symbols.TypeSymbol, 0), false, false, false, symbols.PackageSymbol{}, nil)
	Float  = symbols.CreateTypeSymbol("float", make([]symbols.TypeSymbol, 0), false, false, false, symbols.PackageSymbol{}, nil)
	Double = symbols.CreateTypeSymbol("double", make([]symbols.TypeSymbol, 0), false, false, false, symbols.PackageSymbol{}, nil)
	String = symbols.CreateTypeSymbol("string", make([]symbols.TypeSymbol, 0), true, false, false, symbols.PackageSymbol{}, nil)
	Any    = symbols.CreateTypeSymbol("any", make([]symbols.TypeSymbol, 0), true, false, false, symbols.PackageSymbol{}, nil)

	// lambda/functionExpression/action/etc
	Action = symbols.CreateTypeSymbol("action", make([]symbols.TypeSymbol, 0), false, false, false, symbols.PackageSymbol{}, nil)

	// threads
	Thread = symbols.CreateTypeSymbol("thread", make([]symbols.TypeSymbol, 0), true, false, false, symbols.PackageSymbol{}, nil)

	// generic array types so the emitter has something to work with
	Array  = symbols.CreateTypeSymbol("array", make([]symbols.TypeSymbol, 0), true, false, false, symbols.PackageSymbol{}, nil)
	PArray = symbols.CreateTypeSymbol("parray", make([]symbols.TypeSymbol, 0), true, false, false, symbols.PackageSymbol{}, nil)

	// lazy shortcut
	AnyArr = symbols.CreateTypeSymbol("array", []symbols.TypeSymbol{Any}, true, false, false, symbols.PackageSymbol{}, nil)

	// placeholder
	Enum = symbols.CreateTypeSymbol("enum", make([]symbols.TypeSymbol, 0), false, false, true, symbols.PackageSymbol{}, nil)

	// spoopy
	Pointer = symbols.CreateTypeSymbol("pointer", make([]symbols.TypeSymbol, 0), false, false, false, symbols.PackageSymbol{}, nil)

	// the cursed ones
	Error    = symbols.CreateTypeSymbol("?", make([]symbols.TypeSymbol, 0), false, false, false, symbols.PackageSymbol{}, nil)
	Identity = symbols.CreateTypeSymbol("¯\\_(ツ)_/¯", make([]symbols.TypeSymbol, 0), false, false, false, symbols.PackageSymbol{}, nil)

	Types = []symbols.TypeSymbol{
		Void, Bool, Byte, Int, Long, UInt, ULong, Float, Double, String, Any, Action, Array, PArray, Pointer, Thread, Enum,
	}
)