compiler

type C struct {
	// T holds the compiler types.
	T Types

	// M is the codegen module for the program.
	M *codegen.Module

	// API is the api that is being compiled.
	API *semantic.API

	// Mangler is the symbol mangler in use.
	Mangler mangling.Mangler

	// Root is the namespace in which generated symbols should be placed.
	// This excludes gapil runtime symbols which have the prefix 'gapil_'.
	Root mangling.Scope
	// contains filtered or unexported fields
}

type CommandInfo struct {
	// The execute function for the given command.
	// The function has the signature: void (ctx*, Params*)
	Execute codegen.Function

	// The Params structure that is passed to Execute.
	Parameters *codegen.Struct
}

type ErrorCode uint32

type Location struct {
	File   string
	Line   int
	Column int
}

type MapInfo struct {
	Type     *codegen.Struct // Maps are held as pointers to these structs
	Elements *codegen.Struct
	Key      codegen.Type
	Val      codegen.Type
	Element  codegen.Type
	Contains codegen.Function // bool(ctx*, M*, K)
	Index    codegen.Function //   V*(ctx*, M*, K, addIfNotFound)
	Lookup   codegen.Function //   V(ctx*, M*, K)
	Remove   codegen.Function // void(ctx*, M*, K)
	Clear    codegen.Function // void(ctx*, M*)
}

type Plugin interface {
	Build(*C)
}

type Program struct {
	// Settings used to compile the program.
	Settings Settings

	// Commands is a map of command name to CommandInfo.
	Commands map[string]*CommandInfo

	// Structs is a map of struct name to StructInfo.
	Structs map[string]*StructInfo

	// Maps is a map of map name to MapInfo.
	Maps map[string]*MapInfo

	// Globals is the StructInfo of all the globals.
	Globals *StructInfo

	// Locations is the array of source locations.
	// Only generated if Settings.CodeLocations is true.
	Locations []Location

	// Module is the generated code module.
	Module *codegen.Module

	// Initializer is a function that initializes the globals with defaults.
	// The function has the signature: void (ctx* ctx)
	Initializer codegen.Function
}

type S struct {
	// The scope can emit any instructions into the current scope block.
	*codegen.Builder

	// Ctx is a pointer to the active context (context_t*).
	Ctx *codegen.Value

	// Location is a pointer to the current source code location (uint32_t*).
	Location *codegen.Value

	// Globals is a pointer to the current API's global state variables.
	Globals *codegen.Value

	// Arena is a pointer to the current memory arena (arena*).
	Arena *codegen.Value
	// contains filtered or unexported fields
}

type Settings struct {
	// TargetABI is the ABI used by the device running the compiled code.
	TargetABI *device.ABI

	// StorageABI is the ABI of the device used to generate data in serialized
	// buffers.
	StorageABI *device.ABI

	// The mangler used for global functions and types.
	Mangler mangling.Mangler

	// Prefix for mangler
	Namespaces []string

	// EmitExec is true if the compiler should generate execution functions for
	// each API command.
	EmitExec bool

	// CodeLocations is true if the compiler should emit writes to the context's
	// location field with the currently executing statement.
	CodeLocations bool

	// WriteToApplicationPool is true if writes to the application pool should
	// be performed.
	WriteToApplicationPool bool

	// Plugins are the list of extensions to include in the compilation.
	Plugins []Plugin
}

type StructInfo struct {
	Type *codegen.Struct
}

type Types struct {
	codegen.Types
	Ctx        codegen.Type                        // context_t
	CtxPtr     codegen.Type                        // context_t*
	Pool       codegen.Type                        // pool_t
	PoolPtr    codegen.Type                        // pool_t*
	Sli        codegen.Type                        // slice_t
	Str        *codegen.Struct                     // string_t
	StrPtr     codegen.Type                        // string_t*
	Arena      *codegen.Struct                     // arena_t
	ArenaPtr   codegen.Type                        // arena_t*
	Uint8Ptr   codegen.Type                        // uint8_t*
	VoidPtr    codegen.Type                        // void* (aliased of uint8_t*)
	Globals    *codegen.Struct                     // API global variables structure.
	GlobalsPtr codegen.Type                        // Pointer to Globals.
	CmdParams  map[*semantic.Function]codegen.Type // struct holding all command parameters and return value.
	Maps       map[*semantic.Map]*MapInfo
	// contains filtered or unexported fields
}