parsers

package
v0.0.0-...-e95280a Latest Latest
Warning

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

 Go to latest Published: Jun 19, 2021 License: MIT Imports: 9 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func NewWhiteSpaceEvent 

func NewWhiteSpaceEvent(wsChannelName string) (lexers.Event, error)

NewWhiteSpaceEvent creates a new whiteSpace event

Types

type Application 

type Application interface {
	Head() HeadSection
	Main() MainSection
	HasLabel() bool
	Label() LabelSection
	HasTest() bool
	Test() TestSection
}

Application represents an application

type ApplicationBuilder 

type ApplicationBuilder interface {
	Create() ApplicationBuilder
	WithHead(head HeadSection) ApplicationBuilder
	WithLabel(label LabelSection) ApplicationBuilder
	WithMain(main MainSection) ApplicationBuilder
	WithTest(test TestSection) ApplicationBuilder
	Now() (Application, error)
}

ApplicationBuilder represents the application builder

func NewApplicationBuilder 

func NewApplicationBuilder() ApplicationBuilder

NewApplicationBuilder creates a new application builder

type Arythmetic 

type Arythmetic interface {
	IsAdd() bool
	Add() StandardOperation
	IsSub() bool
	Sub() StandardOperation
	IsMul() bool
	Mul() StandardOperation
	IsDiv() bool
	Div() RemainingOperation
}

Arythmetic represents an arythmetic operation instruction

type ArythmeticBuilder 

type ArythmeticBuilder interface {
	Create() ArythmeticBuilder
	WithAddition(add StandardOperation) ArythmeticBuilder
	WithSubstraction(sub StandardOperation) ArythmeticBuilder
	WithMultiplication(mul StandardOperation) ArythmeticBuilder
	WithDivision(div RemainingOperation) ArythmeticBuilder
	Now() (Arythmetic, error)
}

ArythmeticBuilder represents an arythmetic builder

func NewArythmeticBuilder 

func NewArythmeticBuilder() ArythmeticBuilder

NewArythmeticBuilder creates a new arythmetic builder

type Assert 

type Assert interface {
	Index() int
	HasCondition() bool
	Condition() string
}

Assert represents an assert

type AssertBuilder 

type AssertBuilder interface {
	Create() AssertBuilder
	WithIndex(index int) AssertBuilder
	WithCondition(condition string) AssertBuilder
	Now() (Assert, error)
}

AssertBuilder represents an assert builder

func NewAssertBuilder 

func NewAssertBuilder() AssertBuilder

NewAssertBuilder creates a new assert builder

type Assignment 

type Assignment interface {
	Variable() string
	Value() ValueRepresentation
}

Assignment represents a variable assignment instruction

type AssignmentBuilder 

type AssignmentBuilder interface {
	Create() AssignmentBuilder
	WithVariable(variable string) AssignmentBuilder
	WithValue(value ValueRepresentation) AssignmentBuilder
	Now() (Assignment, error)
}

AssignmentBuilder represents an assignment builder

func NewAssignmentBuilder 

func NewAssignmentBuilder() AssignmentBuilder

NewAssignmentBuilder creates a new assignment builder

type Call 

type Call interface {
	Name() string
	StackFrame() string
	HasCondition() bool
	Condition() string
}

Call represents a call instruction

type CallBuilder 

type CallBuilder interface {
	Create() CallBuilder
	WithName(name string) CallBuilder
	WithStackFrame(stackFrame string) CallBuilder
	WithCondition(condition string) CallBuilder
	Now() (Call, error)
}

CallBuilder represents a call builder

func NewCallBuilder 

func NewCallBuilder() CallBuilder

NewCallBuilder creates a new call builder

type CodeMatch 

type CodeMatch interface {
	Content() string
	Section() string
	PatternVariables() []string
}

CodeMatch represents code match

type CodeMatchBuilder 

type CodeMatchBuilder interface {
	Create() CodeMatchBuilder
	WithContent(content string) CodeMatchBuilder
	WithSection(section string) CodeMatchBuilder
	WithPatternVariables(patterns []string) CodeMatchBuilder
	Now() (CodeMatch, error)
}

CodeMatchBuilder represents a codeMatch builder

func NewCodeMatchBuilder 

func NewCodeMatchBuilder() CodeMatchBuilder

NewCodeMatchBuilder creates a new code match builder

type Command 

type Command interface {
	IsLanguage() bool
	Language() LanguageCommand
	IsScript() bool
	Script() ScriptCommand
	IsHead() bool
	Head() HeadCommand
	IsMain() bool
	Main() MainCommand
	IsLabel() bool
	Label() LabelCommand
	IsTest() bool
	Test() TestCommand
}

Command represents a command

type CommandBuilder 

type CommandBuilder interface {
	Create() CommandBuilder
	WithLanguage(language LanguageCommand) CommandBuilder
	WithScript(script ScriptCommand) CommandBuilder
	WithHead(head HeadCommand) CommandBuilder
	WithMain(main MainCommand) CommandBuilder
	WithLabel(label LabelCommand) CommandBuilder
	WithTest(test TestCommand) CommandBuilder
	Now() (Command, error)
}

CommandBuilder represents a command builder

func NewCommandBuilder 

func NewCommandBuilder() CommandBuilder

NewCommandBuilder creates a new command builder

type Concatenation 

type Concatenation interface {
	Operation() StandardOperation
}

Concatenation represents a concatenation

type ConcatenationBuilder 

type ConcatenationBuilder interface {
	Create() ConcatenationBuilder
	WithOperation(operation StandardOperation) ConcatenationBuilder
	Now() (Concatenation, error)
}

ConcatenationBuilder represents a concatenation builder

func NewConcatenationBuilder 

func NewConcatenationBuilder() ConcatenationBuilder

NewConcatenationBuilder creates a new concatenation builder

type Declaration 

type Declaration interface {
	Variable() string
	Type() Type
}

Declaration represents a variable declaration instruction

type DeclarationBuilder 

type DeclarationBuilder interface {
	Create() DeclarationBuilder
	WithVariable(name string) DeclarationBuilder
	WithType(typ Type) DeclarationBuilder
	Now() (Declaration, error)
}

DeclarationBuilder represents a declaration builder

func NewDeclarationBuilder 

func NewDeclarationBuilder() DeclarationBuilder

NewDeclarationBuilder creates a new declaration builder

type Executable 

type Executable interface {
	IsApplication() bool
	Application() Application
	IsScript() bool
	Script() Script
}

Executable represents an executable program

type ExecutableBuilder 

type ExecutableBuilder interface {
	Create() ExecutableBuilder
	WithApplication(application Application) ExecutableBuilder
	WithScript(script Script) ExecutableBuilder
	Now() (Executable, error)
}

ExecutableBuilder represents an executable builder

func NewExecutableBuilder 

func NewExecutableBuilder() ExecutableBuilder

NewExecutableBuilder creates a new executable builder

type Exit 

type Exit interface {
	HasCondition() bool
	Condition() string
}

Exit represents an exit instruction

type ExitBuilder 

type ExitBuilder interface {
	Create() ExitBuilder
	WithCondition(cond string) ExitBuilder
	Now() (Exit, error)
}

ExitBuilder represents an exit builder

func NewExitBuilder 

func NewExitBuilder() ExitBuilder

NewExitBuilder creates a new exit builder

type FetchRegistry 

type FetchRegistry interface {
	To() string
	From() string
	HasIndex() bool
	Index() IntPointer
}

FetchRegistry represents a fetch registry instruction

type FetchRegistryBuilder 

type FetchRegistryBuilder interface {
	Create() FetchRegistryBuilder
	From(from string) FetchRegistryBuilder
	To(to string) FetchRegistryBuilder
	WithIndex(index IntPointer) FetchRegistryBuilder
	Now() (FetchRegistry, error)
}

FetchRegistryBuilder represents a fetch registry builder

func NewFetchRegistryBuilder 

func NewFetchRegistryBuilder() FetchRegistryBuilder

NewFetchRegistryBuilder creates a new fetch registry builder

type FolderName 

type FolderName interface {
	IsCurrent() bool
	IsPrevious() bool
	IsName() bool
	Name() string
	String() string
}

FolderName represents a folder name

type FolderNameBuilder 

type FolderNameBuilder interface {
	Create() FolderNameBuilder
	IsCurrent() FolderNameBuilder
	IsPrevious() FolderNameBuilder
	WithName(name string) FolderNameBuilder
	Now() (FolderName, error)
}

FolderNameBuilder represents a folderName builder

func NewFolderNameBuilder 

func NewFolderNameBuilder() FolderNameBuilder

NewFolderNameBuilder creates a new folder name builder

type FolderSection 

type FolderSection interface {
	IsTail() bool
	Name() FolderName
	String() string
}

FolderSection represents a folder section

type FolderSectionBuilder 

type FolderSectionBuilder interface {
	Create() FolderSectionBuilder
	IsTail() FolderSectionBuilder
	WithName(name FolderName) FolderSectionBuilder
	Now() (FolderSection, error)
}

FolderSectionBuilder represents a folder section builder

func NewFolderSectionBuilder 

func NewFolderSectionBuilder() FolderSectionBuilder

NewFolderSectionBuilder creates a new folder section builder

type HeadCommand 

type HeadCommand interface {
	Variable() string
	Values() []HeadValue
}

HeadCommand represents a head command

type HeadCommandBuilder 

type HeadCommandBuilder interface {
	Create() HeadCommandBuilder
	WithVariable(variable string) HeadCommandBuilder
	WithValues(values []HeadValue) HeadCommandBuilder
	Now() (HeadCommand, error)
}

HeadCommandBuilder represents an head command builder

func NewHeadCommandBuilder 

func NewHeadCommandBuilder() HeadCommandBuilder

NewHeadCommandBuilder creates a new head command builder

type HeadSection 

type HeadSection interface {
	Name() string
	Version() string
	HasImport() bool
	Import() []ImportSingle
	HasLoad() bool
	Load() []LoadSingle
}

HeadSection represents the headSection

type HeadSectionBuilder 

type HeadSectionBuilder interface {
	Create() HeadSectionBuilder
	WithValues(values []HeadValue) HeadSectionBuilder
	Now() (HeadSection, error)
}

HeadSectionBuilder represents the headSection builder

func NewHeadSectionBuilder 

func NewHeadSectionBuilder() HeadSectionBuilder

NewHeadSectionBuilder creates a new head section builder

type HeadValue 

type HeadValue interface {
	IsName() bool
	Name() string
	IsVersion() bool
	Version() string
	IsImport() bool
	Import() []ImportSingle
	IsLoad() bool
	Load() []LoadSingle
}

HeadValue represents the head value

type HeadValueBuilder 

type HeadValueBuilder interface {
	Create() HeadValueBuilder
	WithName(name string) HeadValueBuilder
	WithVersion(version string) HeadValueBuilder
	WithImport(imp []ImportSingle) HeadValueBuilder
	WithLoad(load []LoadSingle) HeadValueBuilder
	Now() (HeadValue, error)
}

HeadValueBuilder represents the headValue builder

func NewHeadValueBuilder 

func NewHeadValueBuilder() HeadValueBuilder

NewHeadValueBuilder creates a new head value builder

type ImportSingle 

type ImportSingle interface {
	Name() string
	Path() RelativePath
}

ImportSingle represents an import single

type ImportSingleBuilder 

type ImportSingleBuilder interface {
	Create() ImportSingleBuilder
	WithName(name string) ImportSingleBuilder
	WithPath(path RelativePath) ImportSingleBuilder
	Now() (ImportSingle, error)
}

ImportSingleBuilder represents an import single builder

func NewImportSingleBuilder 

func NewImportSingleBuilder() ImportSingleBuilder

NewImportSingleBuilder creates a new import single builder

type Index 

type Index interface {
	Variable() string
}

Index represents an index

type IndexBuilder 

type IndexBuilder interface {
	Create() IndexBuilder
	WithVariable(variable string) IndexBuilder
	Now() (Index, error)
}

IndexBuilder represents an index builder

func NewIndexBuilder 

func NewIndexBuilder() IndexBuilder

NewIndexBuilder creates a new index builder

type Instruction 

type Instruction interface {
	IsVariable() bool
	Variable() Variable
	IsOperation() bool
	Operation() Operation
	IsPrint() bool
	Print() Print
	IsStackFrame() bool
	StackFrame() StackFrame
	IsJump() bool
	Jump() Jump
	IsExit() bool
	Exit() Exit
	IsCall() bool
	Call() Call
	IsModule() bool
	Module() Module
	IsRegistry() bool
	Registry() Registry
	IsSwitch() bool
	Switch() Switch
	IsSave() bool
	Save() Save
}

Instruction represents an instruction

type InstructionBuilder 

type InstructionBuilder interface {
	Create() InstructionBuilder
	WithVariable(variable Variable) InstructionBuilder
	WithOperation(operation Operation) InstructionBuilder
	WithPrint(print Print) InstructionBuilder
	WithStackFrame(stackFrame StackFrame) InstructionBuilder
	WithJump(jmp Jump) InstructionBuilder
	WithExit(exit Exit) InstructionBuilder
	WithCall(call Call) InstructionBuilder
	WithModule(module Module) InstructionBuilder
	WithRegistry(registry Registry) InstructionBuilder
	WithSwitch(swtch Switch) InstructionBuilder
	WithSave(save Save) InstructionBuilder
	Now() (Instruction, error)
}

InstructionBuilder represents an instruction builder

func NewInstructionBuilder 

func NewInstructionBuilder() InstructionBuilder

NewInstructionBuilder creates a new instruction builder

type IntPointer 

type IntPointer interface {
	IsInt() bool
	Int() int64
	IsVariable() bool
	Variable() string
}

IntPointer represents an int pointer

type IntPointerBuilder 

type IntPointerBuilder interface {
	Create() IntPointerBuilder
	WithInt(intVal int64) IntPointerBuilder
	WithVariable(variable string) IntPointerBuilder
	Now() (IntPointer, error)
}

IntPointerBuilder represents an int pointer builder

func NewIntPointerBuilder 

func NewIntPointerBuilder() IntPointerBuilder

NewIntPointerBuilder creates a new int pointer builder

type Jump 

type Jump interface {
	Label() string
	HasCondition() bool
	Condition() string
}

Jump represents a jump instruction

type JumpBuilder 

type JumpBuilder interface {
	Create() JumpBuilder
	WithLabel(label string) JumpBuilder
	WithCondition(condition string) JumpBuilder
	Now() (Jump, error)
}

JumpBuilder represents a jump builder

func NewJumpBuilder 

func NewJumpBuilder() JumpBuilder

NewJumpBuilder creates a new jump builder

type LabelCommand 

type LabelCommand interface {
	Variable() string
	Name() string
	Instructions() []LabelCommandInstruction
}

LabelCommand represents a label command

type LabelCommandBuilder 

type LabelCommandBuilder interface {
	Create() LabelCommandBuilder
	WithVariable(variable string) LabelCommandBuilder
	WithName(name string) LabelCommandBuilder
	WithInstructions(ins []LabelCommandInstruction) LabelCommandBuilder
	Now() (LabelCommand, error)
}

LabelCommandBuilder represents a label command builder

func NewLabelCommandBuilder 

func NewLabelCommandBuilder() LabelCommandBuilder

NewLabelCommandBuilder creates a new label command builder

type LabelCommandInstruction 

type LabelCommandInstruction interface {
	Instruction() LabelInstruction
	HasScopes() bool
	Scopes() Scopes
}

LabelCommandInstruction represents a label command instruction

type LabelCommandInstructionBuilder 

type LabelCommandInstructionBuilder interface {
	Create() LabelCommandInstructionBuilder
	WithInstruction(ins LabelInstruction) LabelCommandInstructionBuilder
	WithScopes(scopes Scopes) LabelCommandInstructionBuilder
	Now() (LabelCommandInstruction, error)
}

LabelCommandInstructionBuilder represents a label command instruction builder

func NewLabelCommandInstructionBuilder 

func NewLabelCommandInstructionBuilder() LabelCommandInstructionBuilder

NewLabelCommandInstructionBuilder creates a new label command instruction builder

type LabelDeclaration 

type LabelDeclaration interface {
	Name() string
	Instructions() []LabelInstruction
}

LabelDeclaration represents the label declaration

type LabelDeclarationBuilder 

type LabelDeclarationBuilder interface {
	Create() LabelDeclarationBuilder
	WithName(name string) LabelDeclarationBuilder
	WithInstructions(ins []LabelInstruction) LabelDeclarationBuilder
	Now() (LabelDeclaration, error)
}

LabelDeclarationBuilder represents the labelDeclaration builder

func NewLabelDeclarationBuilder 

func NewLabelDeclarationBuilder() LabelDeclarationBuilder

NewLabelDeclarationBuilder creates a new label declaration builder

type LabelInstruction 

type LabelInstruction interface {
	IsRet() bool
	IsInstruction() bool
	Instruction() Instruction
}

LabelInstruction represents the label instruction

type LabelInstructionBuilder 

type LabelInstructionBuilder interface {
	Create() LabelInstructionBuilder
	IsRet() LabelInstructionBuilder
	WithInstruction(ins Instruction) LabelInstructionBuilder
	Now() (LabelInstruction, error)
}

LabelInstructionBuilder represents the label instruction builder

func NewLabelInstructonBuilder 

func NewLabelInstructonBuilder() LabelInstructionBuilder

NewLabelInstructonBuilder creates a new label instruction builder

type LabelSection 

type LabelSection interface {
	Declarations() []LabelDeclaration
}

LabelSection represents the label section

type LabelSectionBuilder 

type LabelSectionBuilder interface {
	Create() LabelSectionBuilder
	WithDeclarations(decl []LabelDeclaration) LabelSectionBuilder
	Now() (LabelSection, error)
}

LabelSectionBuilder represents the labelSection builder

func NewLabelSectionBuilder 

func NewLabelSectionBuilder() LabelSectionBuilder

NewLabelSectionBuilder creates a new label section builder

type LanguageApplication 

type LanguageApplication interface {
	Head() HeadSection
	Labels() LanguageLabelSection
	Main() LanguageMainSection
	HasTests() bool
	Tests() LanguageTestSection
}

LanguageApplication represents a language application

type LanguageApplicationBuilder 

type LanguageApplicationBuilder interface {
	Create() LanguageApplicationBuilder
	WithHead(head HeadSection) LanguageApplicationBuilder
	WithLabels(labels LanguageLabelSection) LanguageApplicationBuilder
	WithMain(main LanguageMainSection) LanguageApplicationBuilder
	WithTests(tests LanguageTestSection) LanguageApplicationBuilder
	Now() (LanguageApplication, error)
}

LanguageApplicationBuilder represents a language application builder

func NewLanguageApplicationBuilder 

func NewLanguageApplicationBuilder() LanguageApplicationBuilder

NewLanguageApplicationBuilder creates a new language application builder

type LanguageCommand 

type LanguageCommand interface {
	Variable() string
	Values() []LanguageValue
}

LanguageCommand represents a language command

type LanguageCommandBuilder 

type LanguageCommandBuilder interface {
	Create() LanguageCommandBuilder
	WithVariable(variable string) LanguageCommandBuilder
	WithValues(values []LanguageValue) LanguageCommandBuilder
	Now() (LanguageCommand, error)
}

LanguageCommandBuilder represents a language command builder

func NewLanguageCommandBuilder 

func NewLanguageCommandBuilder() LanguageCommandBuilder

NewLanguageCommandBuilder creates a new language command builder

type LanguageDefinition 

type LanguageDefinition interface {
	Root() string
	Tokens() RelativePath
	Rules() RelativePath
	Logic() RelativePath
	Input() string
	HasChannels() bool
	Channels() RelativePath
	HasExtends() bool
	Extends() []RelativePath
	HasPatternMatches() bool
	PatternMatches() []PatternMatch
}

LanguageDefinition represents a language definition

type LanguageDefinitionBuilder 

type LanguageDefinitionBuilder interface {
	Create() LanguageDefinitionBuilder
	WithValues(values []LanguageValue) LanguageDefinitionBuilder
	Now() (LanguageDefinition, error)
}

LanguageDefinitionBuilder represents the language definition builder

func NewLanguageDefinitionBuilder 

func NewLanguageDefinitionBuilder() LanguageDefinitionBuilder

NewLanguageDefinitionBuilder creates a new language definition builder

type LanguageInstruction 

type LanguageInstruction interface {
	IsInstruction() bool
	Instruction() LanguageInstructionCommon
	IsCommand() bool
	Command() Command
}

LanguageInstruction represents a language instruction

type LanguageInstructionBuilder 

type LanguageInstructionBuilder interface {
	Create() LanguageInstructionBuilder
	WithInstruction(ins LanguageInstructionCommon) LanguageInstructionBuilder
	WithCommand(command Command) LanguageInstructionBuilder
	Now() (LanguageInstruction, error)
}

LanguageInstructionBuilder represents a language instruction builder

func NewLanguageInstructionBuilder 

func NewLanguageInstructionBuilder() LanguageInstructionBuilder

NewLanguageInstructionBuilder creates a new language instruction builder

type LanguageInstructionCommon 

type LanguageInstructionCommon interface {
	IsInstruction() bool
	Instruction() Instruction
	IsMatch() bool
	Match() Match
}

LanguageInstructionCommon represents a language instruction common

type LanguageInstructionCommonBuilder 

type LanguageInstructionCommonBuilder interface {
	Create() LanguageInstructionCommonBuilder
	WithInstruction(ins Instruction) LanguageInstructionCommonBuilder
	WithMatch(match Match) LanguageInstructionCommonBuilder
	Now() (LanguageInstructionCommon, error)
}

LanguageInstructionCommonBuilder represents a language instruction common builder

func NewLanguageInstructionCommonBuilder 

func NewLanguageInstructionCommonBuilder() LanguageInstructionCommonBuilder

NewLanguageInstructionCommonBuilder creates a new language instruction common builder

type LanguageLabelDeclaration 

type LanguageLabelDeclaration interface {
	Name() string
	Instructions() []LanguageLabelInstruction
}

LanguageLabelDeclaration represents a language label declaration

type LanguageLabelDeclarationBuilder 

type LanguageLabelDeclarationBuilder interface {
	Create() LanguageLabelDeclarationBuilder
	WithName(name string) LanguageLabelDeclarationBuilder
	WithInstructions(instructions []LanguageLabelInstruction) LanguageLabelDeclarationBuilder
	Now() (LanguageLabelDeclaration, error)
}

LanguageLabelDeclarationBuilder represents a language label declaration builder

func NewLanguageLabelDeclarationBuilder 

func NewLanguageLabelDeclarationBuilder() LanguageLabelDeclarationBuilder

NewLanguageLabelDeclarationBuilder creates a new language label declaration builder

type LanguageLabelInstruction 

type LanguageLabelInstruction interface {
	IsLanguageInstruction() bool
	LanguageInstruction() LanguageInstruction
	IsLabelInstruction() bool
	LabelInstruction() LabelInstruction
	IsToken() bool
	Token() Token
}

LanguageLabelInstruction represents a language label instruction

type LanguageLabelInstructionBuilder 

type LanguageLabelInstructionBuilder interface {
	Create() LanguageLabelInstructionBuilder
	WithLanguageInstruction(languageInstruction LanguageInstruction) LanguageLabelInstructionBuilder
	WithLabelInstruction(labelInstruction LabelInstruction) LanguageLabelInstructionBuilder
	WithToken(token Token) LanguageLabelInstructionBuilder
	Now() (LanguageLabelInstruction, error)
}

LanguageLabelInstructionBuilder represents a language label instruction builder

func NewLanguageLabelInstructionBuilder 

func NewLanguageLabelInstructionBuilder() LanguageLabelInstructionBuilder

NewLanguageLabelInstructionBuilder creates a new language label instruction builder

type LanguageLabelSection 

type LanguageLabelSection interface {
	Declarations() []LanguageLabelDeclaration
}

LanguageLabelSection represents a language label section

type LanguageLabelSectionBuilder 

type LanguageLabelSectionBuilder interface {
	Create() LanguageLabelSectionBuilder
	WithDeclarations(declarations []LanguageLabelDeclaration) LanguageLabelSectionBuilder
	Now() (LanguageLabelSection, error)
}

LanguageLabelSectionBuilder represents a language label section builder

func NewLanguageLabelSectionBuilder 

func NewLanguageLabelSectionBuilder() LanguageLabelSectionBuilder

NewLanguageLabelSectionBuilder creates a new language label section builder

type LanguageMainSection 

type LanguageMainSection interface {
	Instructions() []LanguageInstruction
}

LanguageMainSection represents a language main section

type LanguageMainSectionBuilder 

type LanguageMainSectionBuilder interface {
	Create() LanguageMainSectionBuilder
	WithInstructions(instructions []LanguageInstruction) LanguageMainSectionBuilder
	Now() (LanguageMainSection, error)
}

LanguageMainSectionBuilder represents a language main section builder

func NewLanguageMainSectionBuilder 

func NewLanguageMainSectionBuilder() LanguageMainSectionBuilder

NewLanguageMainSectionBuilder creates a new language main section builder

type LanguageTestDeclaration 

type LanguageTestDeclaration interface {
	Name() string
	Instructions() []LanguageTestInstruction
}

LanguageTestDeclaration represents a language test declaration

type LanguageTestDeclarationBuilder 

type LanguageTestDeclarationBuilder interface {
	Create() LanguageTestDeclarationBuilder
	WithName(name string) LanguageTestDeclarationBuilder
	WithInstructions(instructions []LanguageTestInstruction) LanguageTestDeclarationBuilder
	Now() (LanguageTestDeclaration, error)
}

LanguageTestDeclarationBuilder represents a language test declaration builder

func NewLanguageTestDeclarationBuilder 

func NewLanguageTestDeclarationBuilder() LanguageTestDeclarationBuilder

NewLanguageTestDeclarationBuilder creates a new language test declaration builder

type LanguageTestInstruction 

type LanguageTestInstruction interface {
	IsLanguageInstruction() bool
	LanguageInstruction() LanguageInstructionCommon
	IsTestInstruction() bool
	TestInstruction() TestInstruction
	IsInterpret() bool
}

LanguageTestInstruction represents a language test instruction

type LanguageTestInstructionBuilder 

type LanguageTestInstructionBuilder interface {
	Create() LanguageTestInstructionBuilder
	WithLanguageInstruction(languageIns LanguageInstructionCommon) LanguageTestInstructionBuilder
	WithTestInstruction(testIns TestInstruction) LanguageTestInstructionBuilder
	IsInterpret() LanguageTestInstructionBuilder
	Now() (LanguageTestInstruction, error)
}

LanguageTestInstructionBuilder represents a language test instruction builder

func NewLanguageTestInstructionBuilder 

func NewLanguageTestInstructionBuilder() LanguageTestInstructionBuilder

NewLanguageTestInstructionBuilder creates a new language test instruction builder

type LanguageTestSection 

type LanguageTestSection interface {
	Declarations() []LanguageTestDeclaration
}

LanguageTestSection represents a language test section

type LanguageTestSectionBuilder 

type LanguageTestSectionBuilder interface {
	Create() LanguageTestSectionBuilder
	WithDeclarations(declarations []LanguageTestDeclaration) LanguageTestSectionBuilder
	Now() (LanguageTestSection, error)
}

LanguageTestSectionBuilder represents a language test section builder

func NewLanguageTestSectionBuilder 

func NewLanguageTestSectionBuilder() LanguageTestSectionBuilder

NewLanguageTestSectionBuilder creates a new language test section builder

type LanguageValue 

type LanguageValue interface {
	IsRoot() bool
	Root() string
	IsTokens() bool
	Tokens() RelativePath
	IsChannels() bool
	Channels() RelativePath
	IsRules() bool
	Rules() RelativePath
	IsLogic() bool
	Logic() RelativePath
	IsInputVariable() bool
	InputVariable() string
	IsExtends() bool
	Extends() []RelativePath
	IsPatternMatches() bool
	PatternMatches() []PatternMatch
}

LanguageValue represents a language value

type LanguageValueBuilder 

type LanguageValueBuilder interface {
	Create() LanguageValueBuilder
	WithRoot(root string) LanguageValueBuilder
	WithTokens(tokens RelativePath) LanguageValueBuilder
	WithChannels(channels RelativePath) LanguageValueBuilder
	WithRules(rules RelativePath) LanguageValueBuilder
	WithLogic(logic RelativePath) LanguageValueBuilder
	WithInputVariable(inputVar string) LanguageValueBuilder
	WithExtends(extends []RelativePath) LanguageValueBuilder
	WithPatternMatches(matches []PatternMatch) LanguageValueBuilder
	Now() (LanguageValue, error)
}

LanguageValueBuilder represents the language value builder

func NewLanguageValueBuilder 

func NewLanguageValueBuilder() LanguageValueBuilder

NewLanguageValueBuilder creates a new language value builder

type LoadSingle 

type LoadSingle interface {
	Internal() string
	External() string
}

LoadSingle represents a load single

type LoadSingleBuilder 

type LoadSingleBuilder interface {
	Create() LoadSingleBuilder
	WithInternal(internal string) LoadSingleBuilder
	WithExternal(external string) LoadSingleBuilder
	Now() (LoadSingle, error)
}

LoadSingleBuilder represents a load single builder

func NewLoadSingleBuilder 

func NewLoadSingleBuilder() LoadSingleBuilder

NewLoadSingleBuilder creates a new load single builder

type Logical 

type Logical interface {
	IsAnd() bool
	And() StandardOperation
	IsOr() bool
	Or() StandardOperation
}

Logical represents a logical operation instruction

type LogicalBuilder 

type LogicalBuilder interface {
	Create() LogicalBuilder
	WithAnd(and StandardOperation) LogicalBuilder
	WithOr(or StandardOperation) LogicalBuilder
	Now() (Logical, error)
}

LogicalBuilder represents a logical builder

func NewLogicalBuilder 

func NewLogicalBuilder() LogicalBuilder

NewLogicalBuilder creates a new logical builder

type MainCommand 

type MainCommand interface {
	Variable() string
	Instructions() []MainCommandInstruction
}

MainCommand represents a main command

type MainCommandBuilder 

type MainCommandBuilder interface {
	Create() MainCommandBuilder
	WithVariable(variable string) MainCommandBuilder
	WithInstructions(ins []MainCommandInstruction) MainCommandBuilder
	Now() (MainCommand, error)
}

MainCommandBuilder represents a main command builder

func NewMainCommandBuilder 

func NewMainCommandBuilder() MainCommandBuilder

NewMainCommandBuilder creates a new main command builder

type MainCommandInstruction 

type MainCommandInstruction interface {
	Instruction() Instruction
	HasScopes() bool
	Scopes() Scopes
}

MainCommandInstruction represents a main command instruction

type MainCommandInstructionBuilder 

type MainCommandInstructionBuilder interface {
	Create() MainCommandInstructionBuilder
	WithInstruction(ins Instruction) MainCommandInstructionBuilder
	WithScopes(scopes Scopes) MainCommandInstructionBuilder
	Now() (MainCommandInstruction, error)
}

MainCommandInstructionBuilder represents a main command instruction builder

func NewMainCommandInstructionBuilder 

func NewMainCommandInstructionBuilder() MainCommandInstructionBuilder

NewMainCommandInstructionBuilder creates a new main command instruction builder

type MainSection 

type MainSection interface {
	Instructions() []Instruction
}

MainSection represents the main section

type MainSectionBuilder 

type MainSectionBuilder interface {
	Create() MainSectionBuilder
	WithInstructions(ins []Instruction) MainSectionBuilder
	Now() (MainSection, error)
}

MainSectionBuilder represents the main section builder

func NewMainSectionBuilder 

func NewMainSectionBuilder() MainSectionBuilder

NewMainSectionBuilder creates a new main section builder

type Match 

type Match interface {
	Input() string
	HasPattern() bool
	Pattern() string
}

Match represents a match

type MatchBuilder 

type MatchBuilder interface {
	Create() MatchBuilder
	WithInput(input string) MatchBuilder
	WithPattern(pattern string) MatchBuilder
	Now() (Match, error)
}

MatchBuilder represents a match builder

func NewMatchBuilder 

func NewMatchBuilder() MatchBuilder

NewMatchBuilder creates a new match builder

type Module 

type Module interface {
	StackFrame() string
	Name() string
	Symbol() string
}

Module represents a module

type ModuleBuilder 

type ModuleBuilder interface {
	Create() ModuleBuilder
	WithStackFrame(stackFrame string) ModuleBuilder
	WithName(name string) ModuleBuilder
	WithSymbol(symbol string) ModuleBuilder
	Now() (Module, error)
}

ModuleBuilder represents a module builder

func NewModuleBuilder 

func NewModuleBuilder() ModuleBuilder

NewModuleBuilder creates a new module builder

type NumericValue 

type NumericValue interface {
	IsNegative() bool
	IsInt() bool
	Int() *int
	IsFloat() bool
	Float() *float64
}

NumericValue represents a numeric value

type NumericValueBuilder 

type NumericValueBuilder interface {
	Create() NumericValueBuilder
	IsNegative() NumericValueBuilder
	WithInt(intVal int) NumericValueBuilder
	WithFloat(floatVal float64) NumericValueBuilder
	Now() (NumericValue, error)
}

NumericValueBuilder represents a numeric value builder

func NewNumericValueBuilder 

func NewNumericValueBuilder() NumericValueBuilder

NewNumericValueBuilder creates a new numeric value buildeer

type Operation 

type Operation interface {
	IsArythmetic() bool
	Arythmetic() Arythmetic
	IsRelational() bool
	Relational() Relational
	IsLogical() bool
	Logical() Logical
}

Operation represents an operation instruction

type OperationBuilder 

type OperationBuilder interface {
	Create() OperationBuilder
	WithArythmetic(arythmetic Arythmetic) OperationBuilder
	WithRelational(relational Relational) OperationBuilder
	WithLogical(logical Logical) OperationBuilder
	Now() (Operation, error)
}

OperationBuilder represents an operation builder

func NewOperationBuilder 

func NewOperationBuilder() OperationBuilder

NewOperationBuilder creates a new operation builder

type Parser 

type Parser interface {
	Execute(lexer lexers.Lexer) (interface{}, error)
	ExecuteFile(filePath string) (interface{}, error)
	ExecuteScript(script string) (interface{}, error)
}

Parser represents a parser

type ParserBuilder 

type ParserBuilder interface {
	Create() ParserBuilder
	WithLexerAdapter(lexerAdapter lexers.Adapter) ParserBuilder
	Now() (Parser, error)
}

ParserBuilder represents a parser builder

func NewParserBuilder 

func NewParserBuilder() ParserBuilder

NewParserBuilder creates a new ParserBuilder instance

type PatternLabels 

type PatternLabels interface {
	HasEnterLabel() bool
	EnterLabel() string
	HasExitLabel() bool
	ExitLabel() string
}

PatternLabels represents the pattern labels

type PatternLabelsBuilder 

type PatternLabelsBuilder interface {
	Create() PatternLabelsBuilder
	WithEnterLabel(enter string) PatternLabelsBuilder
	WithExitLabel(exit string) PatternLabelsBuilder
	Now() (PatternLabels, error)
}

PatternLabelsBuilder represents the pattern labels builder

func NewPatternLabelsBuilder 

func NewPatternLabelsBuilder() PatternLabelsBuilder

NewPatternLabelsBuilder creeates a new pattern labels builder

type PatternMatch 

type PatternMatch interface {
	Pattern() string
	Labels() PatternLabels
}

PatternMatch represents pattern match

type PatternMatchBuilder 

type PatternMatchBuilder interface {
	Create() PatternMatchBuilder
	WithPattern(pattern string) PatternMatchBuilder
	WithLabels(labels PatternLabels) PatternMatchBuilder
	Now() (PatternMatch, error)
}

PatternMatchBuilder represents a pattern match builderexitHeadValue

func NewPatternMatchBuilder 

func NewPatternMatchBuilder() PatternMatchBuilder

NewPatternMatchBuilder creates a new pattern match builder

type Print 

type Print interface {
	Value() ValueRepresentation
}

Print represents a print instruction

type PrintBuilder 

type PrintBuilder interface {
	Create() PrintBuilder
	WithValue(value ValueRepresentation) PrintBuilder
	Now() (Print, error)
}

PrintBuilder represents a print instruction builder

func NewPrintBuilder 

func NewPrintBuilder() PrintBuilder

NewPrintBuilder creates a new print builder

type Program 

type Program interface {
	IsTestable() bool
	Testable() Testable
	IsLanguage() bool
	Language() LanguageApplication
}

Program represents the program

type ProgramBuilder 

type ProgramBuilder interface {
	Create() ProgramBuilder
	WithTestable(testable Testable) ProgramBuilder
	WithLanguage(lang LanguageApplication) ProgramBuilder
	Now() (Program, error)
}

ProgramBuilder represents the program builder

func NewProgramBuilder 

func NewProgramBuilder() ProgramBuilder

NewProgramBuilder creates a new program builder

type ReadFile 

type ReadFile interface {
	Variable() string
	Path() RelativePath
}

ReadFile represents a reafile instruction

type ReadFileBuilder 

type ReadFileBuilder interface {
	Create() ReadFileBuilder
	WithVariable(variable string) ReadFileBuilder
	WithPath(path RelativePath) ReadFileBuilder
	Now() (ReadFile, error)
}

ReadFileBuilder represents a readfile builder

func NewReadFileBuilder 

func NewReadFileBuilder() ReadFileBuilder

NewReadFileBuilder creates a new read file builder

type Register 

type Register interface {
	Variable() string
	HasIndex() bool
	Index() IntPointer
}

Register represents a register instruction

type RegisterBuilder 

type RegisterBuilder interface {
	Create() RegisterBuilder
	WithVariable(variable string) RegisterBuilder
	WithIndex(Index IntPointer) RegisterBuilder
	Now() (Register, error)
}

RegisterBuilder represents a register pointer

func NewRegisterBuilder 

func NewRegisterBuilder() RegisterBuilder

NewRegisterBuilder creates a new register builder

type Registry 

type Registry interface {
	IsFetch() bool
	Fetch() FetchRegistry
	IsRegister() bool
	Register() Register
	IsUnregister() bool
	Unregister() Unregister
}

Registry represents a registry instruction

type RegistryBuilder 

type RegistryBuilder interface {
	Create() RegistryBuilder
	WithFetch(fetch FetchRegistry) RegistryBuilder
	WithRegister(register Register) RegistryBuilder
	WithUnregister(unregister Unregister) RegistryBuilder
	Now() (Registry, error)
}

RegistryBuilder represents a registry builder

func NewRegistryBuilder 

func NewRegistryBuilder() RegistryBuilder

NewRegistryBuilder creates a new registry builder

type Relational 

type Relational interface {
	IsLessThan() bool
	LessThan() StandardOperation
	IsEqual() bool
	Equal() StandardOperation
	IsNotEqual() bool
	NotEqual() StandardOperation
}

Relational represents a relational operation instruction

type RelationalBuilder 

type RelationalBuilder interface {
	Create() RelationalBuilder
	WithLessThan(lessThan StandardOperation) RelationalBuilder
	WithEqual(equal StandardOperation) RelationalBuilder
	WithNotEqual(notEqual StandardOperation) RelationalBuilder
	Now() (Relational, error)
}

RelationalBuilder represents a relational builder

func NewRelationalBuilder 

func NewRelationalBuilder() RelationalBuilder

NewRelationalBuilder creates a new relational builder

type RelativePath 

type RelativePath interface {
	All() []FolderSection
	Head() []FolderSection
	HasTail() bool
	Tail() FolderSection
	String() string
}

RelativePath represents a relative path

type RelativePathBuilder 

type RelativePathBuilder interface {
	Create() RelativePathBuilder
	WithSections(sections []FolderSection) RelativePathBuilder
	WithPath(path string) RelativePathBuilder
	Now() (RelativePath, error)
}

RelativePathBuilder represents the relativePath builder

func NewRelativePathBuilder 

func NewRelativePathBuilder() RelativePathBuilder

NewRelativePathBuilder creates a new relative path builder

type RelativePaths 

type RelativePaths interface {
	All() []RelativePath
}

RelativePaths represents relative paths

type RelativePathsBuilder 

type RelativePathsBuilder interface {
	Create() RelativePathsBuilder
	WithRelativePaths(relPaths []RelativePath) RelativePathsBuilder
	Now() (RelativePaths, error)
}

RelativePathsBuilder represents a relative paths builder

func NewRelativePathsBuilder 

func NewRelativePathsBuilder() RelativePathsBuilder

NewRelativePathsBuilder creates a new relative paths builder

type RemainingOperation 

type RemainingOperation interface {
	First() string
	Second() string
	Result() string
	Remaining() string
}

RemainingOperation represents a an operation with a remaining value

type RemainingOperationBuilder 

type RemainingOperationBuilder interface {
	Create() RemainingOperationBuilder
	WithFirst(first string) RemainingOperationBuilder
	WithSecond(second string) RemainingOperationBuilder
	WithResult(result string) RemainingOperationBuilder
	WithRemaining(remaining string) RemainingOperationBuilder
	Now() (RemainingOperation, error)
}

RemainingOperationBuilder represents a remaining operation builder

func NewRemainingOperationBuilder 

func NewRemainingOperationBuilder() RemainingOperationBuilder

NewRemainingOperationBuilder creates a new remaining operation builder

type Save 

type Save interface {
	To() string
	HasFrom() bool
	From() string
}

Save represents a save instruction

type SaveBuilder 

type SaveBuilder interface {
	Create() SaveBuilder
	From(from string) SaveBuilder
	To(to string) SaveBuilder
	Now() (Save, error)
}

SaveBuilder represents a save builder

func NewSaveBuilder 

func NewSaveBuilder() SaveBuilder

NewSaveBuilder creates a new save builder

type Scope 

type Scope interface {
	IsInternal() bool
	IsExternal() bool
}

Scope represents a scope

type ScopeBuilder 

type ScopeBuilder interface {
	Create() ScopeBuilder
	IsInternal() ScopeBuilder
	IsExternal() ScopeBuilder
	Now() (Scope, error)
}

ScopeBuilder represents a scope builder

func NewScopeBuilder 

func NewScopeBuilder() ScopeBuilder

NewScopeBuilder creates a new scope builder

type Scopes 

type Scopes interface {
	All() []Scope
}

Scopes represents scopes

type ScopesBuilder 

type ScopesBuilder interface {
	Create() ScopesBuilder
	WithScopes(scopes []Scope) ScopesBuilder
	Now() (Scopes, error)
}

ScopesBuilder represents a scopes builder

func NewScopesBuilder 

func NewScopesBuilder() ScopesBuilder

NewScopesBuilder creates a new scopes builder

type Script 

type Script interface {
	Name() string
	Version() string
	Script() RelativePath
	Language() RelativePath
	Output() string
	HasTests() bool
	Tests() ScriptTests
}

Script represents a script

type ScriptBuilder 

type ScriptBuilder interface {
	Create() ScriptBuilder
	WithValues(values []ScriptValue) ScriptBuilder
	Now() (Script, error)
}

ScriptBuilder represents a script builder

func NewScriptBuilder 

func NewScriptBuilder() ScriptBuilder

NewScriptBuilder creates a new script builder

type ScriptCommand 

type ScriptCommand interface {
	Variable() string
	Values() []ScriptValue
}

ScriptCommand represents a script command

type ScriptCommandBuilder 

type ScriptCommandBuilder interface {
	Create() ScriptCommandBuilder
	WithVariable(variable string) ScriptCommandBuilder
	WithValues(values []ScriptValue) ScriptCommandBuilder
	Now() (ScriptCommand, error)
}

ScriptCommandBuilder represents a script command builder

func NewScriptCommandBuilder 

func NewScriptCommandBuilder() ScriptCommandBuilder

NewScriptCommandBuilder creates a new script command builder

type ScriptTest 

type ScriptTest interface {
	Name() string
	Path() RelativePath
}

ScriptTest represents a script test

type ScriptTestBuilder 

type ScriptTestBuilder interface {
	Create() ScriptTestBuilder
	WithName(name string) ScriptTestBuilder
	WithPath(path RelativePath) ScriptTestBuilder
	Now() (ScriptTest, error)
}

ScriptTestBuilder represents a script test builder

func NewScriptTestBuilder 

func NewScriptTestBuilder() ScriptTestBuilder

NewScriptTestBuilder creates a new script test builder

type ScriptTests 

type ScriptTests interface {
	All() []ScriptTest
}

ScriptTests represents script tests

type ScriptTestsBuilder 

type ScriptTestsBuilder interface {
	Create() ScriptTestsBuilder
	WithTests(tests []ScriptTest) ScriptTestsBuilder
	Now() (ScriptTests, error)
}

ScriptTestsBuilder represents a script tests builder

func NewScriptTestsBuilder 

func NewScriptTestsBuilder() ScriptTestsBuilder

NewScriptTestsBuilder creates a new script tests builder

type ScriptValue 

type ScriptValue interface {
	IsName() bool
	Name() string
	IsVersion() bool
	Version() string
	IsScript() bool
	Script() RelativePath
	IsLanguage() bool
	Language() RelativePath
	IsOutput() bool
	Output() string
	IsScriptTests() bool
	ScriptTests() ScriptTests
}

ScriptValue represents a script value

type ScriptValueBuilder 

type ScriptValueBuilder interface {
	Create() ScriptValueBuilder
	WithName(name string) ScriptValueBuilder
	WithVersion(version string) ScriptValueBuilder
	WithScriptPath(scriptPath RelativePath) ScriptValueBuilder
	WithLanguagePath(langPath RelativePath) ScriptValueBuilder
	WithOutput(output string) ScriptValueBuilder
	WithScriptTests(scriptTests ScriptTests) ScriptValueBuilder
	Now() (ScriptValue, error)
}

ScriptValueBuilder represents a script value builder

func NewScriptValueBuilder 

func NewScriptValueBuilder() ScriptValueBuilder

NewScriptValueBuilder creates a new script value builder

type Skip 

type Skip interface {
	Pointer() IntPointer
}

Skip represents a skip

type SkipBuilder 

type SkipBuilder interface {
	Create() SkipBuilder
	WithPointer(pointer IntPointer) SkipBuilder
	Now() (Skip, error)
}

SkipBuilder represents a skip builder

func NewSkipBuilder 

func NewSkipBuilder() SkipBuilder

NewSkipBuilder creates a new skip builder

type SpecificTokenCode 

type SpecificTokenCode interface {
	VariableName() string
	PatternVariable() string
	HasAmount() bool
	Amount() string
}

SpecificTokenCode represents a specific token code

type SpecificTokenCodeBuilder 

type SpecificTokenCodeBuilder interface {
	Create() SpecificTokenCodeBuilder
	WithVariableName(variableName string) SpecificTokenCodeBuilder
	WithAmount(amount string) SpecificTokenCodeBuilder
	WithPatternVariable(pattern string) SpecificTokenCodeBuilder
	Now() (SpecificTokenCode, error)
}

SpecificTokenCodeBuilder represents a specificTokenCode builder

func NewSpecificTokenCodeBuilder 

func NewSpecificTokenCodeBuilder() SpecificTokenCodeBuilder

NewSpecificTokenCodeBuilder creates a new specific token code builder

type StackFrame 

type StackFrame interface {
	IsPush() bool
	IsPop() bool
	IsIndex() bool
	Index() Index
	IsSkip() bool
	Skip() Skip
}

StackFrame represents a stackFrame related instruction

type StackFrameBuilder 

type StackFrameBuilder interface {
	Create() StackFrameBuilder
	IsPush() StackFrameBuilder
	IsPop() StackFrameBuilder
	WithIndex(index Index) StackFrameBuilder
	WithSkip(skip Skip) StackFrameBuilder
	Now() (StackFrame, error)
}

StackFrameBuilder represents a stackFrame builder

func NewStackFrameBuilder 

func NewStackFrameBuilder() StackFrameBuilder

NewStackFrameBuilder creates a new stack frame builder

type StandardOperation 

type StandardOperation interface {
	First() string
	Second() string
	Result() string
}

StandardOperation represents a standard operation

type StandardOperationBuilder 

type StandardOperationBuilder interface {
	Create() StandardOperationBuilder
	WithFirst(first string) StandardOperationBuilder
	WithSecond(second string) StandardOperationBuilder
	WithResult(result string) StandardOperationBuilder
	Now() (StandardOperation, error)
}

StandardOperationBuilder represents a standard operation builder

func NewStandardOperationBuilder 

func NewStandardOperationBuilder() StandardOperationBuilder

NewStandardOperationBuilder creates a new standard operation builder

type Switch 

type Switch interface {
	Variable() string
}

Switch represents a switch instruction

type SwitchBuilder 

type SwitchBuilder interface {
	Create() SwitchBuilder
	WithVariable(variable string) SwitchBuilder
	Now() (Switch, error)
}

SwitchBuilder represents a switch builder

func NewSwitchBuilder 

func NewSwitchBuilder() SwitchBuilder

NewSwitchBuilder creates a new switch builder

type TestCommand 

type TestCommand interface {
	Variable() string
	Name() string
	Instructions() []TestCommandInstruction
}

TestCommand represents a test command

type TestCommandBuilder 

type TestCommandBuilder interface {
	Create() TestCommandBuilder
	WithVariable(variable string) TestCommandBuilder
	WithName(name string) TestCommandBuilder
	WithInstructions(ins []TestCommandInstruction) TestCommandBuilder
	Now() (TestCommand, error)
}

TestCommandBuilder represents a test command builder

func NewTestCommandBuilder 

func NewTestCommandBuilder() TestCommandBuilder

NewTestCommandBuilder creates a new test command builder

type TestCommandInstruction 

type TestCommandInstruction interface {
	Instruction() TestInstruction
	HasScopes() bool
	Scopes() Scopes
}

TestCommandInstruction represents a test command instruction

type TestCommandInstructionBuilder 

type TestCommandInstructionBuilder interface {
	Create() TestCommandInstructionBuilder
	WithInstruction(ins TestInstruction) TestCommandInstructionBuilder
	WithScopes(scopes Scopes) TestCommandInstructionBuilder
	Now() (TestCommandInstruction, error)
}

TestCommandInstructionBuilder represents a test command instruction builder

func NewTestCommandInstructionBuilder 

func NewTestCommandInstructionBuilder() TestCommandInstructionBuilder

NewTestCommandInstructionBuilder creates a new test command instruction builder

type TestDeclaration 

type TestDeclaration interface {
	Name() string
	Instructions() []TestInstruction
}

TestDeclaration represents a test declaration

type TestDeclarationBuilder 

type TestDeclarationBuilder interface {
	Create() TestDeclarationBuilder
	WithName(name string) TestDeclarationBuilder
	WithInstructions(instructions []TestInstruction) TestDeclarationBuilder
	Now() (TestDeclaration, error)
}

TestDeclarationBuilder represnets a testDeclaration builder

func NewTestDeclarationBuilder 

func NewTestDeclarationBuilder() TestDeclarationBuilder

NewTestDeclarationBuilder creates a new test declaration builder

type TestInstruction 

type TestInstruction interface {
	IsAssert() bool
	Assert() Assert
	IsReadFile() bool
	ReadFile() ReadFile
	IsInstruction() bool
	Instruction() Instruction
}

TestInstruction represents a test instruction

type TestInstructionBuilder 

type TestInstructionBuilder interface {
	Create() TestInstructionBuilder
	WithInstruction(ins Instruction) TestInstructionBuilder
	WithReadFile(readFile ReadFile) TestInstructionBuilder
	WithAssert(assert Assert) TestInstructionBuilder
	Now() (TestInstruction, error)
}

TestInstructionBuilder represents a testInstruction builder

func NewTestInstructionBuilder 

func NewTestInstructionBuilder() TestInstructionBuilder

NewTestInstructionBuilder creates a new test instruction builder

type TestSection 

type TestSection interface {
	Declarations() []TestDeclaration
}

TestSection represents a test section

type TestSectionBuilder 

type TestSectionBuilder interface {
	Create() TestSectionBuilder
	WithDeclarations(declarations []TestDeclaration) TestSectionBuilder
	Now() (TestSection, error)
}

TestSectionBuilder represents a testSection builder

func NewTestSectionBuilder 

func NewTestSectionBuilder() TestSectionBuilder

NewTestSectionBuilder creates a new test section builder

type Testable 

type Testable interface {
	IsExecutable() bool
	Executable() Executable
	IsLanguage() bool
	Language() LanguageDefinition
}

Testable represents a testable program

type TestableBuilder 

type TestableBuilder interface {
	Create() TestableBuilder
	WithExecutable(executable Executable) TestableBuilder
	WithLanguage(language LanguageDefinition) TestableBuilder
	Now() (Testable, error)
}

TestableBuilder represents a testable builder

func NewTestableBuilder 

func NewTestableBuilder() TestableBuilder

NewTestableBuilder creates a new testable builder

type Token 

type Token interface {
	IsCodeMatch() bool
	CodeMatch() CodeMatch
	IsTokenSection() bool
	TokenSection() TokenSection
}

Token represents a token instruction

type TokenBuilder 

type TokenBuilder interface {
	Create() TokenBuilder
	WithCodeMatch(codeMatch CodeMatch) TokenBuilder
	WithTokenSection(tokenSection TokenSection) TokenBuilder
	Now() (Token, error)
}

TokenBuilder represents a token builder

func NewTokenBuilder 

func NewTokenBuilder() TokenBuilder

NewTokenBuilder creates a new token builder

type TokenSection 

type TokenSection interface {
	IsVariableName() bool
	VariableName() string
	IsSpecific() bool
	Specific() SpecificTokenCode
}

TokenSection represents a token section

type TokenSectionBuilder 

type TokenSectionBuilder interface {
	Create() TokenSectionBuilder
	WithVariableName(variableName string) TokenSectionBuilder
	WithSpecific(specific SpecificTokenCode) TokenSectionBuilder
	Now() (TokenSection, error)
}

TokenSectionBuilder represents a tokenSection builder

func NewTokenSectionBuilder 

func NewTokenSectionBuilder() TokenSectionBuilder

NewTokenSectionBuilder creates a new token section builder

type Type 

type Type interface {
	IsBool() bool
	IsInt8() bool
	IsInt16() bool
	IsInt32() bool
	IsInt64() bool
	IsFloat32() bool
	IsFloat64() bool
	IsUint8() bool
	IsUint16() bool
	IsUint32() bool
	IsUint64() bool
	IsString() bool
	IsStackFrame() bool
	String() string
}

Type represents a variable type

type TypeBuilder 

type TypeBuilder interface {
	Create() TypeBuilder
	IsBool() TypeBuilder
	IsInt8() TypeBuilder
	IsInt16() TypeBuilder
	IsInt32() TypeBuilder
	IsInt64() TypeBuilder
	IsFloat32() TypeBuilder
	IsFloat64() TypeBuilder
	IsUint8() TypeBuilder
	IsUint16() TypeBuilder
	IsUint32() TypeBuilder
	IsUint64() TypeBuilder
	IsString() TypeBuilder
	IsStackFrame() TypeBuilder
	Now() (Type, error)
}

TypeBuilder represents a type builder

func NewTypeBuilder 

func NewTypeBuilder() TypeBuilder

NewTypeBuilder creates a new type builder

type Unregister 

type Unregister interface {
	Variable() string
}

Unregister represents an unregister instruction

type UnregisterBuilder 

type UnregisterBuilder interface {
	Create() UnregisterBuilder
	WithVariable(name string) UnregisterBuilder
	Now() (Unregister, error)
}

UnregisterBuilder represents an unregister builder

func NewUnregisterBuilder 

func NewUnregisterBuilder() UnregisterBuilder

NewUnregisterBuilder creates a new unregister builder

type Value 

type Value interface {
	IsNil() bool
	IsNumeric() bool
	Numeric() NumericValue
	IsBool() bool
	Bool() *bool
	IsString() bool
	String() string
}

Value represents a value

type ValueBuilder 

type ValueBuilder interface {
	Create() ValueBuilder
	IsNil() ValueBuilder
	WithNumeric(numeric NumericValue) ValueBuilder
	WithBool(bl bool) ValueBuilder
	WithString(str string) ValueBuilder
	Now() (Value, error)
}

ValueBuilder represents a value

func NewValueBuilder 

func NewValueBuilder() ValueBuilder

NewValueBuilder creates a new value builder

type ValueRepresentation 

type ValueRepresentation interface {
	IsValue() bool
	Value() Value
	IsVariable() bool
	Variable() string
}

ValueRepresentation represents a value representation

type ValueRepresentationBuilder 

type ValueRepresentationBuilder interface {
	Create() ValueRepresentationBuilder
	WithValue(value Value) ValueRepresentationBuilder
	WithVariable(variable string) ValueRepresentationBuilder
	Now() (ValueRepresentation, error)
}

ValueRepresentationBuilder represents a value representation builder

func NewValueRepresentationBuilder 

func NewValueRepresentationBuilder() ValueRepresentationBuilder

NewValueRepresentationBuilder creates a new value representation builder

type Variable 

type Variable interface {
	IsDeclaration() bool
	Declaration() Declaration
	IsAssignment() bool
	Assignment() Assignment
	IsConcatenation() bool
	Concatenation() Concatenation
	IsDelete() bool
	Delete() string
}

Variable represents a variable related instruction

type VariableBuilder 

type VariableBuilder interface {
	Create() VariableBuilder
	WithDeclaration(declaration Declaration) VariableBuilder
	WithAssigment(assignment Assignment) VariableBuilder
	WithConcatenation(concatenation Concatenation) VariableBuilder
	WithDelete(delete string) VariableBuilder
	Now() (Variable, error)
}

VariableBuilder represents a variable builder

func NewVariableBuilder 

func NewVariableBuilder() VariableBuilder

NewVariableBuilder creates a new variable builder

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.