SkyLine_Configuration_Engine_Backend_Source

package
v0.0.0-...-72c8661 Latest Latest
Warning

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

 Go to latest Published: Aug 6, 2023 License: GPL-2.0 Imports: 15 Imported by: 0

Documentation

Overview

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 

 													 _____ _       __    _
														|   __| |_ _ _|  |  |_|___ ___
													    |__   | '_| | |  |__| |   | -_|
														|_____|_,_|_  |_____|_|_|_|___|
		   														  |___|

The SkyLine configuration language is a language and engine designed to act as a modification language to the SkyLine programming language. This language is very minimal and contains a regex base lexer, a very basic parser, a few keywords, a base interpreter and that is all as well as some backend engine code. This language is purely modified to be an extension to the SkyLine programming language, something that can be a pre processor language post processing for the main SkyLine script. Below is more technical information for the language

Lexer : Regex based lexer with minimal tokens and base syntax Parser : Base parser with minimal tokens and base syntax with simple error systems REPL : Does not exist Environment : Extremely minimal Types : String, Boolean, Integer Statements : set, import, use, errors, output, system, constant/const

Contains -> This file contains functions for project management. The SLC or SkyLine configuration language is a language and engine that was designed from the RPC project management system. Radical Processing Core's Engine (RPC-E) was an engine that would help manage and generate projects easier within RPC. This is because of how syntactically annoying RPC was. So for C++/C/Go wrapping and library calling we decided to also add the engine. This engine will help generate code templates using M4-Sugar ( For linux ) based on templates and help better set you up for project development! Current support for this system is LINUX

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 

 													 _____ _       __    _
														|   __| |_ _ _|  |  |_|___ ___
													    |__   | '_| | |  |__| |   | -_|
														|_____|_,_|_  |_____|_|_|_|___|
		   														  |___|

The SkyLine configuration language is a language and engine designed to act as a modification language to the SkyLine programming language. This language is very minimal and contains a regex base lexer, a very basic parser, a few keywords, a base interpreter and that is all as well as some backend engine code. This language is purely modified to be an extension to the SkyLine programming language, something that can be a pre processor language post processing for the main SkyLine script. Below is more technical information for the language

Lexer : Regex based lexer with minimal tokens and base syntax Parser : Base parser with minimal tokens and base syntax with simple error systems REPL : Does not exist Environment : Extremely minimal Types : String, Boolean, Integer Statements : set, import, use, errors, output, system, constant/const

Contains -> This file contains a function that works with the SkyLine configuration language's engine's environment to be able to set constant variables and prevent them 

from being modified.

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 

 													 _____ _       __    _
														|   __| |_ _ _|  |  |_|___ ___
													    |__   | '_| | |  |__| |   | -_|
														|_____|_,_|_  |_____|_|_|_|___|
		   														  |___|

The SkyLine configuration language is a language and engine designed to act as a modification language to the SkyLine programming language. This language is very minimal and contains a regex base lexer, a very basic parser, a few keywords, a base interpreter and that is all as well as some backend engine code. This language is purely modified to be an extension to the SkyLine programming language, something that can be a pre processor language post processing for the main SkyLine script. Below is more technical information for the language

Lexer : Regex based lexer with minimal tokens and base syntax Parser : Base parser with minimal tokens and base syntax with simple error systems REPL : Does not exist Environment : Extremely minimal Types : String, Boolean, Integer Statements : set, import, use, errors, output, system, constant/const

Contains -> This file contains functions that are dedicated to checking, prepping and setting a variable before it can be registered into the environment

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 

 													 _____ _       __    _
														|   __| |_ _ _|  |  |_|___ ___
													    |__   | '_| | |  |__| |   | -_|
														|_____|_,_|_  |_____|_|_|_|___|
		   														  |___|

The SkyLine configuration language is a language and engine designed to act as a modification language to the SkyLine programming language. This language is very minimal and contains a regex base lexer, a very basic parser, a few keywords, a base interpreter and that is all as well as some backend engine code. This language is purely modified to be an extension to the SkyLine programming language, something that can be a pre processor language post processing for the main SkyLine script. Below is more technical information for the language

Lexer : Regex based lexer with minimal tokens and base syntax Parser : Base parser with minimal tokens and base syntax with simple error systems REPL : Does not exist Environment : Extremely minimal Types : String, Boolean, Integer Statements : set, import, use, errors, output, system, constant/const

Contains -> This file contains most of the models or data type structures for the language, each section is split into its own reason.

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 

 													 _____ _       __    _
														|   __| |_ _ _|  |  |_|___ ___
													    |__   | '_| | |  |__| |   | -_|
														|_____|_,_|_  |_____|_|_|_|___|
		   														  |___|

The SkyLine configuration language is a language and engine designed to act as a modification language to the SkyLine programming language. This language is very minimal and contains a regex base lexer, a very basic parser, a few keywords, a base interpreter and that is all as well as some backend engine code. This language is purely modified to be an extension to the SkyLine programming language, something that can be a pre processor language post processing for the main SkyLine script. Below is more technical information for the language

Lexer : Regex based lexer with minimal tokens and base syntax Parser : Base parser with minimal tokens and base syntax with simple error systems REPL : Does not exist Environment : Extremely minimal Types : String, Boolean, Integer Statements : set, import, use, errors, output, system, constant/const

File contains -> This file contains every single part of the SkyLine configuration language parser

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 

 													 _____ _       __    _
														|   __| |_ _ _|  |  |_|___ ___
													    |__   | '_| | |  |__| |   | -_|
														|_____|_,_|_  |_____|_|_|_|___|
		   														  |___|

The SkyLine configuration language is a language and engine designed to act as a modification language to the SkyLine programming language. This language is very minimal and contains a regex base lexer, a very basic parser, a few keywords, a base interpreter and that is all as well as some backend engine code. This language is purely modified to be an extension to the SkyLine programming language, something that can be a pre processor language post processing for the main SkyLine script. Below is more technical information for the language

Lexer : Regex based lexer with minimal tokens and base syntax Parser : Base parser with minimal tokens and base syntax with simple error systems REPL : Does not exist Environment : Extremely minimal Types : String, Boolean, Integer Statements : set, import, use, errors, output, system, constant/const

contains -> This file contains functions known as verification functions. These functions can better verify what a specific input or character matches up to.

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 

 													 _____ _       __    _
														|   __| |_ _ _|  |  |_|___ ___
													    |__   | '_| | |  |__| |   | -_|
														|_____|_,_|_  |_____|_|_|_|___|
		   														  |___|

The SkyLine configuration language is a language and engine designed to act as a modification language to the SkyLine programming language. This language is very minimal and contains a regex base lexer, a very basic parser, a few keywords, a base interpreter and that is all as well as some backend engine code. This language is purely modified to be an extension to the SkyLine programming language, something that can be a pre processor language post processing for the main SkyLine script. Below is more technical information for the language

Lexer : Regex based lexer with minimal tokens and base syntax Parser : Base parser with minimal tokens and base syntax with simple error systems REPL : Does not exist Environment : Extremely minimal Types : String, Boolean, Integer Statements : set, import, use, errors, output, system, constant/const

File -> SkyLine_Configuration_Language_Frontend_ArtWork.go Apart -> SLC/Modules/Backend Source -> .go, .mod, .SL-Modify

File contains -> This file is dedicated to the entire configuration language's core library. The configuration language for SkyLine mainly runs off of standard functions 

                 or rather standard library based functions which include functions to verify systems, load json files and much more amongst that. So to do that and to
                 allow for specific functions we will be registering all of them into the environment at once using a init() function. This file will hold all proper types
				    as well as all proper functions, init calls, descriptions, results, parsers and more. This may be one of the longest files in this entire development directory

WARN: Each section is split up into its own little part and function.

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 

 													 _____ _       __    _
														|   __| |_ _ _|  |  |_|___ ___
													    |__   | '_| | |  |__| |   | -_|
														|_____|_,_|_  |_____|_|_|_|___|
		   														  |___|

The SkyLine configuration language is a language and engine designed to act as a modification language to the SkyLine programming language. This language is very minimal and contains a regex base lexer, a very basic parser, a few keywords, a base interpreter and that is all as well as some backend engine code. This language is purely modified to be an extension to the SkyLine programming language, something that can be a pre processor language post processing for the main SkyLine script. Below is more technical information for the language

Lexer : Regex based lexer with minimal tokens and base syntax Parser : Base parser with minimal tokens and base syntax with simple error systems REPL : Does not exist Environment : Extremely minimal Types : String, Boolean, Integer Statements : set, import, use, errors, output, system, constant/const Filename : SkyLine_Configuration_Engine_Error_System.go

Contains -> This file defines the entire error syetem and every error for the SkyLine Configuration Language. THis error system is defined below in terms of understanding as well as codes, type systems, type checking and much more among that list.

:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::

The SkyLine configuration language/engine is a very unique engine of its kind, it does not use standard error systems as it makes its own, anytime there is an error

there are unique codes put in place to do this. Now, working with SLC given how small it is means there is only a small amount of codes and errors that can happen or

that can exist within this engine. We can give our standard range of 1-100 for standard errors, 100-200 for parser errors, 200-300 for scanner errors, 300-400 for evaluator

errors and anything above is a developer error code. Below the chart is shown for categorization

---- CHART ( error codes ) -----

1-100 | Standard errors, files, ignoring, flags, config etc 100-200 | parser errors, failed symbols, non prefix parsing functions etc 200-300 | scanner errors, false token, illegal token, illegal syntax, error during parse etc 300-400 | evaluator token, expecting, missing semicolon, missing syntax, missing symbol, broken tag etc 400-10,000 | developer errors such as missing code in map, missing argument call, panic or fatal error etc etc

The below tags all define the design for the error system for the configuration engine. This will go by color codes or definitions etc etc.

---- DESIGN ----

The design for the error system is quite simple, it will show the error, the code, the filename and more. The example is shown below

  • [E]:(Engine)->[1] | |[E]: missing semicolon | |[S]: set x := 10 | |[F]:

The top row will be red with grey where grey will highlight the engine, the number at the end represents the code

further down you have E which is the error message, below the statement and the final statement which will be a possible fix

Index

Constants

View Source 
const (
	ASSIGN_Token             = "="            // Assignment
	MODIFY_Token             = "->"           // Modifier
	SEMICOLON_Token          = ";"            // Break
	COMMA_Token              = ","            // List def
	LPAREN_Token             = "("            // Start compression
	RPAREN_Token             = ")"            // End compression
	LBRACE_Token             = "{"            // Start block
	RBRACE_Token             = "}"            // End block
	LBRACKET_Token           = "["            // Start array
	RBRACKET_Token           = "]"            // End array
	SET_Token                = "SET"          // Assignment
	CONSTANT_Token           = "CONSTANT"     // Constant def
	BOOL_TRUE_Token          = "TRUE"         // Boolean -> true
	BOOL_FALSE_Token         = "FALSE"        // Boolean -> false
	INTEGER_Token            = "INTEGER"      // Integer token
	STRING_Token             = "STRING"       // String token
	ENGINE_Token             = "ENGINE"       // Engine block definition
	ENGINE_INITATE_Token     = "INIT"         // Engine initate parse definition
	END_OF_FILE              = "EOF"          // End of the file has been reached
	ALIENATED_UNVERSED       = "ILLEGAL_TYPE" // Illegal or unsupported data type, this calls alienated due to it not being in bounds of the engine
	IDENTIFIER               = "IDENT"        // Identifier
	OBJECT_NULL              = "NULL"         // Object | Null
	OBJECT_INTEGER           = "INTEGER"      // Object | Integer
	OBJECT_STRING            = "STRING"       // Object | String
	OBJECT_BOOLEAN           = "BOOLEAN"      // Object | Boolean
	OBJECT_ARRAY             = "ARRAY"        // Object | Array
	OBJECT_BUILT_IN_FUNCTION = "Builtin"      // Object | Built-in function
	OBJECT_ERROR             = "ERROR"        // Object | Error
)
View Source 
const (
	NULL_OBJ    = "NULL"
	ERROR_OBJ   = "ERROR"
	INTEGER_OBJ = "INTEGER"
	BOOLEAN_OBJ = "BOOLEAN"
	STRING_OBJ  = "STRING"
	BUILTIN_OBJ = "BUILTIN"
	ARRAY_OBJ   = "ARRAY"
)
View Source 
const (
	LOWEST      int
	EQUALS      // ==
	LESSGREATER // > or <
	SUM         // +
	PRODUCT     // *
	PREFIX      // -X or !X
	CALL        // myFunction(X)
	INDEX       // array[index]
	ARROW
)

PRECS

View Source 
const (
	SLC_FileSystem_NULL_FIELDS                     = "10"  // File does not have anything in it NULL
	SLC_FileSystem_MissingEngineCode               = "20"  // before iniation you must define one engine(true) block and one init(true) block
	SLC_FileSystem_ErrorWhenOpeningOrLoadingFile   = "30"  // Could not load the file due to
	SLC_Parser_ExpectRightBracket                  = "200" // Missing '}
	SLC_Parser_ExpectLeftBracket                   = "205" // Missing '{
	SLC_Parser_ExpectLeftParen                     = "210" // Missing '(
	SLC_Parser_ExpectRightParen                    = "215" // Missing ')
	SLC_Parser_ExpectSemicolom                     = "220" // Missing ';
	SLC_Parser_OnlyOneDefaultParseInEngineINIT     = "225" // The ENGINE (INIT) statement should only have one DEF call to it
	SLC_Parser_Unterminated_IniationStatement      = "230" // Unterminated INIT statement
	SLC_Parser_IntegerOverflowParsingError         = "235" // Integer parsing overflow
	SLC_Parser_NoPrefixParsingFunctionFound        = "240" // No prefix parser function found
	SLC_Parser_UnterminatedConstantStatement       = "245" // Unterminated constant statement
	SLC_Parser_ExpectedTokenButGotSoOnStatement    = "250" // Expected next token to be ”... but got ”...
	SLC_Evaluator_Unknown_Token_Operator           = "300" // Unknown token / operator
	SLC_Evaluator_DataType_Mismatch                = "310" // Non compatible data type
	SLC_Evaluator_Identifier_Not_Found             = "320" // Ident not found
	SLC_Evaluator_Array_Index_Operator_Unsupported = "330" // Array index expression false
	SLC_Evaluator_ValueCall_Not_A_Function         = "340" // Not a function
	SLC_Evaluator_ATTEMPT_TO_MOD_CONSTANT          = "350" // Attempting to modify a constant value
	SLC_Evaluator_FAULT_WHEN_PARSING               = "360" // The engine encountered a segment fault when parsing the left or right values of ->.
)
View Source 
const (
	M4_Sugar_LOC = "/usr/share/Modules/Backend/SkyConfEngine/EngineCore/SkyLine-Configuration-Engine-Templates/Linux"
)

Variables

View Source 
var (
	NULL  = &ObjectNULL{}
	TRUE  = &ObjectBoolean{Value: true}
	FALSE = &ObjectBoolean{Value: false}
)
View Source 
var AllTemplates = []string{
	"slmod:Engine",
	"config:Project",
	"config:Requires",
	"core:Makefile",
	"core:Modules",
	"core:main",
	"core:FFI_IMPL_CPP",
	"core:FFI_IMPL_HPP",
	"core:FFI_FinalPlugin",
	"core:GoMod",
}
View Source 
var Builtins = map[string]*ObjectBUILTINFUNCTION{}
View Source 
var FileMap = map[string]string{
	"core:main":            "main.sl",
	"slmod:Engine":         "Backend/Conf/EngineFiles/Engine.slmod",
	"config:Project":       "Backend/Conf/ProjectData/Project.json",
	"config:Requires":      "Backend/Conf/Requires/Requires.json",
	"core:Modules":         "Backend/Core/Scripts/Module.sl",
	"core:FFI_IMPL_CPP":    "Backend/Core/Plugins/CPPImplementation.cpp",
	"core:FFI_IMPL_HPP":    "Backend/Core/Plugins/CPPImplementation.hpp",
	"core:FFI_FinalPlugin": "Backend/Core/Plugins/PluginCompile.go",
	"core:Makefile":        "Backend/Core/Plugins/Makefile",
	"core:GoMod":           "Backend/Core/Plugins/go.mod",
}
View Source 
var IsRenderForCmdDbg bool
View Source 
var KeyMap = map[string]TokenDataType{
	"set":      SET_Token,
	"true":     BOOL_TRUE_Token,
	"false":    BOOL_FALSE_Token,
	"ENGINE":   ENGINE_Token,
	"INIT":     ENGINE_INITATE_Token,
	"constant": CONSTANT_Token,
	"const":    CONSTANT_Token,
}
View Source 
var LibrariesMap = map[string]bool{
	"math":                true,
	"io":                  true,
	"File":                true,
	"http":                true,
	"Google/Smart_API_DB": true,
	"Amazon/Smart_API_DB": true,
	"Roku/Smart_API_DB":   true,
	"Apple/Smart_API_DB":  true,
	"Other/Smart_API_DB":  true,
	"xml":                 true,
	"json":                true,
	"env":                 true,
	"console":             true,
	"forensics/image":     true,
}
View Source 
var ParserPrecedences = map[TokenDataType]int{
	LPAREN_Token: CALL,
	LBRACE_Token: INDEX,
	MODIFY_Token: ARROW,
}
View Source 
var ScannerTokenizationRegularExpressions = map[*regexp.Regexp]TokenDataType{
	regexp.MustCompile(`^=$`):  ASSIGN_Token,
	regexp.MustCompile(`^;$`):  SEMICOLON_Token,
	regexp.MustCompile(`^\($`): LPAREN_Token,
	regexp.MustCompile(`^\)$`): RPAREN_Token,
	regexp.MustCompile(`^,$`):  COMMA_Token,
	regexp.MustCompile(`^{`):   LBRACE_Token,
	regexp.MustCompile(`^}`):   RBRACE_Token,
	regexp.MustCompile(`^\[$`): LBRACKET_Token,
	regexp.MustCompile(`^\]$`): RBRACKET_Token,
}
View Source 
var SystemsArguments = map[string]int{
	"error_system":       3,
	"import_system":      1,
	"strict_system":      1,
	"parser_code_system": 2,
	"output_system":      2,
}

The systems map allows us to define how much arguments the right side of the modifier '->' can have.

In the SkyLine Configuration Language, a modifier otherwise known as a passer is defined by '->'.

The idea of a modifier is to take the left value of type STRING and then the right side of type ARRAY

and modify the system respectively or in this case store the results so SL can access it before running

the program and all of the data properly. The right side of the array will be how much you can modify.

For example, say we want to modify the error system, well, there are three things you can modify in the error system

output of type string color of type boolean warnings of type boolean

warnings | defines whether or not the user wants to see warnings or output warnings ( true=on or false=off) color | defines whether or not the user wants to turn on color ( true ) or turn it off ( false ) output | defines the error systems form of output, should it be basic, verbose, or tree or masters.

when we want to parse these values, given the array on the right side of the arrow is a array of arguments,

we need to be able to monitor how much arguments are being passed. if the array in the case of

system("warnings") -> [];

does not have any arguments, the engine will output a warning, if the array has arguments but not enough the engine will assume values and if the array has too much arguments according to the system the engine will stop parsing and call to kill the process of both skyline and the engine sending syscall's too its process.

The purpose of this map allows us to define the limit of how much arguments are allows per system.

View Source 
var Systems_Modifable = map[string]string{
	"errors": "error_system",
	"parser": "parser_code_system",
	"output": "output_system",
	"import": "import_system",
}
View Source 
var TemplatePaths = []string{
	"Backend",
	"Backend/Conf/EngineFiles",
	"Backend/Conf/ProjectData",
	"Backend/Conf/Requires",
	"Backend/Core/Scripts",
	"Backend/Core/Plugins",
}

Functions

func CallErrorStr 

func CallErrorStr(Code, Message, Statement string) string

func Clear 

func Clear()

func CreateDir 

func CreateDir(dir string)

func EngineBelowArgLimit 

func EngineBelowArgLimit(minimum int, arguments ...SLC_Object) bool

Check sif the argument list is below the minimum requirement if a function is called with () and the minimum requirement is 1 argument, then this function can be used to check that.

func EngineCheckNil 

func EngineCheckNil(data interface{}) bool

func EngineGetArgLength 

func EngineGetArgLength(args ...SLC_Object) int

func EngineGetDataType 

func EngineGetDataType(args SLC_Object) string

func EngineGrabSystemToModify 

func EngineGrabSystemToModify(system string) string

Grabs the actual system to modify

func EngineIsZero 

func EngineIsZero(arguments ...SLC_Object) bool

this tekks the engine if the argument count is 0 or NULL

func EngineMeetsArgLimit 

func EngineMeetsArgLimit(max int, arguments ...SLC_Object) bool

This tells the engine if the argument count is too much in the case that a function is called with too many arguments this function can be called to check the length and if it goes over or is greater than the max number of arguments allowed

func Execute 

func Execute(command, arg1, write string) (string, error)

func GenerateContentsOfFile 

func GenerateContentsOfFile(filename, startdir string)

func OutputBanner 

func OutputBanner()

func OutputBoxOCode 

func OutputBoxOCode(filename string)

func RegisterBuiltin 

func RegisterBuiltin(name string, fun BuiltinFunction)

func SetupCall 

func SetupCall(StartDirectory string)

Start directory is where SLC will generate or locate the primary start for generating the files and project data for example: say you provide "user/Desktop/Project" SLC will generate all paths and directories and files of the template project in that directory.

func SkyLine_Configuration_Engine_Evaluate_SysModify 

func SkyLine_Configuration_Engine_Evaluate_SysModify(left string, right []SLC_Object) bool

func StartEngine_RenderFile 

func StartEngine_RenderFile(Filename string, iscmdrender bool) (errors bool)

func VerifyDigit 

func VerifyDigit(ch byte) bool

Verification function (Is a digit?) will verify if it is a digit from 1-9

func VerifyLetterAlpha 

func VerifyLetterAlpha(ch byte) bool

Verification function (Is a Letter?) will verify if the character input is a letter

Types

type AbstractSyntaxTree_Expression 

type AbstractSyntaxTree_Expression interface {
	AbstractSyntaxTree_Node
	ExpressionLeafNode()
}

type AbstractSyntaxTree_Node 

type AbstractSyntaxTree_Node interface {
	TokenConstructLiteral() string
	TokenConstructToString() string
}

type AbstractSyntaxTree_Statement 

type AbstractSyntaxTree_Statement interface {
	AbstractSyntaxTree_Node
	SatatementLeafNode()
}

type ArrayLiteral_Expression_AbstractSyntaxTree 

type ArrayLiteral_Expression_AbstractSyntaxTree struct {
	TokenRegister TokenRegistry
	Elements      []AbstractSyntaxTree_Expression

} // Array::[]

func (*ArrayLiteral_Expression_AbstractSyntaxTree) ExpressionLeafNode 

func (AstArray *ArrayLiteral_Expression_AbstractSyntaxTree) ExpressionLeafNode()

func (*ArrayLiteral_Expression_AbstractSyntaxTree) TokenConstructLiteral 

func (AstArray *ArrayLiteral_Expression_AbstractSyntaxTree) TokenConstructLiteral() string

func (*ArrayLiteral_Expression_AbstractSyntaxTree) TokenConstructToString 

func (AstArray *ArrayLiteral_Expression_AbstractSyntaxTree) TokenConstructToString() string

type Assignment_Statement_AbstractSyntaxTree 

type Assignment_Statement_AbstractSyntaxTree struct {
	TokenRegister TokenRegistry
	Name          *Identifier_Expression_AbstractSyntaxTree
	Value         AbstractSyntaxTree_Expression

} // set

func (*Assignment_Statement_AbstractSyntaxTree) SatatementLeafNode 

func (AstAssignment *Assignment_Statement_AbstractSyntaxTree) SatatementLeafNode()

func (*Assignment_Statement_AbstractSyntaxTree) TokenConstructLiteral 

func (AstAssignment *Assignment_Statement_AbstractSyntaxTree) TokenConstructLiteral() string

func (*Assignment_Statement_AbstractSyntaxTree) TokenConstructToString 

func (AstAssignment *Assignment_Statement_AbstractSyntaxTree) TokenConstructToString() string

type BlockStatement_Statement_AbstractSyntaxTree 

type BlockStatement_Statement_AbstractSyntaxTree struct {
	TokenRegister TokenRegistry
	Statements    []AbstractSyntaxTree_Statement

} // {}

func (*BlockStatement_Statement_AbstractSyntaxTree) SatatementLeafNode 

func (AstUnitSec *BlockStatement_Statement_AbstractSyntaxTree) SatatementLeafNode()

func (*BlockStatement_Statement_AbstractSyntaxTree) TokenConstructLiteral 

func (AstUnitSec *BlockStatement_Statement_AbstractSyntaxTree) TokenConstructLiteral() string

func (*BlockStatement_Statement_AbstractSyntaxTree) TokenConstructToString 

func (AstUnitSec *BlockStatement_Statement_AbstractSyntaxTree) TokenConstructToString() string

type BooleanDataType_Expression_AbstractSyntaxTree 

type BooleanDataType_Expression_AbstractSyntaxTree struct {
	TokenRegister TokenRegistry
	Value         bool

} // Boolean::TRUE->FALSE

func (*BooleanDataType_Expression_AbstractSyntaxTree) ExpressionLeafNode 

func (AstBoolean *BooleanDataType_Expression_AbstractSyntaxTree) ExpressionLeafNode()

func (*BooleanDataType_Expression_AbstractSyntaxTree) TokenConstructLiteral 

func (AstBoolean *BooleanDataType_Expression_AbstractSyntaxTree) TokenConstructLiteral() string

func (*BooleanDataType_Expression_AbstractSyntaxTree) TokenConstructToString 

func (AstBoolean *BooleanDataType_Expression_AbstractSyntaxTree) TokenConstructToString() string

type BuiltinFunction 

type BuiltinFunction func(args ...SLC_Object) SLC_Object

type CallFunction_Expression_AbstractSyntaxTree 

type CallFunction_Expression_AbstractSyntaxTree struct {
	TokenRegister TokenRegistry
	Function      AbstractSyntaxTree_Expression
	Arguments     []AbstractSyntaxTree_Expression

} // CallFunction::A-Z..a-z()

func (*CallFunction_Expression_AbstractSyntaxTree) ExpressionLeafNode 

func (AstCall *CallFunction_Expression_AbstractSyntaxTree) ExpressionLeafNode()

func (*CallFunction_Expression_AbstractSyntaxTree) TokenConstructLiteral 

func (AstCallExp *CallFunction_Expression_AbstractSyntaxTree) TokenConstructLiteral() string

func (*CallFunction_Expression_AbstractSyntaxTree) TokenConstructToString 

func (AstCallExp *CallFunction_Expression_AbstractSyntaxTree) TokenConstructToString() string

type Constant_Statement_AbstractSyntaxTree 

type Constant_Statement_AbstractSyntaxTree struct {
	TokenRegister TokenRegistry
	Name          *Identifier_Expression_AbstractSyntaxTree
	Value         AbstractSyntaxTree_Expression

} // Constant

func (*Constant_Statement_AbstractSyntaxTree) SatatementLeafNode 

func (AstConstant *Constant_Statement_AbstractSyntaxTree) SatatementLeafNode()

func (*Constant_Statement_AbstractSyntaxTree) TokenConstructLiteral 

func (AstConstant *Constant_Statement_AbstractSyntaxTree) TokenConstructLiteral() string

func (*Constant_Statement_AbstractSyntaxTree) TokenConstructToString 

func (AstConstant *Constant_Statement_AbstractSyntaxTree) TokenConstructToString() string

type ENGINE_Expression_AbstractSyntaxTree 

type ENGINE_Expression_AbstractSyntaxTree struct {
	TokenRegister TokenRegistry
	Value         AbstractSyntaxTree_Expression
	SubUnits      []*INIT_Expression_AbstractSyntaxTree

} //ENGINE

func (*ENGINE_Expression_AbstractSyntaxTree) ExpressionLeafNode 

func (AstEngineENGINE *ENGINE_Expression_AbstractSyntaxTree) ExpressionLeafNode()

func (*ENGINE_Expression_AbstractSyntaxTree) TokenConstructLiteral 

func (AstENGINE *ENGINE_Expression_AbstractSyntaxTree) TokenConstructLiteral() string

func (*ENGINE_Expression_AbstractSyntaxTree) TokenConstructToString 

func (AstENGINE *ENGINE_Expression_AbstractSyntaxTree) TokenConstructToString() string

type Engine_Environment_Of_Environment 

type Engine_Environment_Of_Environment struct {
	StoreObj    map[string]SLC_Object
	ReadOnly    map[string]bool
	EngineOuter *Engine_Environment_Of_Environment
	PermitMod   []string
}

func Start_Engine_Enclosed_Environment 

func Start_Engine_Enclosed_Environment(OutterShell *Engine_Environment_Of_Environment) *Engine_Environment_Of_Environment

func Start_Engine_Environment_Create 

func Start_Engine_Environment_Create() *Engine_Environment_Of_Environment

func (*Engine_Environment_Of_Environment) Engine_Grab_Varname 

func (Env *Engine_Environment_Of_Environment) Engine_Grab_Varname(NameObj string) (SLC_Object, bool)

func (*Engine_Environment_Of_Environment) Engine_Set_Varname 

func (Env *Engine_Environment_Of_Environment) Engine_Set_Varname(NameObj string, Value SLC_Object) SLC_Object

func (*Engine_Environment_Of_Environment) StoreConstant 

func (Env *Engine_Environment_Of_Environment) StoreConstant(name string, Value SLC_Object) SLC_Object

type Engine_Prog 

type Engine_Prog struct {
	Statements []AbstractSyntaxTree_Statement
}

func (*Engine_Prog) TokenConstructLiteral 

func (Prog *Engine_Prog) TokenConstructLiteral() string

func (*Engine_Prog) TokenConstructToString 

func (Prog *Engine_Prog) TokenConstructToString() string

type EvaluationForModification 

type EvaluationForModification struct {
	System         string
	SystemSettings string
}

type Exportable 

type Exportable struct {
	ProjectData struct {
		Name        string   // Name of the project
		Description string   // Description
		SuportedOS  string   // Supported operating system
		Languages   string   // Language of the program
		Version     string   // Version of the program
		Require     []string // Libraries to register
	}
}
var Exportable_data Exportable

Exportable is data that can be read externally to SLC

type Expression_Statement_AbstractSyntaxTree 

type Expression_Statement_AbstractSyntaxTree struct {
	TokenRegister TokenRegistry
	Expression    AbstractSyntaxTree_Expression

} // expression statement

func (*Expression_Statement_AbstractSyntaxTree) SatatementLeafNode 

func (AstExpression *Expression_Statement_AbstractSyntaxTree) SatatementLeafNode()

func (*Expression_Statement_AbstractSyntaxTree) TokenConstructLiteral 

func (AstExpression *Expression_Statement_AbstractSyntaxTree) TokenConstructLiteral() string

func (*Expression_Statement_AbstractSyntaxTree) TokenConstructToString 

func (AstExpression *Expression_Statement_AbstractSyntaxTree) TokenConstructToString() string

type HashAbleInterface 

type HashAbleInterface interface {
	GrabHashKey() HashingKey
}

type HashingKey 

type HashingKey struct {
	Type  ObjectsDataType
	Value uint64
}

type INIT_Expression_AbstractSyntaxTree 

type INIT_Expression_AbstractSyntaxTree struct {
	TokenRegister TokenRegistry
	Default       bool
	Expression    []AbstractSyntaxTree_Expression
	Sub_UNIT      *BlockStatement_Statement_AbstractSyntaxTree

} //INIT

func (*INIT_Expression_AbstractSyntaxTree) ExpressionLeafNode 

func (AstEngineINIT *INIT_Expression_AbstractSyntaxTree) ExpressionLeafNode()

func (*INIT_Expression_AbstractSyntaxTree) TokenConstructLiteral 

func (AstINIT *INIT_Expression_AbstractSyntaxTree) TokenConstructLiteral() string

func (*INIT_Expression_AbstractSyntaxTree) TokenConstructToString 

func (AstINIT *INIT_Expression_AbstractSyntaxTree) TokenConstructToString() string

type Identifier_Expression_AbstractSyntaxTree 

type Identifier_Expression_AbstractSyntaxTree struct {
	TokenRegister TokenRegistry
	Value         string

} // IDENT::

func (*Identifier_Expression_AbstractSyntaxTree) ExpressionLeafNode 

func (AstIdentifier *Identifier_Expression_AbstractSyntaxTree) ExpressionLeafNode()

func (*Identifier_Expression_AbstractSyntaxTree) TokenConstructLiteral 

func (AstIdentifier *Identifier_Expression_AbstractSyntaxTree) TokenConstructLiteral() string

func (*Identifier_Expression_AbstractSyntaxTree) TokenConstructToString 

func (AstIdentifier *Identifier_Expression_AbstractSyntaxTree) TokenConstructToString() string

type IndexLit_Expression_AbstractSyntaxTree 

type IndexLit_Expression_AbstractSyntaxTree struct {
	TokenRegister TokenRegistry
	Left          AbstractSyntaxTree_Expression
	Index         AbstractSyntaxTree_Expression

} // Index::[1..INF]

func (*IndexLit_Expression_AbstractSyntaxTree) ExpressionLeafNode 

func (AstIndex *IndexLit_Expression_AbstractSyntaxTree) ExpressionLeafNode()

func (*IndexLit_Expression_AbstractSyntaxTree) TokenConstructLiteral 

func (AstIndexExp *IndexLit_Expression_AbstractSyntaxTree) TokenConstructLiteral() string

func (*IndexLit_Expression_AbstractSyntaxTree) TokenConstructToString 

func (AstIndexExp *IndexLit_Expression_AbstractSyntaxTree) TokenConstructToString() string

type InfixExpression_Expression_AbstractSyntaxTree 

type InfixExpression_Expression_AbstractSyntaxTree struct {
	TokenRegister TokenRegistry
	Left          AbstractSyntaxTree_Expression
	Operator      string
	Right         AbstractSyntaxTree_Expression

} // Inffix::

func (*InfixExpression_Expression_AbstractSyntaxTree) ExpressionLeafNode 

func (AstInfix *InfixExpression_Expression_AbstractSyntaxTree) ExpressionLeafNode()

func (*InfixExpression_Expression_AbstractSyntaxTree) TokenConstructLiteral 

func (AstInfixExp *InfixExpression_Expression_AbstractSyntaxTree) TokenConstructLiteral() string

func (*InfixExpression_Expression_AbstractSyntaxTree) TokenConstructToString 

func (AstInfixExp *InfixExpression_Expression_AbstractSyntaxTree) TokenConstructToString() string

type InfixParserFunctions 

type InfixParserFunctions func(AbstractSyntaxTree_Expression) AbstractSyntaxTree_Expression

type IntegerDataType_Expression_AbstractSyntaxTree 

type IntegerDataType_Expression_AbstractSyntaxTree struct {
	TokenRegister TokenRegistry
	Value         int64

} // Integer::1-9

func (*IntegerDataType_Expression_AbstractSyntaxTree) ExpressionLeafNode 

func (AstInteger *IntegerDataType_Expression_AbstractSyntaxTree) ExpressionLeafNode()

func (*IntegerDataType_Expression_AbstractSyntaxTree) TokenConstructLiteral 

func (AstInteger *IntegerDataType_Expression_AbstractSyntaxTree) TokenConstructLiteral() string

func (*IntegerDataType_Expression_AbstractSyntaxTree) TokenConstructToString 

func (AstInteger *IntegerDataType_Expression_AbstractSyntaxTree) TokenConstructToString() string

type Load_ProjectData 

type Load_ProjectData struct {
	ProjectInformation struct {
		Name        string `json:"Name"`
		Description string `json:"Description"`
		SupportedOS string `json:"Supported-OS"`
		Languages   string `json:"Languages"`
		Version     string `json:"Version"`
	} `json:"Project-Information"`
}

Load project data will all be data and variables and constants that will be pre loaded into the environment of the application when parsed.

When working with the engine in skyline, there will be a keyword which works similar to import but is rather ENGINE. When this keyword is found

and looks like ENGINE("main.slc") the parser will load and execute the engine, if the engine comes across a Project.json file within the respected

and expected directories, it will load the below structure which can then be accessed by SL external to SLC. Which means instead of setting variables

within the engine;s environment, you can register it within a projects environment.

type Load_Requirements 

type Load_Requirements struct {
	Requirements struct {
		Libraries       []string `json:"Libraries"`
		OperatingSystem string   `json:"Operating-System"`
		SLCVersion      string   `json:"SLC-Version"`
		SLVersion       string   `json:"SL-Version"`
	} `json:"Requirements"`
}

type ObjectArray 

type ObjectArray struct {
	Elements []SLC_Object
}

func (*ObjectArray) ObjectDataType 

func (ObjArray *ObjectArray) ObjectDataType() ObjectsDataType

func (*ObjectArray) ObjectInspectFunc 

func (ObjArray *ObjectArray) ObjectInspectFunc() string

type ObjectBUILTINFUNCTION 

type ObjectBUILTINFUNCTION struct {
	Function BuiltinFunction
}

func (*ObjectBUILTINFUNCTION) ObjectDataType 

func (ObjBuiltIn *ObjectBUILTINFUNCTION) ObjectDataType() ObjectsDataType

func (*ObjectBUILTINFUNCTION) ObjectInspectFunc 

func (ObjBuiltIn *ObjectBUILTINFUNCTION) ObjectInspectFunc() string

type ObjectBoolean 

type ObjectBoolean struct {
	Value bool
}

func (*ObjectBoolean) GrabHashKey 

func (ObjBoolean *ObjectBoolean) GrabHashKey() HashingKey

func (*ObjectBoolean) ObjectDataType 

func (ObjBoolean *ObjectBoolean) ObjectDataType() ObjectsDataType

func (*ObjectBoolean) ObjectInspectFunc 

func (ObjBoolean *ObjectBoolean) ObjectInspectFunc() string

type ObjectERROR 

type ObjectERROR struct {
	Message string
}

func (*ObjectERROR) ObjectDataType 

func (ObjErrorField *ObjectERROR) ObjectDataType() ObjectsDataType

func (*ObjectERROR) ObjectInspectFunc 

func (ObjERROR *ObjectERROR) ObjectInspectFunc() string

type ObjectInteger 

type ObjectInteger struct {
	Value int64
}

func (*ObjectInteger) GrabHashKey 

func (ObjInteger *ObjectInteger) GrabHashKey() HashingKey

func (*ObjectInteger) ObjectDataType 

func (ObjInteger *ObjectInteger) ObjectDataType() ObjectsDataType

func (*ObjectInteger) ObjectInspectFunc 

func (ObjInteger *ObjectInteger) ObjectInspectFunc() string

type ObjectNULL 

type ObjectNULL struct{}

func (*ObjectNULL) ObjectDataType 

func (ObjNullField *ObjectNULL) ObjectDataType() ObjectsDataType

func (*ObjectNULL) ObjectInspectFunc 

func (ObjNULL *ObjectNULL) ObjectInspectFunc() string

type ObjectString 

type ObjectString struct {
	Value string
}

func (*ObjectString) GrabHashKey 

func (ObjString *ObjectString) GrabHashKey() HashingKey

func (*ObjectString) ObjectDataType 

func (ObjString *ObjectString) ObjectDataType() ObjectsDataType

func (*ObjectString) ObjectInspectFunc 

func (ObjString *ObjectString) ObjectInspectFunc() string

type ObjectsDataType 

type ObjectsDataType string

type PrefixExpression_Expression_AbstractSyntaxTree 

type PrefixExpression_Expression_AbstractSyntaxTree struct {
	TokenRegister TokenRegistry
	Operator      string
	Right         AbstractSyntaxTree_Expression

} // Prefix::

func (*PrefixExpression_Expression_AbstractSyntaxTree) ExpressionLeafNode 

func (AstPrefix *PrefixExpression_Expression_AbstractSyntaxTree) ExpressionLeafNode()

func (*PrefixExpression_Expression_AbstractSyntaxTree) TokenConstructLiteral 

func (AstPrefixExp *PrefixExpression_Expression_AbstractSyntaxTree) TokenConstructLiteral() string

func (*PrefixExpression_Expression_AbstractSyntaxTree) TokenConstructToString 

func (AstPrefixExp *PrefixExpression_Expression_AbstractSyntaxTree) TokenConstructToString() string

type PrefixParserFunctions 

type PrefixParserFunctions func() AbstractSyntaxTree_Expression

type SLC_Object 

type SLC_Object interface {
	ObjectDataType() ObjectsDataType
	ObjectInspectFunc() string
}

func Eval 

func Eval(node AbstractSyntaxTree_Node, env *Engine_Environment_Of_Environment) SLC_Object

func S_Engine_Call_Load 

func S_Engine_Call_Load(arguments ...SLC_Object) SLC_Object

func S_Engine_Call_Loader_CheckerAndVerifier 

func S_Engine_Call_Loader_CheckerAndVerifier(filename string) SLC_Object

func S_Engine_Call_SYSTEM 

func S_Engine_Call_SYSTEM(arguments ...SLC_Object) SLC_Object

func SkyLine_Configuration_Engine_Evaluate_ApplicationalFunction 

func SkyLine_Configuration_Engine_Evaluate_ApplicationalFunction(fn SLC_Object, args []SLC_Object) SLC_Object

func SkyLine_Configuration_Engine_Evaluate_ArrayIndexExpression 

func SkyLine_Configuration_Engine_Evaluate_ArrayIndexExpression(array, index SLC_Object) SLC_Object

func SkyLine_Configuration_Engine_Evaluate_BlockStatement 

func SkyLine_Configuration_Engine_Evaluate_BlockStatement(block *BlockStatement_Statement_AbstractSyntaxTree, env *Engine_Environment_Of_Environment) SLC_Object

func SkyLine_Configuration_Engine_Evaluate_Expressions 

func SkyLine_Configuration_Engine_Evaluate_Expressions(exps []AbstractSyntaxTree_Expression, env *Engine_Environment_Of_Environment) []SLC_Object

func SkyLine_Configuration_Engine_Evaluate_Identifier 

func SkyLine_Configuration_Engine_Evaluate_Identifier(node *Identifier_Expression_AbstractSyntaxTree, env *Engine_Environment_Of_Environment) SLC_Object

func SkyLine_Configuration_Engine_Evaluate_IndexExpression 

func SkyLine_Configuration_Engine_Evaluate_IndexExpression(left, index SLC_Object) SLC_Object

func SkyLine_Configuration_Engine_Evaluate_InfixExpression 

func SkyLine_Configuration_Engine_Evaluate_InfixExpression(
	operator string,
	left, right SLC_Object,
) SLC_Object

func SkyLine_Configuration_Engine_Evaluate_Iniation 

func SkyLine_Configuration_Engine_Evaluate_Iniation(se *ENGINE_Expression_AbstractSyntaxTree, env *Engine_Environment_Of_Environment) SLC_Object

func SkyLine_Configuration_Engine_Evaluate_Program 

func SkyLine_Configuration_Engine_Evaluate_Program(program *Engine_Prog, env *Engine_Environment_Of_Environment) SLC_Object

func SkyLine_Configuration_Engine_Evaluate_StringInfixExpression 

func SkyLine_Configuration_Engine_Evaluate_StringInfixExpression(operator string, left, right SLC_Object) SLC_Object

type SLC_Parser_Structure 

type SLC_Parser_Structure struct {
	Scanner              ScannnerInterface
	EngineErrors         []string
	CurrentToken         TokenRegistry
	PeekToken            TokenRegistry
	PrefixParseFunctions map[TokenDataType]PrefixParserFunctions
	InfixParseFunctions  map[TokenDataType]InfixParserFunctions
}

func NewParser 

func NewParser(Scanner *ScannerStructureRegister) *SLC_Parser_Structure

func (*SLC_Parser_Structure) ENGINE_CURRENT_TOKEN_IS_THIS 

func (SLC_Parser *SLC_Parser_Structure) ENGINE_CURRENT_TOKEN_IS_THIS(t TokenDataType) bool

func (*SLC_Parser_Structure) ENGINE_EXPECT_PEEK 

func (SLC_Parser *SLC_Parser_Structure) ENGINE_EXPECT_PEEK(t TokenDataType) bool

func (*SLC_Parser_Structure) ENGINE_PARSER_LOAD_NEXT_FAULT_TOKEN 

func (SLC_Parser *SLC_Parser_Structure) ENGINE_PARSER_LOAD_NEXT_FAULT_TOKEN()

func (*SLC_Parser_Structure) ENGINE_PEEK_TOKEN_IS_THIS 

func (SLC_Parser *SLC_Parser_Structure) ENGINE_PEEK_TOKEN_IS_THIS(t TokenDataType) bool

func (*SLC_Parser_Structure) ENGINE_UNIT_CALL_PARSE_FUNCTION_ARRAY 

func (SLC_Parser *SLC_Parser_Structure) ENGINE_UNIT_CALL_PARSE_FUNCTION_ARRAY() AbstractSyntaxTree_Expression

func (*SLC_Parser_Structure) ENGINE_UNIT_CALL_PARSE_FUNCTION_BOOLEAN_TRUTHY 

func (SLC_Parser *SLC_Parser_Structure) ENGINE_UNIT_CALL_PARSE_FUNCTION_BOOLEAN_TRUTHY() AbstractSyntaxTree_Expression

func (*SLC_Parser_Structure) ENGINE_UNIT_CALL_PARSE_FUNCTION_BRACKET_ENGINE_KEY_SECTOR 

func (SLC_Parser *SLC_Parser_Structure) ENGINE_UNIT_CALL_PARSE_FUNCTION_BRACKET_ENGINE_KEY_SECTOR() AbstractSyntaxTree_Expression

func (*SLC_Parser_Structure) ENGINE_UNIT_CALL_PARSE_FUNCTION_CALL_EXPRESSION 

func (SLC_Parser *SLC_Parser_Structure) ENGINE_UNIT_CALL_PARSE_FUNCTION_CALL_EXPRESSION(function AbstractSyntaxTree_Expression) AbstractSyntaxTree_Expression

func (*SLC_Parser_Structure) ENGINE_UNIT_CALL_PARSE_FUNCTION_CONSTANT_STATEMENT 

func (SLC_Parser *SLC_Parser_Structure) ENGINE_UNIT_CALL_PARSE_FUNCTION_CONSTANT_STATEMENT() *Constant_Statement_AbstractSyntaxTree

parseConstStatement parses a constant declaration.

func (*SLC_Parser_Structure) ENGINE_UNIT_CALL_PARSE_FUNCTION_ENGINE_SECTOR 

func (SLC_Parser *SLC_Parser_Structure) ENGINE_UNIT_CALL_PARSE_FUNCTION_ENGINE_SECTOR() AbstractSyntaxTree_Expression

func (*SLC_Parser_Structure) ENGINE_UNIT_CALL_PARSE_FUNCTION_ENGINE_UNIT_BLOCK_STATEMENTS 

func (SLC_Parser *SLC_Parser_Structure) ENGINE_UNIT_CALL_PARSE_FUNCTION_ENGINE_UNIT_BLOCK_STATEMENTS() *BlockStatement_Statement_AbstractSyntaxTree

func (*SLC_Parser_Structure) ENGINE_UNIT_CALL_PARSE_FUNCTION_EXPRESSION_LIST 

func (SLC_Parser *SLC_Parser_Structure) ENGINE_UNIT_CALL_PARSE_FUNCTION_EXPRESSION_LIST(end TokenDataType) []AbstractSyntaxTree_Expression

func (*SLC_Parser_Structure) ENGINE_UNIT_CALL_PARSE_FUNCTION_EXPRESSION_STATEMENT 

func (SLC_Parser *SLC_Parser_Structure) ENGINE_UNIT_CALL_PARSE_FUNCTION_EXPRESSION_STATEMENT() *Expression_Statement_AbstractSyntaxTree

func (*SLC_Parser_Structure) ENGINE_UNIT_CALL_PARSE_FUNCTION_GROUPED_LIST_EXPRESSION 

func (SLC_Parser *SLC_Parser_Structure) ENGINE_UNIT_CALL_PARSE_FUNCTION_GROUPED_LIST_EXPRESSION() AbstractSyntaxTree_Expression

func (*SLC_Parser_Structure) ENGINE_UNIT_CALL_PARSE_FUNCTION_IDENTIFIER 

func (SLC_Parser *SLC_Parser_Structure) ENGINE_UNIT_CALL_PARSE_FUNCTION_IDENTIFIER() AbstractSyntaxTree_Expression

func (*SLC_Parser_Structure) ENGINE_UNIT_CALL_PARSE_FUNCTION_INDEX_EXPRESSION 

func (SLC_Parser *SLC_Parser_Structure) ENGINE_UNIT_CALL_PARSE_FUNCTION_INDEX_EXPRESSION(left AbstractSyntaxTree_Expression) AbstractSyntaxTree_Expression

func (*SLC_Parser_Structure) ENGINE_UNIT_CALL_PARSE_FUNCTION_INFIX_EXPRESSION 

func (SLC_Parser *SLC_Parser_Structure) ENGINE_UNIT_CALL_PARSE_FUNCTION_INFIX_EXPRESSION(left AbstractSyntaxTree_Expression) AbstractSyntaxTree_Expression

func (*SLC_Parser_Structure) ENGINE_UNIT_CALL_PARSE_FUNCTION_INTEGER 

func (SLC_Parser *SLC_Parser_Structure) ENGINE_UNIT_CALL_PARSE_FUNCTION_INTEGER() AbstractSyntaxTree_Expression

func (*SLC_Parser_Structure) ENGINE_UNIT_CALL_PARSE_FUNCTION_PARSE_EXPRESSION 

func (SLC_Parser *SLC_Parser_Structure) ENGINE_UNIT_CALL_PARSE_FUNCTION_PARSE_EXPRESSION(precedence int) AbstractSyntaxTree_Expression

func (*SLC_Parser_Structure) ENGINE_UNIT_CALL_PARSE_FUNCTION_PREFIX_EXPRESSION 

func (SLC_Parser *SLC_Parser_Structure) ENGINE_UNIT_CALL_PARSE_FUNCTION_PREFIX_EXPRESSION() AbstractSyntaxTree_Expression

func (*SLC_Parser_Structure) ENGINE_UNIT_CALL_PARSE_FUNCTION_STATEMENT 

func (SLC_Parser *SLC_Parser_Structure) ENGINE_UNIT_CALL_PARSE_FUNCTION_STATEMENT() AbstractSyntaxTree_Statement

func (*SLC_Parser_Structure) ENGINE_UNIT_CALL_PARSE_FUNCTION_STRING 

func (SLC_Parser *SLC_Parser_Structure) ENGINE_UNIT_CALL_PARSE_FUNCTION_STRING() AbstractSyntaxTree_Expression

func (*SLC_Parser_Structure) ENGINE_UNIT_CALL_PARSE_FUNCTION_VARIABLE_DECL 

func (SLC_Parser *SLC_Parser_Structure) ENGINE_UNIT_CALL_PARSE_FUNCTION_VARIABLE_DECL() *Assignment_Statement_AbstractSyntaxTree

func (*SLC_Parser_Structure) Errors 

func (SLC_Parser *SLC_Parser_Structure) Errors() []string

func (*SLC_Parser_Structure) ParseProgram 

func (SLC_Parser *SLC_Parser_Structure) ParseProgram() *Engine_Prog

type ScannerStructureRegister 

type ScannerStructureRegister struct {
	CharInput        string
	POS              int
	RPOS             int
	Char             byte
	Chars            []rune
	PreviousRegistry TokenRegistry
	PrevCh           byte
}

func New 

func New(input string) *ScannerStructureRegister

func (*ScannerStructureRegister) ConsumeComment 

func (Scanner *ScannerStructureRegister) ConsumeComment()

func (*ScannerStructureRegister) ConsumeMultiLineComment 

func (Scanner *ScannerStructureRegister) ConsumeMultiLineComment()

func (*ScannerStructureRegister) ConsumeWhiteSpace 

func (Scanner *ScannerStructureRegister) ConsumeWhiteSpace()

func (*ScannerStructureRegister) NT 

func (Scanner *ScannerStructureRegister) NT() TokenRegistry

func (*ScannerStructureRegister) Peek 

func (Scanner *ScannerStructureRegister) Peek() byte

Helps peek the next token

func (*ScannerStructureRegister) RDIGIT 

func (Scanner *ScannerStructureRegister) RDIGIT() string

Helps to read the digits within the code

func (*ScannerStructureRegister) READ 

func (Scanner *ScannerStructureRegister) READ(VerificationFunc func(byte) bool) string

Helps to read various data based on its input checking function

func (*ScannerStructureRegister) RIDENT 

func (Scanner *ScannerStructureRegister) RIDENT() string

Helps to read the identifiers within the code

func (*ScannerStructureRegister) RINT 

func (Scanner *ScannerStructureRegister) RINT() TokenRegistry

Helps to read the integers being parsed

func (*ScannerStructureRegister) RNTCS 

func (Scanner *ScannerStructureRegister) RNTCS() TokenRegistry

func (*ScannerStructureRegister) RSTR 

func (Scanner *ScannerStructureRegister) RSTR() string

Helps to read strings and return control characters

type ScannnerInterface 

type ScannnerInterface interface {
	NT() TokenRegistry
}

type StringDataType_Expression_AbstractSyntaxTree 

type StringDataType_Expression_AbstractSyntaxTree struct {
	TokenRegister TokenRegistry
	Value         string

} // String::""

func (*StringDataType_Expression_AbstractSyntaxTree) ExpressionLeafNode 

func (AstString *StringDataType_Expression_AbstractSyntaxTree) ExpressionLeafNode()

func (*StringDataType_Expression_AbstractSyntaxTree) TokenConstructLiteral 

func (AstString *StringDataType_Expression_AbstractSyntaxTree) TokenConstructLiteral() string

func (*StringDataType_Expression_AbstractSyntaxTree) TokenConstructToString 

func (AstString *StringDataType_Expression_AbstractSyntaxTree) TokenConstructToString() string

type TokenDataType 

type TokenDataType string

func SL_IDENT_LOOKUP 

func SL_IDENT_LOOKUP(identifier string) TokenDataType

type TokenRegistry 

type TokenRegistry struct {
	TokenDataType TokenDataType
	Literal       string
}

func RegisterToken 

func RegisterToken(TT TokenDataType, char byte) TokenRegistry

Source Files

View all Source files

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.