main.go

package main

import (
	"bufio"
	"bytes"
	"fmt"
	"github.com/fatih/color"
	"io"
	"os"
	"os/exec"
	"reflect"
	"strconv"
	"unicode"
)

// -----------------------------
// ----------- Lexer -----------
// -----------------------------

type Token int

const (
	TOKEN_EOF = iota
	// TOKEN_ILLEGAL
	TOKEN_ID
	TOKEN_STRING
	TOKEN_INT
	TOKEN_TYPE
	TOKEN_PLUS
	TOKEN_MINUS
	TOKEN_END
	TOKEN_DO
	TOKEN_BOOL
	TOKEN_ELIF
	TOKEN_ELSE
	TOKEN_DIV
	TOKEN_MUL
	TOKEN_EQUALS
	TOKEN_IS_EQUALS
	TOKEN_NOT_EQUALS
	TOKEN_LESS_THAN
	TOKEN_GREATER_THAN
	TOKEN_LESS_EQUALS
	TOKEN_GREATER_EQUALS
	TOKEN_REM
	TOKEN_L_BRACKET
	TOKEN_R_BRACKET
	TOKEN_DOT
	TOKEN_COMMA
	TOKEN_ERROR
	TOKEN_EXCEPT
	TOKEN_OR
	TOKEN_AND
)

var tokens = []string{
	TOKEN_PLUS:           "+",
	TOKEN_MINUS:          "-",
	TOKEN_DIV:            "/",
	TOKEN_MUL:            "*",
	TOKEN_IS_EQUALS:      "==",
	TOKEN_NOT_EQUALS:     "!=",
	TOKEN_LESS_THAN:      "<",
	TOKEN_GREATER_THAN:   ">",
	TOKEN_LESS_EQUALS:    "<=",
	TOKEN_GREATER_EQUALS: ">=",
	TOKEN_REM:            "%",
	TOKEN_OR:             "||",
	TOKEN_AND:            "&&",
}

type Position struct {
	line   int
	column int
}

type Lexer struct {
	pos      Position
	reader   *bufio.Reader
	FileName string
}

func LexerInit(reader io.Reader, FileName string) *Lexer {
	return &Lexer{
		pos:      Position{line: 1, column: 0},
		reader:   bufio.NewReader(reader),
		FileName: FileName,
	}
}

func (lexer *Lexer) Lex() (Position, Token, string, string) {
	for {
		r, _, err := lexer.reader.ReadRune()
		if err != nil {
			if err == io.EOF {
				err = nil
				return lexer.pos, TOKEN_EOF, "EOF", lexer.FileName
			}
			panic(err)
		}
		lexer.pos.column++
		switch r {
		case '\n':
			lexer.resetPosition()
		case '+':
			return lexer.pos, TOKEN_PLUS, "+", lexer.FileName
		case '/':
			return lexer.pos, TOKEN_DIV, "/", lexer.FileName
		case '*':
			return lexer.pos, TOKEN_MUL, "*", lexer.FileName
		case '%':
			return lexer.pos, TOKEN_REM, "%", lexer.FileName
		case '{':
			return lexer.pos, TOKEN_L_BRACKET, "{", lexer.FileName
		case '}':
			return lexer.pos, TOKEN_R_BRACKET, "}", lexer.FileName
		case ',':
			return lexer.pos, TOKEN_COMMA, ",", lexer.FileName
		case '.':
			return lexer.pos, TOKEN_DOT, ".", lexer.FileName
		default:
			if unicode.IsSpace(r) {
				continue
			} else if r == '=' {
				r, _, err := lexer.reader.ReadRune()
				lexer.pos.column++
				if err != nil {
					panic(err)
				}
				lexer.pos.column++
				if r == '=' {
					return lexer.pos, TOKEN_IS_EQUALS, "==", lexer.FileName
				}
			} else if r == '-' {
				r, _, err := lexer.reader.ReadRune()
				if err != nil {
					if err == io.EOF {
						return lexer.pos, TOKEN_MINUS, "-", lexer.FileName
					}
					panic(err)
				}
				lexer.pos.column++
				if r == '>' {
					return lexer.pos, TOKEN_EQUALS, "->", lexer.FileName
				} else {
					return lexer.pos, TOKEN_MINUS, "-", lexer.FileName
				}
			} else if r == '<' {
				r, _, err := lexer.reader.ReadRune()
				lexer.pos.column++
				if err != nil {
					if err == io.EOF {
						return lexer.pos, TOKEN_LESS_THAN, "<", lexer.FileName
					}
					panic(err)
				}
				if r == '=' {
					lexer.pos.column++
					return lexer.pos, TOKEN_LESS_EQUALS, "<=", lexer.FileName
				} else {
					return lexer.pos, TOKEN_LESS_THAN, "<", lexer.FileName
				}
			} else if r == '|' {
				r, _, err := lexer.reader.ReadRune()
				lexer.pos.column++
				if err != nil {
					if err == io.EOF {
						fmt.Println(fmt.Sprintf("SyntaxError:%d:%d: unexpected token value `%s`.", lexer.pos.line, lexer.pos.column, string(r)))
						os.Exit(0)
					}
					err = nil
					fmt.Println(fmt.Sprintf("SyntaxError:%d:%d: unexpected token value `%s`.", lexer.pos.line, lexer.pos.column, string(r)))
					panic(err)
				}
				if r == '|' {
					lexer.pos.column++
					return lexer.pos, TOKEN_OR, "||", lexer.FileName
				} else {
					fmt.Println(fmt.Sprintf("SyntaxError:%d:%d: unexpected token value `%s`.", lexer.pos.line, lexer.pos.column, string(r)))
					os.Exit(0)
				}
			} else if r == '&' {
				r, _, err := lexer.reader.ReadRune()
				lexer.pos.column++
				if err != nil {
					if err == io.EOF {
						fmt.Println(fmt.Sprintf("SyntaxError:%d:%d: unexpected token value `%s`.", lexer.pos.line, lexer.pos.column, string(r)))
						os.Exit(0)
					}
					err = nil
					fmt.Println(fmt.Sprintf("SyntaxError:%d:%d: unexpected token value `%s`.", lexer.pos.line, lexer.pos.column, string(r)))
					panic(err)
				}
				if r == '&' {
					lexer.pos.column++
					return lexer.pos, TOKEN_AND, "&&", lexer.FileName
				} else {
					fmt.Println(fmt.Sprintf("SyntaxError:%d:%d: unexpected token value `%s`.", lexer.pos.line, lexer.pos.column, string(r)))
					os.Exit(0)
				}
			} else if r == '>' {
				r, _, err := lexer.reader.ReadRune()
				lexer.pos.column++
				if err != nil {
					if err == io.EOF {
						return lexer.pos, TOKEN_GREATER_THAN, ">", lexer.FileName
					}
					panic(err)
				}
				if r == '=' {
					lexer.pos.column++
					return lexer.pos, TOKEN_GREATER_EQUALS, ">=", lexer.FileName
				} else {
					return lexer.pos, TOKEN_GREATER_THAN, ">", lexer.FileName
				}
			} else if r == '!' {
				r, _, err := lexer.reader.ReadRune()
				if err != nil {
					panic(err)
				}
				lexer.pos.column++
				lexer.pos.column++
				if r == '=' {
					return lexer.pos, TOKEN_NOT_EQUALS, "!=", lexer.FileName
				}
			} else if r == '#' {
				for {
					r, _, err := lexer.reader.ReadRune()
					if err != nil {
						if err == io.EOF {
							err = nil
							return lexer.pos, TOKEN_EOF, "EOF", lexer.FileName
						}
						panic(err)
					}
					if r == '\n' {
						lexer.resetPosition()
						break
					}
					if err != nil {
						panic(err)
					}
					lexer.pos.column++
				}
				continue
			} else if unicode.IsDigit(r) {
				startPos := lexer.pos
				lexer.backup()
				val := lexer.lexInt()
				return startPos, TOKEN_INT, val, lexer.FileName
			} else if unicode.IsLetter(r) {
				startPos := lexer.pos
				lexer.backup()
				val := lexer.lexId()
				if val == "end" {
					return startPos, TOKEN_END, val, lexer.FileName
				} else if val == "do" {
					return startPos, TOKEN_DO, val, lexer.FileName
				} else if val == "true" || val == "false" {
					return startPos, TOKEN_BOOL, val, lexer.FileName
				} else if val == "string" || val == "int" || val == "bool" || val == "type" || val == "list" || val == "error" {
					return startPos, TOKEN_TYPE, val, lexer.FileName
				} else if val == "else" {
					return startPos, TOKEN_ELSE, val, lexer.FileName
				} else if val == "elif" {
					return startPos, TOKEN_ELIF, val, lexer.FileName
				} else if val == "NameError" || val == "StackUnderflowError" || val == "TypeError" || val == "IncludeError" || val == "IndexError" || val == "AssertionError" || val == "FileNotFoundError" || val == "CommandError" {
					return startPos, TOKEN_ERROR, val, lexer.FileName
				} else if val == "except" {
					return startPos, TOKEN_EXCEPT, val, lexer.FileName
				}
				return startPos, TOKEN_ID, val, lexer.FileName
			} else if r == '"' {
				startPos := lexer.pos
				lexer.backup()
				lexer.pos.column++
				lexer.pos.column++
				val, _ := strconv.Unquote(lexer.lexString())
				r, _, err = lexer.reader.ReadRune()
				return startPos, TOKEN_STRING, val, lexer.FileName
			} else if string(r) == "'" {
				startPos := lexer.pos
				lexer.backup()
				lexer.pos.column++
				lexer.pos.column++
				val, _ := strconv.Unquote(lexer.lexStringSingle())
				r, _, err = lexer.reader.ReadRune()
				return startPos, TOKEN_STRING, val, lexer.FileName
			} else {
				file, err := os.Open(lexer.FileName)
				if err != nil {
					panic(err)
				}
				lexer := LexerInit(file, lexer.FileName)
				fmt.Println(fmt.Sprintf("%s:SyntaxError:%d:%d: unexpected token value `%s`.", lexer.FileName, lexer.pos.line, lexer.pos.column, string(r)))
				os.Exit(0)
			}
		}
	}
}

func (lexer *Lexer) backup() {
	if err := lexer.reader.UnreadRune(); err != nil {
		panic(err)
	}
	lexer.pos.column--
}

func (lexer *Lexer) lexId() string {
	var val string
	for {
		r, _, err := lexer.reader.ReadRune()
		if err != nil {
			if err == io.EOF {
				return val
			}
		}
		lexer.pos.column++
		if unicode.IsLetter(r) {
			val = val + string(r)
		} else if unicode.IsDigit(r) {
			val = val + string(r)
		} else if unicode.IsSpace(r) {
			lexer.backup()
			return val
		} else if string(r) == "_" {
			val = val + string(r)
		} else if string(r) == "-" {
			val = val + string(r)
		} else {
			lexer.backup()
			return val
		}
	}
}

func (lexer *Lexer) lexInt() string {
	var val string
	for {
		r, _, err := lexer.reader.ReadRune()
		if err != nil {
			if err == io.EOF {
				return val
			}
		}
		lexer.pos.column++
		if unicode.IsDigit(r) {
			val = val + string(r)
		} else {
			lexer.backup()
			return val
		}
	}
}

func (lexer *Lexer) lexString() string {
	var val string
	r, _, err := lexer.reader.ReadRune()
	val = val + string(r)
	for {
		r, _, err = lexer.reader.ReadRune()
		if err != nil {
			if err == io.EOF {
				return val
			}
		}
		lexer.pos.column++
		if r != '"' {
			val = val + string(r)
		} else {
			val = val + string(r)
			lexer.backup()
			return val
		}
	}
}

func (lexer *Lexer) lexStringSingle() string {
	var val string
	r, _, err := lexer.reader.ReadRune()
	val = val + "\""
	for {
		r, _, err = lexer.reader.ReadRune()
		if err != nil {
			if err == io.EOF {
				return val
			}
		}
		lexer.pos.column++
		if string(r) != "'" {
			val = val + string(r)
		} else {
			val = val + "\""
			lexer.backup()
			return val
		}
	}
}

func (lexer *Lexer) resetPosition() {
	lexer.pos.line++
	lexer.pos.column = 0
}

// -----------------------------
// ---------- Errors -----------
// -----------------------------

type ErrorType int

const (
	StackUnderflowError ErrorType = iota
	// ErrorVoid
	NameError
	TypeError
	IndexError
	IncludeError
	AssertionError
	FileNotFoundError
	CommandError
)

type Error struct {
	message string
	Type    ErrorType
}

// -----------------------------
// ------------ AST ------------
// -----------------------------

type NodePosition struct {
	FileName string
	Line     int
	Column   int
}

type AsStr struct {
	StringValue string
}

func (node AsStr) node() {}

type AsInt struct {
	IntValue int
}

func (node AsInt) node() {}

type AsBool struct {
	BoolValue bool
}

func (node AsBool) node() {}

type AsFile struct {
	FileAddress *os.File
	FileName    string
}

func (node AsFile) node() {}

type NewList struct {
	ListBody AST
}

func (node NewList) node() {}

type AsList struct {
	ListArgs []AST
}

func (node AsList) node() {}

type AsId struct {
	name     string
	Position NodePosition
}

func (node AsId) node() {}

type Include struct {
	FileName string
	Position NodePosition
}

func (node Include) node() {}

type Assert struct {
	Position NodePosition
	Message  string
}

func (node Assert) node() {}

type Compare struct {
	op       uint8
	Position NodePosition
}

func (node Compare) node() {}

type AsError struct {
	err ErrorType
}

func (node AsError) node() {}

type AsBinop struct {
	op       uint8
	Position NodePosition
}

func (node AsBinop) node() {}

type AsPush struct {
	value AST
}

func (node AsPush) node() {}

type AsType struct {
	TypeValue string
}

func (node AsType) node() {}

type Vardef struct {
	Name     string
	Position NodePosition
}

func (node Vardef) node() {}

type Var struct {
	Name     string
	Position NodePosition
}

func (node Var) node() {}

type Blockdef struct {
	Name      string
	BlockBody AST
}

func (node Blockdef) node() {}

type If struct {
	IfOp          AST
	Position      NodePosition
	IfBody        AST
	ElifOps       []AST
	ElifPositions []NodePosition
	ElifBodys     []AST
	ElseBody      AST
}

func (node If) node() {}

type For struct {
	ForOp    AST
	Position NodePosition
	ForBody  AST
}

func (node For) node() {}

type Try struct {
	TryBody      AST
	ExceptErrors []AST
	ExceptBodys  []AST
}

func (node Try) node() {}

type AsStatements []AST

func (node AsStatements) node() {}

type AST interface {
	node()
}

// -----------------------------
// ---------- Parser -----------
// -----------------------------

type Parser struct {
	currentTokenType  Token
	currentTokenValue string
	FileName          string
	lexer             Lexer
	line              int
	column            int
}

func ParserInit(lexer *Lexer) *Parser {
	pos, tok, val, file := lexer.Lex()
	return &Parser{
		currentTokenType:  tok,
		currentTokenValue: val,
		FileName:          file,
		lexer:             *lexer,
		line:              pos.line,
		column:            pos.column,
	}
}

func (parser *Parser) ParserEat(token Token) {
	if token != parser.currentTokenType {
		fmt.Println(fmt.Sprintf("%s:SyntaxError:%d:%d: unexpected token value `%s`.", parser.FileName, parser.line, parser.column, parser.currentTokenValue))
		os.Exit(0)
	}
	pos, tok, val, file := parser.lexer.Lex()
	parser.currentTokenType = tok
	parser.currentTokenValue = val
	parser.FileName = file
	parser.line = pos.line
	parser.column = pos.column
}

func StrToInt(num string) int {
	i, err := strconv.Atoi(num)
	if err != nil {
		panic(err)
	}
	return i
}

func RetNodePosition(parser *Parser) NodePosition {
	return NodePosition{
		Line:     parser.line,
		Column:   parser.column,
		FileName: parser.FileName,
	}
}

func ParserParseError(parser *Parser) AST {
	var err ErrorType
	switch parser.currentTokenValue {
	case "StackUnderflowError":
		err = StackUnderflowError
	case "NameError":
		err = NameError
	case "IncludeError":
		err = IncludeError
	case "TypeError":
		err = TypeError
	case "IndexError":
		err = IndexError
	case "AssertionError":
		err = AssertionError
	case "FileNotFoundError":
		err = FileNotFoundError
	case "CommandError":
		err = CommandError
	}
	parser.ParserEat(TOKEN_ERROR)
	ErrorExpr := AsError{
		err: err,
	}
	return ErrorExpr
}

func ParserParseExpr(parser *Parser) AST {
	var expr AST
	switch parser.currentTokenType {
	case TOKEN_INT:
		expr = AsInt{
			StrToInt(parser.currentTokenValue),
		}
		parser.ParserEat(TOKEN_INT)
	case TOKEN_STRING:
		expr = AsStr{
			parser.currentTokenValue,
		}
		parser.ParserEat(TOKEN_STRING)
	case TOKEN_BOOL:
		BoolValue := parser.currentTokenValue == "true"
		expr = AsBool{
			BoolValue,
		}
		parser.ParserEat(TOKEN_BOOL)
	case TOKEN_ERROR:
		expr = ParserParseError(parser)
	case TOKEN_L_BRACKET:
		parser.ParserEat(TOKEN_L_BRACKET)
		var ListBody AST
		if parser.currentTokenType != TOKEN_R_BRACKET {
			ListBody = ParserParse(parser)
		}
		expr = NewList{
			ListBody,
		}
		parser.ParserEat(TOKEN_R_BRACKET)
	case TOKEN_ID:
		expr = Var{
			Name:     parser.currentTokenValue,
			Position: RetNodePosition(parser),
		}
		parser.ParserEat(TOKEN_ID)
	case TOKEN_TYPE:
		expr = AsType{
			parser.currentTokenValue,
		}
		parser.ParserEat(TOKEN_TYPE)
	default:
		fmt.Println(fmt.Sprintf("%s:SyntaxError:%d:%d: unexpected token value `%s`.", parser.FileName, parser.line, parser.column, parser.currentTokenValue))
		os.Exit(0)
	}

	return expr
}

func ParserParse(parser *Parser) AST {
	var Statements AsStatements
	IdExprs := []string{"print", "break", "append", "remove", "swap", "in", "typeof", "rot", "len", "input", "drop",
		"dup", "inc", "dec", "replace", "read", "println", "over", "printS", "exit", "free", "fopen", "fclose",
		"fwrite", "fread", "isdigit", "ftruncate", "atoi", "itoa", "b", "uniquote", "system"}
	if parser.currentTokenType == TOKEN_DO || parser.currentTokenType == TOKEN_END || parser.currentTokenType == TOKEN_ELIF || parser.currentTokenType == TOKEN_ELSE || parser.currentTokenType == TOKEN_EXCEPT {
		fmt.Println(fmt.Sprintf("%s:SyntaxError:%d:%d: the body is empty, unexpected token value `%s`.", parser.FileName, parser.line, parser.column, parser.currentTokenValue))
		os.Exit(0)
	}
	for {
		if parser.currentTokenType == TOKEN_ID {
			switch v := parser.currentTokenValue; v {
			case "assert":
				position := RetNodePosition(parser)
				parser.ParserEat(TOKEN_ID)
				AssertExpr := Assert{
					Position: position,
					Message:  parser.currentTokenValue,
				}
				parser.ParserEat(TOKEN_STRING)
				Statements = append(Statements, AssertExpr)
			case "block":
				parser.ParserEat(TOKEN_ID)
				name := parser.currentTokenValue
				parser.ParserEat(TOKEN_ID)
				parser.ParserEat(TOKEN_DO)
				BlockBody := ParserParse(parser)
				parser.ParserEat(TOKEN_END)
				BlockdefExpr := Blockdef{
					Name:      name,
					BlockBody: BlockBody,
				}
				Statements = append(Statements, BlockdefExpr)
			case "include":
				parser.ParserEat(TOKEN_ID)
				IncludeExpr := Include{
					parser.currentTokenValue,
					RetNodePosition(parser),
				}
				parser.ParserEat(TOKEN_STRING)
				Statements = append(Statements, IncludeExpr)
			case "if":
				parser.ParserEat(TOKEN_ID)
				position := RetNodePosition(parser)
				IfOp := ParserParse(parser)
				parser.ParserEat(TOKEN_DO)
				IfBody := ParserParse(parser)
				var ElifOps []AST
				var ElifBodys []AST
				var ElifPositions []NodePosition
				for {
					if parser.currentTokenType != TOKEN_ELIF {
						break
					}
					parser.ParserEat(TOKEN_ELIF)
					ElifPosition := RetNodePosition(parser)
					ElifOp := ParserParse(parser)
					ElifOps = append(ElifOps, ElifOp)
					ElifPositions = append(ElifPositions, ElifPosition)
					parser.ParserEat(TOKEN_DO)
					ElifBody := ParserParse(parser)
					ElifBodys = append(ElifBodys, ElifBody)
				}
				var ElseBody AST = nil
				for {
					if parser.currentTokenType != TOKEN_ELSE {
						break
					}
					parser.ParserEat(TOKEN_ELSE)
					ElseBody = ParserParse(parser)
				}
				parser.ParserEat(TOKEN_END)
				IfExpr := If{
					IfOp:          IfOp,
					Position:      position,
					IfBody:        IfBody,
					ElifOps:       ElifOps,
					ElifPositions: ElifPositions,
					ElifBodys:     ElifBodys,
					ElseBody:      ElseBody,
				}
				Statements = append(Statements, IfExpr)
			case "for":
				parser.ParserEat(TOKEN_ID)
				position := RetNodePosition(parser)
				ForOp := ParserParse(parser)
				parser.ParserEat(TOKEN_DO)
				ForBody := ParserParse(parser)
				parser.ParserEat(TOKEN_END)
				ForExpr := For{
					ForOp:    ForOp,
					Position: position,
					ForBody:  ForBody,
				}
				Statements = append(Statements, ForExpr)
			case "try":
				parser.ParserEat(TOKEN_ID)
				TryBody := ParserParse(parser)
				var ExceptErrors []AST
				var ExceptBodys []AST
				for {
					if parser.currentTokenType != TOKEN_EXCEPT {
						break
					}
					parser.ParserEat(TOKEN_EXCEPT)
					ExceptError := ParserParseError(parser)
					ExceptErrors = append(ExceptErrors, ExceptError)
					parser.ParserEat(TOKEN_DO)
					ExceptBody := ParserParse(parser)
					ExceptBodys = append(ExceptBodys, ExceptBody)
				}
				parser.ParserEat(TOKEN_END)
				TryExpr := Try{
					TryBody:      TryBody,
					ExceptErrors: ExceptErrors,
					ExceptBodys:  ExceptBodys,
				}
				Statements = append(Statements, TryExpr)
			default:
				if func(strs []string, s string) bool {
					for _, str := range strs {
						if str == s {
							return true
						}
					}
					return false
				}(IdExprs, v) {
					name := parser.currentTokenValue
					position := RetNodePosition(parser)
					IdExpr := AsId{
						name,
						position,
					}
					parser.ParserEat(TOKEN_ID)
					Statements = append(Statements, IdExpr)
				} else {
					expr := ParserParseExpr(parser)
					PushExpr := AsPush{
						value: expr,
					}
					Statements = append(Statements, PushExpr)
				}
			}
		} else if parser.currentTokenType == TOKEN_INT || parser.currentTokenType == TOKEN_STRING ||
			parser.currentTokenType == TOKEN_BOOL || parser.currentTokenType == TOKEN_ERROR || parser.currentTokenType == TOKEN_L_BRACKET || parser.currentTokenType == TOKEN_TYPE {
			expr := ParserParseExpr(parser)
			PushExpr := AsPush{
				value: expr,
			}
			Statements = append(Statements, PushExpr)
		} else if parser.currentTokenType == TOKEN_EQUALS {
			position := RetNodePosition(parser)
			parser.ParserEat(TOKEN_EQUALS)
			VardefExpr := Vardef{
				Name:     parser.currentTokenValue,
				Position: position,
			}
			parser.ParserEat(TOKEN_ID)
			Statements = append(Statements, VardefExpr)
		} else if parser.currentTokenType == TOKEN_PLUS || parser.currentTokenType == TOKEN_MINUS || parser.currentTokenType == TOKEN_MUL || parser.currentTokenType == TOKEN_DIV || parser.currentTokenType == TOKEN_REM {
			BinopExpr := AsBinop{
				op:       uint8(parser.currentTokenType),
				Position: RetNodePosition(parser),
			}
			parser.ParserEat(parser.currentTokenType)
			Statements = append(Statements, BinopExpr)
		} else if parser.currentTokenType == TOKEN_LESS_EQUALS || parser.currentTokenType == TOKEN_GREATER_EQUALS || parser.currentTokenType == TOKEN_LESS_THAN || parser.currentTokenType == TOKEN_GREATER_THAN || parser.currentTokenType == TOKEN_IS_EQUALS || parser.currentTokenType == TOKEN_NOT_EQUALS || parser.currentTokenType == TOKEN_OR || parser.currentTokenType == TOKEN_AND {
			CompareExpr := Compare{
				op:       uint8(parser.currentTokenType),
				Position: RetNodePosition(parser),
			}
			parser.ParserEat(parser.currentTokenType)
			Statements = append(Statements, CompareExpr)
		} else if parser.currentTokenType == TOKEN_EOF || parser.currentTokenType == TOKEN_DO ||
			parser.currentTokenType == TOKEN_END || parser.currentTokenType == TOKEN_ELIF ||
			parser.currentTokenType == TOKEN_ELSE || parser.currentTokenType == TOKEN_EXCEPT || parser.currentTokenType == TOKEN_R_BRACKET {
			break
		} else {
			fmt.Println(fmt.Sprintf("%s:SyntaxError:%d:%d: unexpected token value `%s`.", parser.FileName, parser.line, parser.column, parser.currentTokenValue))
			os.Exit(0)
		}
	}
	return Statements
}

// -----------------------------
// ----------- Stack -----------
// -----------------------------

type Scope struct {
	Stack []AST
}

var Variables = map[string]AST{}

func InitScope() *Scope {
	return &Scope{
		[]AST{},
	}
}

func (scope *Scope) OpPush(node AST, VariableScope *map[string]AST) *Error {
	if _, IsList := node.(NewList); IsList {
		ListScope := InitScope()
		if node.(NewList).ListBody != nil {
			ListScope.VisitorVisit(node.(NewList).ListBody, false, VariableScope)
		}
		scope.Stack = append(scope.Stack, AsList{ListScope.Stack})
	} else if _, IsVar := node.(Var); IsVar {
		if VariableScope == nil {
			if _, ok := Variables[node.(Var).Name]; ok {
				if _, ok := Variables[node.(Var).Name].(Blockdef); ok {
					VariableScope := map[string]AST{}
					scope.VisitorVisit(Variables[node.(Var).Name].(Blockdef).BlockBody, false, &VariableScope)
					return nil
				}
				scope.Stack = append(scope.Stack, Variables[node.(Var).Name])
				return nil
			}
		} else {
			if _, ok := (*VariableScope)[node.(Var).Name]; ok {
				if _, ok := (*VariableScope)[node.(Var).Name].(Blockdef); ok {
					NewVariableScope := map[string]AST{}
					scope.VisitorVisit((*VariableScope)[node.(Var).Name].(Blockdef).BlockBody, false, &NewVariableScope)
					return nil
				}
				scope.Stack = append(scope.Stack, (*VariableScope)[node.(Var).Name])
				return nil
			} else {
				if _, ok := Variables[node.(Var).Name]; ok {
					if _, ok := Variables[node.(Var).Name].(Blockdef); ok {
						NewVariableScope := map[string]AST{}
						scope.VisitorVisit(Variables[node.(Var).Name].(Blockdef).BlockBody, false, &NewVariableScope)
						return nil
					}
					scope.Stack = append(scope.Stack, Variables[node.(Var).Name])
					return nil
				}
			}
		}
		err := Error{}
		err.message = fmt.Sprintf("%s:NameError:%d:%d: name `%s` is not defined.", node.(Var).Position.FileName, node.(Var).Position.Line, node.(Var).Position.Column, node.(Var).Name)
		err.Type = NameError
		return &err
	} else {
		scope.Stack = append(scope.Stack, node)
	}
	return nil
}

func (scope *Scope) OpDrop(node AST) *Error {
	if len(scope.Stack) < 1 {
		err := Error{}
		err.message = fmt.Sprintf("%s:StackUnderflowError:%d:%d: `drop` expected one or more element in the stack.", node.(AsId).Position.FileName, node.(AsId).Position.Line, node.(AsId).Position.Column)
		err.Type = StackUnderflowError
		return &err
	}
	scope.Stack = scope.Stack[:len(scope.Stack)-1]
	return nil
}

func (scope *Scope) OpSwap(node AST) *Error {
	if len(scope.Stack) < 2 {
		err := Error{}
		err.message = fmt.Sprintf("%s:StackUnderflowError:%d:%d: `swap` expected two or more element in the stack.", node.(AsId).Position.FileName, node.(AsId).Position.Line, node.(AsId).Position.Column)
		err.Type = StackUnderflowError
		return &err
	}
	first := scope.Stack[len(scope.Stack)-1]
	second := scope.Stack[len(scope.Stack)-2]
	scope.Stack = scope.Stack[:len(scope.Stack)-2]
	scope.OpPush(first, nil)
	scope.OpPush(second, nil)
	return nil
}

func RetTokenAsStr(token uint8) string {
	return tokens[token]
}

func (scope *Scope) OpBinop(op uint8, position NodePosition) *Error {
	if len(scope.Stack) < 2 {
		err := Error{}
		err.message = fmt.Sprintf("%s:StackUnderflowError:%d:%d: `%s` expected more than 2 <int> type elements in the stack.", position.FileName, position.Line, position.Column, RetTokenAsStr(op))
		err.Type = StackUnderflowError
		return &err
	}
	first := scope.Stack[len(scope.Stack)-1]
	second := scope.Stack[len(scope.Stack)-2]
	scope.Stack = scope.Stack[:len(scope.Stack)-2]
	_, ok := first.(AsInt)
	_, ok2 := second.(AsInt)

	_, IsStr := first.(AsStr)
	_, IsStr2 := second.(AsStr)

	if IsStr && IsStr2 {
		StrVal := second.(AsStr).StringValue + first.(AsStr).StringValue
		expr := AsStr{
			StrVal,
		}
		scope.OpPush(expr, nil)
		return nil
	}

	if !ok || !ok2 {
		err := Error{}
		err.message = fmt.Sprintf("%s:StackUnderflowError:%d:%d: `%s` expected 2 <int> type or 2 <string> type elements in the stack.", position.FileName, position.Line, position.Column, RetTokenAsStr(op))
		err.Type = TypeError
		return &err
	}
	var val int
	switch op {
	case TOKEN_PLUS:
		val = first.(AsInt).IntValue + second.(AsInt).IntValue
	case TOKEN_MINUS:
		val = second.(AsInt).IntValue - first.(AsInt).IntValue
	case TOKEN_MUL:
		val = second.(AsInt).IntValue * first.(AsInt).IntValue
	case TOKEN_DIV:
		val = second.(AsInt).IntValue / first.(AsInt).IntValue
	case TOKEN_REM:
		val = second.(AsInt).IntValue % first.(AsInt).IntValue
	}
	expr := AsInt{
		val,
	}
	scope.OpPush(expr, nil)
	return nil
}

func (scope *Scope) OpCompare(op uint8, position NodePosition) *Error {
	if len(scope.Stack) < 2 {
		err := Error{}
		err.message = fmt.Sprintf("%s:StackUnderflowError:%d:%d: `%s` expected more than 2 elements in the stack.", position.FileName, position.Line, position.Column, RetTokenAsStr(op))
		err.Type = StackUnderflowError
		return &err
	}
	first := scope.Stack[len(scope.Stack)-1]
	second := scope.Stack[len(scope.Stack)-2]
	var val bool
	if op == TOKEN_IS_EQUALS {
		if reflect.TypeOf(first) != reflect.TypeOf(second) {
			val = false
		} else {
			switch first.(type) {
			case AsStr:
				val = first.(AsStr).StringValue == second.(AsStr).StringValue
			case AsInt:
				val = second.(AsInt).IntValue == first.(AsInt).IntValue
			case AsBool:
				val = second.(AsBool).BoolValue == first.(AsBool).BoolValue
			case AsType:
				val = second.(AsType).TypeValue == first.(AsType).TypeValue
			case AsError:
				val = second.(AsError).err == first.(AsError).err
			case AsList:
				val = reflect.DeepEqual(second.(AsList).ListArgs, first.(AsList).ListArgs)
			case Blockdef:
				val = reflect.DeepEqual(second.(Blockdef), first.(Blockdef))
			}
		}
	} else if op == TOKEN_NOT_EQUALS {
		if reflect.TypeOf(first) != reflect.TypeOf(second) {
			val = true
		} else {
			switch first.(type) {
			case AsStr:
				val = first.(AsStr).StringValue != second.(AsStr).StringValue
			case AsInt:
				val = second.(AsInt).IntValue != first.(AsInt).IntValue
			case AsBool:
				val = second.(AsBool).BoolValue != first.(AsBool).BoolValue
			case AsType:
				val = second.(AsType).TypeValue != first.(AsType).TypeValue
			case AsError:
				val = second.(AsError).err != first.(AsError).err
			case AsList:
				val = !reflect.DeepEqual(second.(AsList).ListArgs, first.(AsList).ListArgs)
			case Blockdef:
				val = !reflect.DeepEqual(second.(Blockdef), first.(Blockdef))
			}
		}
	} else if op == TOKEN_OR || op == TOKEN_AND {
		_, ok := first.(AsBool)
		_, ok2 := second.(AsBool)
		if !ok || !ok2 {
			err := Error{}
			err.message = fmt.Sprintf("%s:TypeError:%d:%d: `%s` expected 2 <bool> type elements in the stack.", position.FileName, position.Line, position.Column, RetTokenAsStr(op))
			err.Type = TypeError
			return &err
		}
		switch op {
		case TOKEN_OR:
			val = second.(AsBool).BoolValue || first.(AsBool).BoolValue
		case TOKEN_AND:
			val = second.(AsBool).BoolValue && first.(AsBool).BoolValue
		}
	} else {
		_, ok := first.(AsInt)
		_, ok2 := second.(AsInt)
		if !ok || !ok2 {
			err := Error{}
			err.message = fmt.Sprintf("%s:TypeError:%d:%d: `%s` expected 2 <int> type elements in the stack.", position.FileName, position.Line, position.Column, RetTokenAsStr(op))
			err.Type = TypeError
			return &err
		}
		switch op {
		case TOKEN_LESS_THAN:
			val = second.(AsInt).IntValue < first.(AsInt).IntValue
		case TOKEN_LESS_EQUALS:
			val = second.(AsInt).IntValue <= first.(AsInt).IntValue
		case TOKEN_GREATER_THAN:
			val = second.(AsInt).IntValue > first.(AsInt).IntValue
		case TOKEN_GREATER_EQUALS:
			val = second.(AsInt).IntValue >= first.(AsInt).IntValue
		}
	}
	scope.Stack = scope.Stack[:len(scope.Stack)-2]
	expr := AsBool{
		val,
	}
	scope.OpPush(expr, nil)
	return nil
}

func PrintAsList(node AST) {
	fmt.Print("{")
	for i := 0; i < len(node.(AsList).ListArgs); i++ {
		switch node.(AsList).ListArgs[i].(type) {
		case AsStr:
			fmt.Print(node.(AsList).ListArgs[i].(AsStr).StringValue)
		case AsInt:
			fmt.Print(node.(AsList).ListArgs[i].(AsInt).IntValue)
		case AsBool:
			fmt.Print(node.(AsList).ListArgs[i].(AsBool).BoolValue)
		case AsType:
			fmt.Print(fmt.Sprintf("<%s>", node.(AsList).ListArgs[i].(AsType).TypeValue))
		case AsFile:
			fmt.Print(fmt.Sprintf("<file %s>", node.(AsList).ListArgs[i].(AsFile).FileName))
		case AsError:
			switch node.(AsList).ListArgs[i].(AsError).err {
			case NameError:
				fmt.Print("<error 'NameError'>")
			case StackUnderflowError:
				fmt.Print("<error 'StackUnderflowError'>")
			case IncludeError:
				fmt.Print("<error 'IncludeError'>")
			case IndexError:
				fmt.Print("<error 'IndexError'>")
			case TypeError:
				fmt.Print("<error 'TypeError'>")
			case FileNotFoundError:
				fmt.Print("<error 'FileNotFoundError'>")
			default:
				fmt.Print(fmt.Sprintf("unexpected error <%d>", node.(AsList).ListArgs[i].(AsError).err))
			}
		case AsList:
			PrintAsList(node.(AsList).ListArgs[i])
		}
		if i < len(node.(AsList).ListArgs)-1 {
			fmt.Print(", ")
		}
	}
	fmt.Print("}")
}

func (scope *Scope) OpPrintln(node AST) *Error {
	if len(scope.Stack) < 1 {
		err := Error{}
		err.message = fmt.Sprintf("%s:StackUnderflowError:%d:%d: `println` the stack is empty.", node.(AsId).Position.FileName, node.(AsId).Position.Line, node.(AsId).Position.Column)
		err.Type = StackUnderflowError
		return &err
	}
	expr := scope.Stack[len(scope.Stack)-1]
	switch expr.(type) {
	case AsStr:
		fmt.Println(expr.(AsStr).StringValue)
	case AsInt:
		fmt.Println(expr.(AsInt).IntValue)
	case AsBool:
		fmt.Println(expr.(AsBool).BoolValue)
	case AsType:
		fmt.Println(fmt.Sprintf("<%s>", expr.(AsType).TypeValue))
	case AsFile:
		fmt.Println(fmt.Sprintf("<file %s>", expr.(AsFile).FileName))
	case AsError:
		switch expr.(AsError).err {
		case NameError:
			fmt.Println("<error 'NameError'>")
		case StackUnderflowError:
			fmt.Println("<error 'StackUnderflowError'>")
		case IncludeError:
			fmt.Println("<error 'IncludeError'>")
		case IndexError:
			fmt.Println("<error 'IndexError'>")
		case TypeError:
			fmt.Println("<error 'TypeError'>")
		case FileNotFoundError:
			fmt.Print("<error 'FileNotFoundError'>")
		default:
			fmt.Println(fmt.Sprintf("unexpected error <%d>", expr.(AsError).err))
		}
	case AsList:
		PrintAsList(expr)
		fmt.Println()
	}
	scope.Stack = scope.Stack[:len(scope.Stack)-1]
	return nil
}

func (scope *Scope) OpPrint(node AST) *Error {
	if len(scope.Stack) < 1 {
		err := Error{}
		err.message = fmt.Sprintf("%s:StackUnderflowError:%d:%d: `print` the stack is empty.", node.(AsId).Position.FileName, node.(AsId).Position.Line, node.(AsId).Position.Column)
		err.Type = StackUnderflowError
		return &err
	}
	expr := scope.Stack[len(scope.Stack)-1]
	switch expr.(type) {
	case AsStr:
		fmt.Print(expr.(AsStr).StringValue)
	case AsInt:
		fmt.Print(expr.(AsInt).IntValue)
	case AsBool:
		fmt.Print(expr.(AsBool).BoolValue)
	case AsType:
		fmt.Print(fmt.Sprintf("<%s>", expr.(AsType).TypeValue))
	case AsFile:
		fmt.Print(fmt.Sprintf("<file %s>", expr.(AsFile).FileName))
	case AsError:
		switch expr.(AsError).err {
		case NameError:
			fmt.Print("<error 'NameError'>")
		case StackUnderflowError:
			fmt.Print("<error 'StackUnderflowError'>")
		case IncludeError:
			fmt.Print("<error 'IncludeError'>")
		case IndexError:
			fmt.Print("<error 'IndexError'>")
		case TypeError:
			fmt.Print("<error 'TypeError'>")
		case FileNotFoundError:
			fmt.Print("<error 'FileNotFoundError'>")
		default:
			fmt.Print(fmt.Sprintf("unexpected error <%d>", expr.(AsError).err))
		}
	case AsList:
		PrintAsList(expr)
	}
	scope.Stack = scope.Stack[:len(scope.Stack)-1]
	return nil
}

func (scope *Scope) OpIf(node AST, IsTry bool, VariableScope *map[string]AST) (bool, *Error) {
	scope.VisitorVisit(node.(If).IfOp, IsTry, VariableScope)
	var BreakValue = false
	var err *Error = nil
	if len(scope.Stack) < 1 {
		err := Error{}
		err.message = fmt.Sprintf("%s:StackUnderflowError:%d:%d: if statement expected one or more <bool> type element in the stack.", node.(If).Position.FileName, node.(If).Position.Line, node.(If).Position.Column)
		err.Type = StackUnderflowError
		return false, &err
	}
	expr := scope.Stack[len(scope.Stack)-1]
	if _, ok := expr.(AsBool); !ok {
		err := Error{}
		err.message = fmt.Sprintf("%s:TypeError:%d:%d: if statement expected one or more <bool> type element in the stack.", node.(If).Position.FileName, node.(If).Position.Line, node.(If).Position.Column)
		err.Type = StackUnderflowError
		return false, &err
	}
	scope.Stack = scope.Stack[:len(scope.Stack)-1]
	if expr.(AsBool).BoolValue {
		BreakValue, err, _ = scope.VisitorVisit(node.(If).IfBody, IsTry, VariableScope)
		if err != nil {
			return BreakValue, err
		}
		return BreakValue, nil
	}
	for i := 0; i < len(node.(If).ElifOps); i++ {
		scope.VisitorVisit(node.(If).ElifOps[i], IsTry, VariableScope)
		if len(scope.Stack) < 1 {
			err := Error{}
			err.message = fmt.Sprintf("%s:StackUnderflowError:%d:%d: if statement expected one or more <bool> type element in the stack.", node.(If).ElifPositions[i].FileName, node.(If).ElifPositions[i].Line, node.(If).ElifPositions[i].Column)
			err.Type = StackUnderflowError
			return BreakValue, &err
		}
		expr := scope.Stack[len(scope.Stack)-1]
		if _, ok := expr.(AsBool); !ok {
			err := Error{}
			err.message = fmt.Sprintf("%s:TypeError:%d:%d: if statement expected one or more <bool> type element in the stack.", node.(If).ElifPositions[i].FileName, node.(If).ElifPositions[i].Line, node.(If).ElifPositions[i].Column)
			err.Type = StackUnderflowError
			return BreakValue, &err
		}
		scope.Stack = scope.Stack[:len(scope.Stack)-1]
		if expr.(AsBool).BoolValue {
			BreakValue, err, _ = scope.VisitorVisit(node.(If).ElifBodys[i], IsTry, VariableScope)
			return BreakValue, err
		}
	}
	if node.(If).ElseBody != nil {
		BreakValue, err, _ = scope.VisitorVisit(node.(If).ElseBody, IsTry, VariableScope)
	}
	return BreakValue, err
}

func (scope *Scope) OpFor(node AST, IsTry bool, VariableScope *map[string]AST) *Error {
	var BreakValue bool
LOOP:
	_, err, _ := scope.VisitorVisit(node.(For).ForOp, IsTry, VariableScope)
	if err != nil {
		return err
	}
	if len(scope.Stack) < 1 {
		err := Error{}
		err.message = fmt.Sprintf("%s:StackUnderflowError:%d:%d: for loop expected one or more <bool> type element in the stack.", node.(For).Position.FileName, node.(For).Position.Line, node.(For).Position.Column)
		err.Type = StackUnderflowError
		return &err
	}
	expr := scope.Stack[len(scope.Stack)-1]
	if _, ok := expr.(AsBool); !ok {
		err := Error{}
		err.message = fmt.Sprintf("%s:TypeError:%d:%d: for loop expected one or more <bool> type element in the stack.", node.(For).Position.FileName, node.(For).Position.Line, node.(For).Position.Column)
		err.Type = TypeError
		return &err
	}
	scope.Stack = scope.Stack[:len(scope.Stack)-1]
	if !expr.(AsBool).BoolValue {
		return nil
	}
	BreakValue, err, _ = scope.VisitorVisit(node.(For).ForBody, IsTry, VariableScope)
	if err != nil {
		return err
	}
	if BreakValue {
		return nil
	}
	goto LOOP
}

func (scope *Scope) OpTry(node AST, VariableScope *map[string]AST) *Error {
	_, err, _ := scope.VisitorVisit(node.(Try).TryBody, true, VariableScope)
	if err != nil {
		for i := 0; i < len(node.(Try).ExceptErrors); i++ {
			if node.(Try).ExceptErrors[i].(AsError).err == err.Type {
				scope.VisitorVisit(node.(Try).ExceptBodys[i], false, VariableScope)
				return nil
			}
		}
	}
	return err
}

func (scope *Scope) OpInc(node AST) *Error {
	if len(scope.Stack) < 1 {
		err := Error{}
		err.message = fmt.Sprintf("%s:StackUnderflowError:%d:%d: `inc` expected one or more <int> type element in the stack.", node.(AsId).Position.FileName, node.(AsId).Position.Line, node.(AsId).Position.Column)
		err.Type = StackUnderflowError
		return &err
	}
	first := scope.Stack[len(scope.Stack)-1]
	_, ok := first.(AsInt)
	if !ok {
		err := Error{}
		err.message = fmt.Sprintf("%s:StackUnderflowError:%d:%d: `inc` expected one or more <int> type element in the stack.", node.(AsId).Position.FileName, node.(AsId).Position.Line, node.(AsId).Position.Column)
		err.Type = StackUnderflowError
		return &err
	}
	scope.Stack = scope.Stack[:len(scope.Stack)-1]
	val := first.(AsInt).IntValue + 1
	expr := AsInt{
		val,
	}
	scope.OpPush(expr, nil)
	return nil
}

func (scope *Scope) OpDec(node AST) *Error {
	if len(scope.Stack) < 1 {
		err := Error{}
		err.message = fmt.Sprintf("%s:StackUnderflowError:%d:%d: `dec` expected one or more <int> type element in the stack.", node.(AsId).Position.FileName, node.(AsId).Position.Line, node.(AsId).Position.Column)
		err.Type = StackUnderflowError
		return &err
	}
	first := scope.Stack[len(scope.Stack)-1]
	_, ok := first.(AsInt)
	if !ok {
		err := Error{}
		err.message = fmt.Sprintf("%s:StackUnderflowError:%d:%d: `dec` expected one or more <int> type element in the stack.", node.(AsId).Position.FileName, node.(AsId).Position.Line, node.(AsId).Position.Column)
		err.Type = StackUnderflowError
		return &err
	}
	scope.Stack = scope.Stack[:len(scope.Stack)-1]
	val := first.(AsInt).IntValue - 1
	expr := AsInt{
		val,
	}
	scope.OpPush(expr, nil)
	return nil
}

func (scope *Scope) OpDup(node AST) *Error {
	if len(scope.Stack) < 1 {
		err := Error{}
		err.message = fmt.Sprintf("%s:StackUnderflowError:%d:%d: `dup` expected one or more <int> type element in the stack.", node.(AsId).Position.FileName, node.(AsId).Position.Line, node.(AsId).Position.Column)
		err.Type = StackUnderflowError
		return &err
	}
	first := scope.Stack[len(scope.Stack)-1]
	scope.OpPush(first, nil)
	return nil
}

func (scope *Scope) OpAppend(node AST) *Error {
	if len(scope.Stack) < 2 {
		err := Error{}
		err.message = fmt.Sprintf("%s:StackUnderflowError:%d:%d: `append` expected two or more element in the stack.", node.(AsId).Position.FileName, node.(AsId).Position.Line, node.(AsId).Position.Column)
		err.Type = StackUnderflowError
		return &err
	}
	if _, ok := scope.Stack[len(scope.Stack)-2].(AsList); !ok {
		err := Error{}
		err.message = fmt.Sprintf("%s:TypeError:%d:%d: `append` expected <list> type element in the stack.", node.(AsId).Position.FileName, node.(AsId).Position.Line, node.(AsId).Position.Column)
		err.Type = TypeError
		return &err
	}
	a := append(scope.Stack[len(scope.Stack)-2].(AsList).ListArgs, scope.Stack[len(scope.Stack)-1])
	scope.Stack = scope.Stack[:len(scope.Stack)-2]
	var NewList AST = AsList{
		a,
	}
	scope.OpPush(NewList, nil)
	return nil
}

func (scope *Scope) OpRead(node AST) *Error {
	if len(scope.Stack) < 2 {
		err := Error{}
		err.message = fmt.Sprintf("%s:StackUnderflowError:%d:%d: `read` expected two or more element in the stack.", node.(AsId).Position.FileName, node.(AsId).Position.Line, node.(AsId).Position.Column)
		err.Type = StackUnderflowError
		return &err
	}
	visitedList := scope.Stack[len(scope.Stack)-2]
	visitedIndex := scope.Stack[len(scope.Stack)-1]
	if _, ok := visitedIndex.(AsInt); !ok {
		err := Error{}
		err.message = fmt.Sprintf("%s:TypeError:%d:%d: `read` index expected <int> type element in the stack.", node.(AsId).Position.FileName, node.(AsId).Position.Line, node.(AsId).Position.Column)
		err.Type = TypeError
		return &err
	}
	_, ok := visitedList.(AsStr)
	_, ok2 := visitedList.(AsList)
	if !ok && !ok2 {
		err := Error{}
		err.message = fmt.Sprintf("%s:TypeError:%d:%d: `read` expected <list> or <string> type element in the stack.", node.(AsId).Position.FileName, node.(AsId).Position.Line, node.(AsId).Position.Column)
		err.Type = TypeError
		return &err
	}
	scope.Stack = scope.Stack[:len(scope.Stack)-2]
	if _, ok := visitedList.(AsList); ok {
		if len(visitedList.(AsList).ListArgs) <= visitedIndex.(AsInt).IntValue {
			err := Error{}
			err.message = fmt.Sprintf("%s:IndexError:%d:%d: `read` type <list> element index out of range.", node.(AsId).Position.FileName, node.(AsId).Position.Line, node.(AsId).Position.Column)
			err.Type = IndexError
			return &err
		}
		scope.OpPush(visitedList.(AsList).ListArgs[visitedIndex.(AsInt).IntValue], nil)
	} else {
		if len(visitedList.(AsStr).StringValue) <= visitedIndex.(AsInt).IntValue {
			err := Error{}
			err.message = fmt.Sprintf("%s:IndexError:%d:%d: `read` type <string> element index out of range.", node.(AsId).Position.FileName, node.(AsId).Position.Line, node.(AsId).Position.Column)
			err.Type = IndexError
			return &err
		}
		StringValue := string([]rune(visitedList.(AsStr).StringValue)[visitedIndex.(AsInt).IntValue])
		var StrExpr AST = AsStr{
			StringValue,
		}
		scope.OpPush(StrExpr, nil)
	}
	return nil
}

func (scope *Scope) OpReplace(node AST) *Error {
	if len(scope.Stack) < 3 {
		err := Error{}
		err.message = fmt.Sprintf("%s:StackUnderflowError:%d:%d: `replace` expected three or more element in the stack.", node.(AsId).Position.FileName, node.(AsId).Position.Line, node.(AsId).Position.Column)
		err.Type = StackUnderflowError
		return &err
	}
	visitedList := scope.Stack[len(scope.Stack)-3]
	visitedValue := scope.Stack[len(scope.Stack)-2]
	visitedIndex := scope.Stack[len(scope.Stack)-1]
	if _, ok := visitedIndex.(AsInt); !ok {
		err := Error{}
		err.message = fmt.Sprintf("%s:TypeError:%d:%d: `replace` index expected <int> type element in the stack.", node.(AsId).Position.FileName, node.(AsId).Position.Line, node.(AsId).Position.Column)
		err.Type = TypeError
		return &err
	}
	if _, ok := visitedList.(AsList); !ok {
		err := Error{}
		err.message = fmt.Sprintf("%s:TypeError:%d:%d: `replace` expected <list> type element in the stack.", node.(AsId).Position.FileName, node.(AsId).Position.Line, node.(AsId).Position.Column)
		err.Type = TypeError
		return &err
	}
	if len(visitedList.(AsList).ListArgs) <= visitedIndex.(AsInt).IntValue {
		err := Error{}
		err.message = fmt.Sprintf("%s:IndexError:%d:%d: `replace` type <list> element index out of range.", node.(AsId).Position.FileName, node.(AsId).Position.Line, node.(AsId).Position.Column)
		err.Type = IndexError
		return &err
	}
	visitedList.(AsList).ListArgs[visitedIndex.(AsInt).IntValue] = visitedValue
	scope.Stack = scope.Stack[:len(scope.Stack)-3]
	scope.OpPush(visitedList, nil)
	return nil
}

func (scope *Scope) OpRemove(node AST) *Error {
	if len(scope.Stack) < 2 {
		err := Error{}
		err.message = fmt.Sprintf("%s:StackUnderflowError:%d:%d: `remove` expected two or more element in the stack.", node.(AsId).Position.FileName, node.(AsId).Position.Line, node.(AsId).Position.Column)
		err.Type = StackUnderflowError
		return &err
	}
	visitedList := scope.Stack[len(scope.Stack)-2]
	visitedIndex := scope.Stack[len(scope.Stack)-1]
	if _, ok := visitedIndex.(AsInt); !ok {
		err := Error{}
		err.message = fmt.Sprintf("%s:TypeError:%d:%d: `remove` index expected <int> type element in the stack.", node.(AsId).Position.FileName, node.(AsId).Position.Line, node.(AsId).Position.Column)
		err.Type = TypeError
		return &err
	}
	if _, ok := visitedList.(AsList); !ok {
		err := Error{}
		err.message = fmt.Sprintf("%s:TypeError:%d:%d: `remove` expected <list> type element in the stack.", node.(AsId).Position.FileName, node.(AsId).Position.Line, node.(AsId).Position.Column)
		err.Type = TypeError
		return &err
	}
	if len(visitedList.(AsList).ListArgs) <= visitedIndex.(AsInt).IntValue {
		err := Error{}
		err.message = fmt.Sprintf("%s:IndexError:%d:%d: `remove` type <list> element index out of range.", node.(AsId).Position.FileName, node.(AsId).Position.Line, node.(AsId).Position.Column)
		err.Type = IndexError
		return &err
	}

	NewList := append(visitedList.(AsList).ListArgs[:visitedIndex.(AsInt).IntValue], visitedList.(AsList).ListArgs[int(visitedIndex.(AsInt).IntValue)+1:]...)
	var ListExpr AST = AsList{
		NewList,
	}
	visitedList = nil
	scope.Stack = scope.Stack[:len(scope.Stack)-2]
	scope.OpPush(ListExpr, nil)
	return nil
}

func (scope *Scope) OpIn(node AST) *Error {
	if len(scope.Stack) < 2 {
		err := Error{}
		err.message = fmt.Sprintf("%s:StackUnderflowError:%d:%d: `in` expected two or more element in the stack.", node.(AsId).Position.FileName, node.(AsId).Position.Line, node.(AsId).Position.Column)
		err.Type = StackUnderflowError
		return &err
	}
	visitedVal := scope.Stack[len(scope.Stack)-2]
	visitedList := scope.Stack[len(scope.Stack)-1]
	scope.Stack = scope.Stack[:len(scope.Stack)-2]
	if _, ok := visitedList.(AsList); !ok {
		err := Error{}
		err.message = fmt.Sprintf("%s:TypeError:%d:%d: `in` expected <list> type element in the stack.", node.(AsId).Position.FileName, node.(AsId).Position.Line, node.(AsId).Position.Column)
		err.Type = TypeError
		return &err
	}
	for i := 0; i < len(visitedList.(AsList).ListArgs); i++ {
		var val AST
		switch visitedVal.(type) {
		case AsStr:
			val = visitedVal.(AsStr)
		case AsInt:
			val = visitedVal.(AsInt)
		case AsList:
			val = visitedVal.(AsList)
		}
		if visitedList.(AsList).ListArgs[i] == val {
			expr := AsBool{
				true,
			}
			scope.OpPush(expr, nil)
			return nil
		}
	}
	expr := AsBool{
		false,
	}
	scope.OpPush(expr, nil)
	return nil
}

func (scope *Scope) OpLen(node AST) *Error {
	if len(scope.Stack) < 1 {
		err := Error{}
		err.message = fmt.Sprintf("%s:StackUnderflowError:%d:%d: `len` expected one or more element in the stack.", node.(AsId).Position.FileName, node.(AsId).Position.Line, node.(AsId).Position.Column)
		err.Type = StackUnderflowError
		return &err
	}
	visitedExpr := scope.Stack[len(scope.Stack)-1]
	_, ok := visitedExpr.(AsList)
	_, ok2 := visitedExpr.(AsStr)
	if !ok && !ok2 {
		err := Error{}
		err.message = fmt.Sprintf("%s:TypeError:%d:%d: `len` expected <list> or <string> type element in the stack.", node.(AsId).Position.FileName, node.(AsId).Position.Line, node.(AsId).Position.Column)
		err.Type = TypeError
		return &err
	}
	IntExpr := AsInt{}
	if ok {
		IntExpr.IntValue = len(visitedExpr.(AsList).ListArgs)
	} else {
		IntExpr.IntValue = len(visitedExpr.(AsStr).StringValue)
	}
	scope.Stack = scope.Stack[:len(scope.Stack)-1]
	scope.OpPush(IntExpr, nil)
	return nil
}

func (scope *Scope) OpTypeOf(node AST) *Error {
	if len(scope.Stack) < 1 {
		err := Error{}
		err.message = fmt.Sprintf("%s:StackUnderflowError:%d:%d: `typeof` expected one or more element in the stack.", node.(AsId).Position.FileName, node.(AsId).Position.Line, node.(AsId).Position.Column)
		err.Type = StackUnderflowError
		return &err
	}
	visitedVal := scope.Stack[len(scope.Stack)-1]
	var TypeVal string
	switch visitedVal.(type) {
	case AsStr:
		TypeVal = "string"
	case AsInt:
		TypeVal = "int"
	case AsList:
		TypeVal = "list"
	case AsBool:
		TypeVal = "bool"
	case AsType:
		TypeVal = "type"
	case AsError:
		TypeVal = "error"
	}
	expr := AsType{
		TypeVal,
	}
	scope.Stack = scope.Stack[:len(scope.Stack)-1]
	scope.OpPush(expr, nil)
	return nil
}

func (scope *Scope) OpRot(node AST) *Error {
	if len(scope.Stack) < 3 {
		err := Error{}
		err.message = fmt.Sprintf("%s:StackUnderflowError:%d:%d: `rot` expected more than three elements in the stack.", node.(AsId).Position.FileName, node.(AsId).Position.Line, node.(AsId).Position.Column)
		err.Type = StackUnderflowError
		return &err
	}
	visitedExpr := scope.Stack[len(scope.Stack)-1]
	visitedExprSecond := scope.Stack[len(scope.Stack)-2]
	visitedExprThird := scope.Stack[len(scope.Stack)-3]
	scope.Stack = scope.Stack[:len(scope.Stack)-3]
	scope.OpPush(visitedExprSecond, nil)
	scope.OpPush(visitedExpr, nil)
	scope.OpPush(visitedExprThird, nil)
	return nil
}

func (scope *Scope) OpOver(node AST) *Error {
	if len(scope.Stack) < 2 {
		err := Error{}
		err.message = fmt.Sprintf("%s:StackUnderflowError:%d:%d: `over` expected more than two elements in the stack.", node.(AsId).Position.FileName, node.(AsId).Position.Line, node.(AsId).Position.Column)
		err.Type = StackUnderflowError
		return &err
	}
	scope.OpPush(scope.Stack[len(scope.Stack)-2], nil)
	return nil
}

func (scope *Scope) OpVardef(name string, position NodePosition, VariableScope *map[string]AST) *Error {
	if len(scope.Stack) < 1 {
		err := Error{}
		err.message = fmt.Sprintf("%s:StackUnderflowError:%d:%d: variable `%s` definiton expected one or more element in the stack.", position.FileName, position.Line, position.Column, name)
		err.Type = StackUnderflowError
		return &err
	}
	if VariableScope == nil {
		VarValue := scope.Stack[len(scope.Stack)-1]
		Variables[name] = VarValue
		scope.Stack = scope.Stack[:len(scope.Stack)-1]
	} else {
		if _, ok := Variables[name]; ok {
			VarValue := scope.Stack[len(scope.Stack)-1]
			Variables[name] = VarValue
			scope.Stack = scope.Stack[:len(scope.Stack)-1]
		} else {
			VarValue := scope.Stack[len(scope.Stack)-1]
			(*VariableScope)[name] = VarValue
			scope.Stack = scope.Stack[:len(scope.Stack)-1]
		}
	}
	return nil
}

func (scope *Scope) OpBlockdef(node AST) *Error {
	Variables[node.(Blockdef).Name] = node
	return nil
}

func (scope *Scope) OpInclude(FileName string, position NodePosition) *Error {
	if _, err := os.Stat(FileName); os.IsNotExist(err) {
		err := Error{}
		err.message = fmt.Sprintf("%s:IncludeError:%d:%d: invalid file name `%s`.", position.FileName, position.Line, position.Column, FileName)
		err.Type = IncludeError
		return &err
	}
	file, err := os.Open(FileName)
	if err != nil {
		panic(err)
	}
	lexer := LexerInit(file, FileName)
	parser := ParserInit(lexer)
	ast := ParserParse(parser)
	scope.VisitorVisit(ast, false, nil)
	return nil
}

func (scope *Scope) OpAssert(node AST) *Error {
	if len(scope.Stack) < 1 {
		err := Error{}
		err.message = fmt.Sprintf("%s:StackUnderflowError:%d:%d: `assert` expected one or more <bool> type element in the stack.", node.(Assert).Position.FileName, node.(Assert).Position.Line, node.(Assert).Position.Column)
		err.Type = StackUnderflowError
		return &err
	}
	BoolValue := scope.Stack[len(scope.Stack)-1]
	if _, ok := BoolValue.(AsBool); !ok {
		err := Error{}
		err.message = fmt.Sprintf("%s:TypeError:%d:%d: `assert` expected <bool> type element in the stack.", node.(Assert).Position.FileName, node.(Assert).Position.Line, node.(Assert).Position.Column)
		err.Type = TypeError
		return &err
	}
	scope.Stack = scope.Stack[:len(scope.Stack)-1]
	if !BoolValue.(AsBool).BoolValue {
		err := Error{}
		err.message = fmt.Sprintf("%s:AssertionError:%d:%d: %s", node.(Assert).Position.FileName, node.(Assert).Position.Line, node.(Assert).Position.Column, node.(Assert).Message)
		err.Type = AssertionError
		return &err
	}
	return nil
}

func (scope *Scope) OpInput() {
	inputReader := bufio.NewReader(os.Stdin)
	input, _ := inputReader.ReadString('\n')
	input = input[:len(input)-1]

	StrExpr := AsStr{
		input,
	}
	scope.OpPush(StrExpr, nil)
}

func (scope *Scope) OpFree() {
	scope.Stack = scope.Stack[:0]
}

func (scope *Scope) OpFopen(node AST) *Error {
	if len(scope.Stack) < 1 {
		err := Error{}
		err.message = fmt.Sprintf("%s:StackUnderflowError:%d:%d: `fopen` expected one or more <file> type element in the stack.", node.(AsId).Position.FileName, node.(AsId).Position.Line, node.(AsId).Position.Column)
		err.Type = StackUnderflowError
		return &err
	}

	FileName := scope.Stack[len(scope.Stack)-1]

	scope.Stack = scope.Stack[:len(scope.Stack)-1]

	if _, ok := FileName.(AsStr); !ok {
		err := Error{}
		err.message = fmt.Sprintf("%s:TypeError:%d:%d: `fopen` expected <string> type element in the stack.", node.(AsId).Position.FileName, node.(AsId).Position.Line, node.(AsId).Position.Column)
		err.Type = TypeError
		return &err
	}

	var file, err = os.OpenFile(FileName.(AsStr).StringValue, os.O_CREATE|os.O_RDWR, 0755)

	if err != nil {
		err := Error{}
		err.message = fmt.Sprintf("%s:FileNotFoundError:%d:%d: `fopen` invalid file name `%s`.", node.(AsId).Position.FileName, node.(AsId).Position.Line, node.(AsId).Position.Column, FileName.(AsStr).StringValue)
		err.Type = FileNotFoundError
		return &err
	}

	FileExpr := AsFile{
		file,
		FileName.(AsStr).StringValue,
	}

	scope.OpPush(FileExpr, nil)

	return nil
}

func (scope *Scope) OpFclose(node AST) *Error {
	if len(scope.Stack) < 1 {
		err := Error{}
		err.message = fmt.Sprintf("%s:StackUnderflowError:%d:%d: `fclose` expected one or more <file> type element in the stack.", node.(AsId).Position.FileName, node.(AsId).Position.Line, node.(AsId).Position.Column)
		err.Type = StackUnderflowError
		return &err
	}

	File := scope.Stack[len(scope.Stack)-1]

	scope.Stack = scope.Stack[:len(scope.Stack)-1]

	if _, ok := File.(AsFile); !ok {
		err := Error{}
		err.message = fmt.Sprintf("%s:TypeError:%d:%d: `fclose` expected <file> type element in the stack.", node.(AsId).Position.FileName, node.(AsId).Position.Line, node.(AsId).Position.Column)
		err.Type = TypeError
		return &err
	}

	File.(AsFile).FileAddress.Close()

	return nil
}

func (scope *Scope) OpFwrite(node AST) *Error {
	if len(scope.Stack) < 2 {
		err := Error{}
		err.message = fmt.Sprintf("%s:StackUnderflowError:%d:%d: `fwrite` expected type <string> and <file> element in the stack.", node.(AsId).Position.FileName, node.(AsId).Position.Line, node.(AsId).Position.Column)
		err.Type = StackUnderflowError
		return &err
	}

	File := scope.Stack[len(scope.Stack)-1]

	StringValue := scope.Stack[len(scope.Stack)-2]

	scope.Stack = scope.Stack[:len(scope.Stack)-2]

	if _, ok := File.(AsFile); !ok {
		err := Error{}
		err.message = fmt.Sprintf("%s:TypeError:%d:%d: `fwrite` expected <file> type element in the stack.", node.(AsId).Position.FileName, node.(AsId).Position.Line, node.(AsId).Position.Column)
		err.Type = TypeError
		return &err
	}

	if _, ok := StringValue.(AsStr); !ok {
		err := Error{}
		err.message = fmt.Sprintf("%s:TypeError:%d:%d: `fwrite` expected <string> type element in the stack.", node.(AsId).Position.FileName, node.(AsId).Position.Line, node.(AsId).Position.Column)
		err.Type = TypeError
		return &err
	}

	if _, err := File.(AsFile).FileAddress.WriteString(StringValue.(AsStr).StringValue); err != nil {
		err := Error{}
		err.message = fmt.Sprintf("%s:FileNotFoundError:%d:%d: `fopen` invalid file name `%s`.", node.(AsId).Position.FileName, node.(AsId).Position.Line, node.(AsId).Position.Column, File.(AsFile).FileName)
		err.Type = FileNotFoundError
		return &err
	}

	return nil
}

func (scope *Scope) OpFread(node AST) *Error {
	if len(scope.Stack) < 1 {
		err := Error{}
		err.message = fmt.Sprintf("%s:StackUnderflowError:%d:%d: `fread` expected at least one <file> type element in the stack.", node.(AsId).Position.FileName, node.(AsId).Position.Line, node.(AsId).Position.Column)
		err.Type = StackUnderflowError
		return &err
	}

	File := scope.Stack[len(scope.Stack)-1]

	scope.Stack = scope.Stack[:len(scope.Stack)-1]

	if _, ok := File.(AsFile); !ok {
		err := Error{}
		err.message = fmt.Sprintf("%s:TypeError:%d:%d: `fread` expected <file> type element in the stack.", node.(AsId).Position.FileName, node.(AsId).Position.Line, node.(AsId).Position.Column)
		err.Type = TypeError
		return &err
	}

	body, err := os.ReadFile(File.(AsFile).FileName)

	if err != nil {
		err := Error{}
		err.message = fmt.Sprintf("%s:FileNotFoundError:%d:%d: `fopen` invalid file name `%s`.", node.(AsId).Position.FileName, node.(AsId).Position.Line, node.(AsId).Position.Column, File.(AsFile).FileName)
		err.Type = FileNotFoundError
		return &err
	}

	StrExpr := AsStr{
		string(body),
	}

	scope.OpPush(StrExpr, nil)
	return nil
}

func (scope *Scope) OpFtruncate(node AST) *Error {
	if len(scope.Stack) < 1 {
		err := Error{}
		err.message = fmt.Sprintf("%s:StackUnderflowError:%d:%d: `ftruncate` expected at least one <string> type element in the stack.", node.(AsId).Position.FileName, node.(AsId).Position.Line, node.(AsId).Position.Column)
		err.Type = StackUnderflowError
		return &err
	}

	File := scope.Stack[len(scope.Stack)-1]
	scope.Stack = scope.Stack[:len(scope.Stack)-1]

	if _, ok := File.(AsFile); !ok {
		err := Error{}
		err.message = fmt.Sprintf("%s:TypeError:%d:%d: `ftruncate` expected <file> type element in the stack.", node.(AsId).Position.FileName, node.(AsId).Position.Line, node.(AsId).Position.Column)
		err.Type = TypeError
		return &err
	}

	err := os.Truncate(File.(AsFile).FileName, 200)

	if err != nil {
		err := Error{}
		err.message = fmt.Sprintf("%s:FileNotFoundError:%d:%d: `fopen` invalid file name `%s`.", node.(AsId).Position.FileName, node.(AsId).Position.Line, node.(AsId).Position.Column, File.(AsStr).StringValue)
		err.Type = FileNotFoundError
		return &err
	}

	return nil
}

func (scope *Scope) OpIsdigit(node AST) *Error {
	if len(scope.Stack) < 1 {
		err := Error{}
		err.message = fmt.Sprintf("%s:StackUnderflowError:%d:%d: `isdigit` expected at least one <string> type element in the stack.", node.(AsId).Position.FileName, node.(AsId).Position.Line, node.(AsId).Position.Column)
		err.Type = StackUnderflowError
		return &err
	}

	StringValue := scope.Stack[len(scope.Stack)-1]
	scope.Stack = scope.Stack[:len(scope.Stack)-1]

	if _, ok := StringValue.(AsStr); !ok {
		err := Error{}
		err.message = fmt.Sprintf("%s:TypeError:%d:%d: `isdigit` expected <string> type element in the stack.", node.(AsId).Position.FileName, node.(AsId).Position.Line, node.(AsId).Position.Column)
		err.Type = TypeError
		return &err
	}

	_, err := strconv.Atoi(StringValue.(AsStr).StringValue)

	var BoolValue bool

	if err != nil {
		BoolValue = false
	} else {
		BoolValue = true
	}

	err = nil

	BoolExpr := AsBool{
		BoolValue,
	}

	scope.OpPush(BoolExpr, nil)

	return nil
}

func (scope *Scope) OpAtoi(node AST) *Error {
	if len(scope.Stack) < 1 {
		err := Error{}
		err.message = fmt.Sprintf("%s:StackUnderflowError:%d:%d: `atoi` expected at least one <string> type element in the stack.", node.(AsId).Position.FileName, node.(AsId).Position.Line, node.(AsId).Position.Column)
		err.Type = StackUnderflowError
		return &err
	}

	StringValue := scope.Stack[len(scope.Stack)-1]
	scope.Stack = scope.Stack[:len(scope.Stack)-1]

	if _, ok := StringValue.(AsStr); !ok {
		err := Error{}
		err.message = fmt.Sprintf("%s:TypeError:%d:%d: `atoi` expected <string> type element in the stack.", node.(AsId).Position.FileName, node.(AsId).Position.Line, node.(AsId).Position.Column)
		err.Type = TypeError
		return &err
	}

	IntValue, err := strconv.Atoi(StringValue.(AsStr).StringValue)
	if err != nil {
		IntValue = 0
		err = nil
	}

	scope.OpPush(AsInt{IntValue}, nil)

	return nil
}

func (scope *Scope) OpItoa(node AST) *Error {
	if len(scope.Stack) < 1 {
		err := Error{}
		err.message = fmt.Sprintf("%s:StackUnderflowError:%d:%d: `atoi` expected at least one <int> type element in the stack.", node.(AsId).Position.FileName, node.(AsId).Position.Line, node.(AsId).Position.Column)
		err.Type = StackUnderflowError
		return &err
	}

	IntValue := scope.Stack[len(scope.Stack)-1]
	scope.Stack = scope.Stack[:len(scope.Stack)-1]

	if _, ok := IntValue.(AsInt); !ok {
		err := Error{}
		err.message = fmt.Sprintf("%s:TypeError:%d:%d: `atoi` expected <int> type element in the stack.", node.(AsId).Position.FileName, node.(AsId).Position.Line, node.(AsId).Position.Column)
		err.Type = TypeError
		return &err
	}

	StringValue := strconv.Itoa(IntValue.(AsInt).IntValue)

	scope.OpPush(AsStr{StringValue}, nil)
	return nil
}

func (scope *Scope) OpBytes(node AST) *Error {
	if len(scope.Stack) < 1 {
		err := Error{}
		err.message = fmt.Sprintf("%s:StackUnderflowError:%d:%d: `tobyte` expected at least one <string> type element in the stack.", node.(AsId).Position.FileName, node.(AsId).Position.Line, node.(AsId).Position.Column)
		err.Type = StackUnderflowError
		return &err
	}

	StringValue := scope.Stack[len(scope.Stack)-1]

	if _, ok := StringValue.(AsStr); !ok {
		err := Error{}
		err.message = fmt.Sprintf("%s:TypeError:%d:%d: `b` expected <string> type element in the stack.", node.(AsId).Position.FileName, node.(AsId).Position.Line, node.(AsId).Position.Column)
		err.Type = TypeError
		return &err
	}

	scope.Stack = scope.Stack[:len(scope.Stack)-1]

	ByteArray := []byte(StringValue.(AsStr).StringValue)

	NewScope := InitScope()

	for i := 0; i < len(ByteArray); i++ {
		IntValue, err := strconv.Atoi(fmt.Sprintf("%v", ByteArray[i]))
		if err != nil {
			IntValue = 0
			err = nil
		}
		NewScope.Stack = append(NewScope.Stack, AsInt{IntValue})
	}

	scope.Stack = append(scope.Stack, AsList{NewScope.Stack})

	return nil
}

func (scope *Scope) OpUniquote(node AST) *Error {
	if len(scope.Stack) < 1 {
		err := Error{}
		err.message = fmt.Sprintf("%s:StackUnderflowError:%d:%d: `uniquote` expected at least one <string> type element in the stack.", node.(AsId).Position.FileName, node.(AsId).Position.Line, node.(AsId).Position.Column)
		err.Type = StackUnderflowError
		return &err
	}

	StringValue := scope.Stack[len(scope.Stack)-1]

	if _, ok := StringValue.(AsStr); !ok {
		err := Error{}
		err.message = fmt.Sprintf("%s:TypeError:%d:%d: `uniquote` expected <string> type element in the stack.", node.(AsId).Position.FileName, node.(AsId).Position.Line, node.(AsId).Position.Column)
		err.Type = TypeError
		return &err
	}

	scope.Stack = scope.Stack[:len(scope.Stack)-1]

	val, _ := strconv.Unquote("\"" + StringValue.(AsStr).StringValue + "\"")

	scope.Stack = append(scope.Stack, AsStr{val})

	return nil
}

const ShellToUse = "bash"

func Shellout(command string) (error, string, string) {
	var stdout bytes.Buffer
	var stderr bytes.Buffer
	cmd := exec.Command(ShellToUse, "-c", command)
	cmd.Stdout = &stdout
	cmd.Stderr = &stderr
	err := cmd.Run()
	return err, stdout.String(), stderr.String()
}

func (scope *Scope) OpSystem(node AST) *Error {
	if len(scope.Stack) < 1 {
		err := Error{}
		err.message = fmt.Sprintf("%s:StackUnderflowError:%d:%d: `system` expected at least one <string> type element in the stack.", node.(AsId).Position.FileName, node.(AsId).Position.Line, node.(AsId).Position.Column)
		err.Type = StackUnderflowError
		return &err
	}

	StringValue := scope.Stack[len(scope.Stack)-1]

	if _, ok := StringValue.(AsStr); !ok {
		err := Error{}
		err.message = fmt.Sprintf("%s:TypeError:%d:%d: `system` expected <string> type element in the stack.", node.(AsId).Position.FileName, node.(AsId).Position.Line, node.(AsId).Position.Column)
		err.Type = TypeError
		return &err
	}

	scope.Stack = scope.Stack[:len(scope.Stack)-1]

	err, out, _ := Shellout(StringValue.(AsStr).StringValue)

	if err != nil {
		err := Error{}
		err.message = fmt.Sprintf("%s:CommandError:%d:%d: `system` something whent wrong...", node.(AsId).Position.FileName, node.(AsId).Position.Line, node.(AsId).Position.Column)
		err.Type = CommandError
		return &err
	}

	fmt.Print(out)

	return nil
}

func (scope *Scope) OpAgrv() {
	NewScope := InitScope()
	for i := 0; i < len(os.Args); i++ {
		NewScope.OpPush(AsStr{os.Args[i]}, nil)
	}
	Variables["argv"] = AsList{NewScope.Stack}
}

// -----------------------------
// --------- Visitor -----------
// -----------------------------

func (scope *Scope) VisitorVisit(node AST, IsTry bool, VariableScope *map[string]AST) (bool, *Error, *map[string]AST) {
	BreakValue := false
	var err *Error
	for i := 0; i < len(node.(AsStatements)); i++ {
		node := node.(AsStatements)[i]
		switch node.(type) {
		case AsPush:
			err = scope.OpPush(node.(AsPush).value, VariableScope)
		case AsId:
			switch node.(AsId).name {
			case "println":
				err = scope.OpPrintln(node)
			case "print":
				err = scope.OpPrint(node)
			case "break":
				BreakValue = true
			case "drop":
				err = scope.OpDrop(node)
			case "swap":
				err = scope.OpSwap(node)
			case "inc":
				err = scope.OpInc(node)
			case "dec":
				err = scope.OpDec(node)
			case "dup":
				err = scope.OpDup(node)
			case "append":
				err = scope.OpAppend(node)
			case "read":
				err = scope.OpRead(node)
			case "replace":
				err = scope.OpReplace(node)
			case "remove":
				err = scope.OpRemove(node)
			case "in":
				err = scope.OpIn(node)
			case "len":
				err = scope.OpLen(node)
			case "typeof":
				err = scope.OpTypeOf(node)
			case "rot":
				err = scope.OpRot(node)
			case "over":
				err = scope.OpOver(node)
			case "exit":
				os.Exit(0)
			case "input":
				scope.OpInput()
			case "free":
				scope.OpFree()
			case "fopen":
				err = scope.OpFopen(node)
			case "fwrite":
				err = scope.OpFwrite(node)
			case "fclose":
				err = scope.OpFclose(node)
			case "fread":
				err = scope.OpFread(node)
			case "ftruncate":
				err = scope.OpFtruncate(node)
			case "isdigit":
				err = scope.OpIsdigit(node)
			case "atoi":
				err = scope.OpAtoi(node)
			case "itoa":
				err = scope.OpItoa(node)
			case "b":
				err = scope.OpBytes(node)
			case "uniquote":
				err = scope.OpUniquote(node)
			case "system":
				err = scope.OpSystem(node)
			default:
				panic("unreachable")
			}
		case AsBinop:
			err = scope.OpBinop(node.(AsBinop).op, node.(AsBinop).Position)
		case Vardef:
			err = scope.OpVardef(node.(Vardef).Name, node.(Vardef).Position, VariableScope)
		case Blockdef:
			err = scope.OpBlockdef(node)
		case Include:
			err = scope.OpInclude(node.(Include).FileName, node.(Include).Position)
		case Compare:
			err = scope.OpCompare(node.(Compare).op, node.(Compare).Position)
		case AsStatements:
			scope.VisitorVisit(node.(AsStatements), IsTry, VariableScope)
		case If:
			BreakValue, err = scope.OpIf(node.(If), IsTry, VariableScope)
		case For:
			err = scope.OpFor(node.(For), IsTry, VariableScope)
		case Try:
			err = scope.OpTry(node.(Try), VariableScope)
		case Assert:
			err = scope.OpAssert(node)
		default:
			panic("unreachable")
		}
		if err != nil {
			if !IsTry {
				fmt.Println(err.message)
				os.Exit(0)
			}
			return BreakValue, err, VariableScope
		}
		if BreakValue {
			break
		}
	}
	return BreakValue, err, VariableScope
}

// -----------------------------
// ----------- Main ------------
// -----------------------------

func Usage() {
	fmt.Println("Usage:")
	fmt.Println("  tsh <filename>.tsp")
	os.Exit(0)
}

func main() {
	if len(os.Args) <= 1 || os.Args[1] == "help" {
		Usage()
	}

	file, err := os.Open(os.Args[1])
	if err != nil {
		fmt.Println(fmt.Sprintf("Error: invalid file name `%s`.", os.Args[1]))

		whilte := color.New(color.FgWhite)

		fmt.Print("Run ")
		boldWhite := whilte.Add(color.BgCyan)
		boldWhite.Print(" tsh help ")
		fmt.Println(" for usage")

		os.Exit(0)
	}

	lexer := LexerInit(file, os.Args[1])
	parser := ParserInit(lexer)
	ast := ParserParse(parser)
	scope := InitScope()
	scope.OpAgrv()
	scope.VisitorVisit(ast, false, nil)
}