compiler

type Compiler struct {
	// lock to prevent race conditions during compilation
	sync.RWMutex

	// array of VMs that will be bundled into this build
	VMs []*GenesisVM

	// a map that places subsets of VMs into buckets according to their priority
	SortedVMs map[int][]*GenesisVM

	// logging object to be used
	Logger logger.Logger

	// a slice of unique priorities that can be found within this VMs bundled into this build
	UniqPriorities []int

	// configuration object for the compiler
	computil.Options
	// contains filtered or unexported fields
}

type EmbeddedFile struct {
	// local file path to the target file
	SourcePath string

	// url to the target file (optional)
	CachedPath string

	// the composite ($ID_$OrigName) filename of the referenced file
	Filename string

	// the original basename of the referenced file
	OrigName string

	// unique identifier that is used by the compiler to reference file contents
	ID string

	// unique identifier that is used by the compiler to swizzle the file decoding and decrypting into a function pointer
	FuncID string

	// uncompressed embedded file data
	Uncompressed []byte

	// compressed embedded file data
	Compressed []byte

	// used to AES encrypt the embedded assets
	EncryptionKey []byte

	// temporary buffer used to generate the intermediate representation of the compressed data
	EmbedData *bytes.Buffer
}

type FunctionCall struct {
	// genesis vm namespace the function call corrasponds to
	Namespace string

	// name of the function call as used in the genesis vm
	FuncName string

	// list of arguments passed to the genesis vm function caller
	ArgumentList []gast.Expression
}

type GenesisVM struct {
	// mutex for compiler manipulation
	sync.RWMutex

	// generated script ID
	ID string `json:"id"`

	// Absolute path to the script file
	SourceFile string `json:"source"`

	// map of embedded files
	Embeds map[string]*EmbeddedFile

	// name of the script (base name of file)
	Name string

	// raw script contents
	Data []byte

	// FileSet for parsing the genesis ASTs
	FileSet *gfile.FileSet

	// represents script as an GenesisAST
	GenesisAST *gast.Program

	// holds the value of parsed macros
	Macros []*Macro

	// maps the current build environment's golang imports
	// key = golang import path
	// value = reference to go package object
	GoPackageByImport map[string]*GoPackage

	// maps the namespace of genesis go imports to their
	// corrasponding go packages
	// key = genesis import namespace
	// value = reference to a go package object
	GoPackageByNamespace map[string]*GoPackage

	// StandardLibraries holds all references to used genesis standard library
	// packages that will be included in the build
	EnabledStandardLibs map[string]*GoPackage

	// required operating system for this script (GOOS)
	RequiredOS string

	// required architecture for this script (GOARCH)
	RequiredArch string

	// Object that holds the translation targets between golang and gscript
	Linker *Linker

	// maintains a map of the function names to the obfuscated references
	EntryPointMapping map[string]string

	// unique variable name to reference this scripts entry point
	PreloadAlias string

	// list of functions that need to be waterfalled for successful execution of the VM
	// usually either single element (Deploy) or the legacy compatible BeforeDeploy, Deploy, AfterDeploy
	EngineVersion int

	// reference to compiler options
	computil.Options

	// GenesisFile holds the intermediate representation of this VM's bundle code
	GenesisFile *bytes.Buffer

	// Logger to publish output from
	Logger logger.Logger

	// EnginePackage is the go package this engine should use
	EnginePackage *GoPackage

	// StandardLibs holds references to all possible standard libs
	StandardLibs map[string]*GoPackage
}

type GoConst struct {
	// Name refers to the const name within the package
	Name string

	// Key refers to the unique identifier for a const in the intermediate representation
	Key string
}

type GoPackage struct {
	sync.RWMutex

	// Dir is the local path where this package is found
	Dir string

	// MaskedName is the masked import representation of this gopackage
	MaskedName string

	// ImportPath is the golang import path used for this package
	ImportPath string

	// Name defines the go package's name
	Name string

	// VM references the script that is importing this package
	VM *GenesisVM

	// Namespace is the namespace aliased in the parent script
	Namespace string

	// ImportKey is the import path defined in the parent script
	ImportKey string

	// ScriptCallers maps the go package function names to genesis AST function calls
	ScriptCallers map[string]*FunctionCall

	// ImportsByFile is the map of each file within the package and what dependencies it imports
	ImportsByFile map[string][]*ast.ImportSpec

	// ImportsByAlias is a map of each import's alias and its dependency information
	ImportsByAlias map[string]*ast.ImportSpec

	// FuncToFileMap maps each public function within the package to it's corrasponding source file
	FuncToFileMap map[string]string

	// FuncTable is the map of each function name to it's Golang AST declaration
	FuncTable map[string]*ast.FuncDecl

	// LinkedFuncs defines references to the dynamically linked functions for this go package
	LinkedFuncs []*LinkedFunction

	// Reference to know if this go package is part of the standard library
	IsStandardLib bool

	// FileSet is used by the parser to interpret the current golang's file tokens
	FileSet *token.FileSet

	// GoTypes are struct type declarations that need to be accounted for in the engine
	GoTypes map[string]*GoStructDef

	// GoConsts are const declarations that need to be accounted for in the engine
	GoConsts map[string]*GoConst

	// GoVars are top level var declarations that need to be accounted for in the engine
	GoVars map[string]*GoVar
}

type GoParamDef struct {
	// Type denotes the type of parameter def (struct, function, etc.)
	Type string

	// OriginalName is to reference the original name of the field incase of problems
	OriginalName string

	// SigBuffer is used to create a definition to the actual type declaration in the genesis compiler's linker
	SigBuffer bytes.Buffer

	// NameBuffer is used to create a label that the genesis linker can use to create it's translations
	NameBuffer bytes.Buffer

	// ImportRefs holds a mapping of any golang dependencies required for this parameter's type declaration
	ImportRefs map[string]*ast.ImportSpec

	// VarName holds a representation of the logical representation of a parameter's label with it's offset appended
	VarName string

	// ParamIdx will be the relative position within the parameter declaration.
	// This is inclusive to multiple declarations of the same type. Example:
	//
	// func Foo(a, b string, c int) {}
	// GoParamDef objects for "a" and "b" would hold the same ParamIdx, but different
	// ArgOffset values
	ParamIdx int

	// ArgOffset defines the absolute position within the parameter declaration. It will increment
	// Regardless of multiple labels defined in the same type.
	// This is used by the linker to correctly translate arguments for golang functions
	ArgOffset int

	// ExtSig will hold the final result of the SigBuffer rendering as a string
	ExtSig string

	// GoLabel is used to represent the label name within Golang
	GoLabel string

	// NeedsMapping defines a hard coded type mapping between golang and javascript types
	NeedsMapping bool

	// MappedTypeAlias is a helper method to look up the type a method should be
	MappedTypeAlias string

	// LinkedFUnction is used to reference the parent LinkedFunction object
	LinkedFunction *LinkedFunction

	// IsInterfaceType defines ifthe GoParamDef an interface type?
	IsInterfaceType bool

	// SkipResolution defines whether the left recursive lexer should skip package resolution
	SkipResolution bool

	// Reference to the parent GoPackage
	GoPackage *GoPackage

	// False, unless the interpretation fails
	Errored bool

	// Holds the error message if the interpretation fails
	ErrorMessage string
}

type GoStructDef struct {
	sync.RWMutex

	// Package is a reference to the parent GoPackage
	Package *GoPackage

	// File is a reference to the parent AST file
	File *ast.File

	// TypeSpec references the typespec node within the file's AST
	TypeSpec *ast.TypeSpec

	// AST references the actual struct definition within the file's AST
	AST *ast.StructType

	// Name represents the name of the struct definition
	Name string

	// Key represents the masked name of the function declaration in the intermediate representation
	Key string

	// ImportRefs hold a mapping of any golang dependencies required for this type declaration
	ImportRefs map[string]*ast.ImportSpec

	// Fields are the fields that can be used within this struct (compatible with genesis type conversion)
	Fields map[string]*GoParamDef

	// Incompatible are fields that CANNOT be used with genesis
	Incompatible map[string]*GoParamDef

	// Embeds is a convenience reference showing any embedded types that might exist within this struct
	Embeds map[string]*GoParamDef
}

type GoVar struct {
	sync.RWMutex

	// Package is a reference to the parent GoPackage
	Package *GoPackage

	// File is a reference to the parent AST file
	File *ast.File

	// ValueSpec is the parent ValueSpec declaration in the AST
	ValueSpec *ast.ValueSpec

	// VSOffset is the offset within the ValueSpec's Ident this var is found
	VSOffset int

	// Ident is a reference to the actual Golang AST ident object
	Ident *ast.Ident

	// Expr holds the data we are checking out!
	Expr ast.Expr

	// Name is the name of the exported var
	Name string

	// Key is the swizzled unique identifier to the declaration
	Key string

	// Valid means it has passed swizzle sanity check for types we can't mess with
	Valid bool

	// Def is the swizzling point of reference for this particular package
	Def *GoParamDef
}

type LegacyArgDef struct {
	// the name of the argument passed into the function
	Name string `yaml:"label"`

	// the golang type argument is expected to be
	GoType string `yaml:"gotype"`
}

type LegacyFunctionCall struct {
	// name of the legacy function
	Name string `yaml:"name"`

	// description of the legacy function
	Description string `yaml:"description"`

	// owner of the legacy function
	Author string `yaml:"author"`

	// package name the legacy function is in
	Package string `yaml:"package"`

	// the expected arguments to the legacy function call
	ExpectedArgTypes []LegacyArgDef `yaml:"args"`

	// the expected returns to the legacy function call
	ExpectedReturnTypes []LegacyRetDef `yaml:"returns"`
}

type LegacyLibrary struct {
	// name of the owning package in the legacy standard library
	Name string `yaml:"package"`

	// path to the golang file located in which this library is implemented
	Path string `yaml:"path"`

	// file set for the AST walk and re-write
	FSet *token.FileSet `yaml:"-"`

	// Golang AST representation of the library's source file
	AST *ast.File `yaml:"-"`

	// map of the function names to their LegacyFunctionCall objects
	Funcs map[string]*LegacyFunctionCall `yaml:"-"`

	// the raw file data for the legacy library source
	Source []byte `yaml:"-"`
}

type LegacyRetDef struct {
	// name of the rerturn value parameter
	Name string `yaml:"label"`

	// the golang type return parameter is expected to be
	GoType string `yaml:"gotype"`

	// optional value to determine if you wish to return this value to the VM
	ReturnToVM bool `yaml:"return,omitempty"`
}

type LinkedFunction struct {
	// ID of the function that is linked
	ID string

	// string representation of the function basename
	Function string

	// reference to the caller in the genesis script AST
	Caller *FunctionCall

	// reference to the golang AST tree of the file this function is declared in
	File *ast.File

	// reference to the declaration of this function in the golang AST
	GoDecl *ast.FuncDecl

	// list of references to any imports needed in declaring argument and return parameters
	// for this linked function
	Imports []*ast.ImportSpec

	// reference to the compiler's go package object
	GoPackage *GoPackage

	// a slice of all the go parameters that make up the argument signature
	GoArgs []*GoParamDef

	// a slice of all the go parameters that make up the return signature
	GoReturns []*GoParamDef

	// a reference to the parent genesis VM
	GenesisVM *GenesisVM

	// reference back to the parent linker
	Linker *Linker

	// A check to make sure this swizzle was successful
	SwizzleSuccessful bool

	// Any errors from the swizzling of this function
	SwizzleError error

	// Signature is a saved version of the golang's method signature
	Signature string
}

type Linker struct {
	sync.RWMutex

	// a reference to the parent genesis VM
	VM *GenesisVM

	// mapping of function name to the linked function object used during generation
	Funcs map[string]*LinkedFunction

	// mapping of type definitions to be linked into the engine
	Types map[string]*GoStructDef

	// MaskedImports map a golang dependency by import path into a translated path
	MaskedImports map[string]*MaskedImport
}

type Macro struct {
	// the genesis compiler option's name for this macro
	Key string

	// map of the values associated with this macro
	Params map[string]string
}

type MaskedImport struct {
	// ImportPath of the masked Import
	ImportPath string

	// OldAlias represents the alias in the target package source
	OldAlias string

	// NewAlias represents the aliased package name in the intermediate representation
	NewAlias string
}