From f7603e30c4a4e523e2d5904a5cadeb7e80c61b3e Mon Sep 17 00:00:00 2001 From: William Bell Date: Wed, 8 Mar 2023 19:04:53 +0000 Subject: [PATCH] colourise the terminal --- src/built-in-functions.go | 19 +----- src/built-ins.go | 5 +- src/comment.go | 6 +- src/error.go | 4 +- src/import.go | 2 +- src/input.go | 19 ++++++ src/main.go | 4 +- src/map.go | 3 +- src/maths constants.go | 1 + src/operations.go | 124 ++++++++++++++++++++++++++++++++++---- src/run.go | 11 ++-- src/shell.go | 36 +++++++++++ src/string.go | 16 ++++- src/term-class.go | 100 +++++++++++++++++++++++++++--- src/to-argon.go | 83 +++++++++++++++++++------ src/translate.go | 9 ++- src/variable.go | 2 +- test.ar | 5 +- 18 files changed, 373 insertions(+), 76 deletions(-) create mode 100644 src/input.go create mode 100644 src/shell.go diff --git a/src/built-in-functions.go b/src/built-in-functions.go index 61edcf5..4afd5cd 100644 --- a/src/built-in-functions.go +++ b/src/built-in-functions.go @@ -1,10 +1,7 @@ package main import ( - "bufio" - "fmt" "math/big" - "os" ) type builtinFunc struct { @@ -12,22 +9,12 @@ type builtinFunc struct { FUNC func(...any) (any, ArErr) } -func ArgonMult(args ...any) (any, ArErr) { - return reduce(func(x any, y any) any { - return newNumber().Mul(y.(number), x.(number)) - }, args), ArErr{} +func ArgonString(args ...any) (any, ArErr) { + return anyToArgon(args[0], true, false, 3, 0, false, 0), ArErr{} } func ArgonInput(args ...any) (any, ArErr) { - output := []any{} - for i := 0; i < len(args); i++ { - output = append(output, anyToArgon(args[i], false, true, 3, 0)) - } - fmt.Print(output...) - scanner := bufio.NewScanner(os.Stdin) - scanner.Scan() - input := scanner.Text() - return input, ArErr{} + return input(args...), ArErr{} } func ArgonNumber(args ...any) (any, ArErr) { diff --git a/src/built-ins.go b/src/built-ins.go index 83f9928..61d5ac5 100644 --- a/src/built-ins.go +++ b/src/built-ins.go @@ -3,14 +3,15 @@ package main var vars = scope{} func init() { - vars["window"] = vars + vars["vars"] = vars vars["term"] = ArTerm vars["true"] = true vars["false"] = false vars["null"] = nil vars["input"] = builtinFunc{"input", ArgonInput} vars["number"] = builtinFunc{"number", ArgonNumber} - vars["mult"] = builtinFunc{"mult", ArgonMult} + vars["string"] = builtinFunc{"string", ArgonString} + vars["infinity"] = infinity vars["length"] = builtinFunc{"length", func(a ...any) (any, ArErr) { switch x := a[0].(type) { case string: diff --git a/src/comment.go b/src/comment.go index d1a5ec2..2531673 100644 --- a/src/comment.go +++ b/src/comment.go @@ -4,7 +4,7 @@ import ( "strings" ) -var commentCompile = makeRegex("(.|\n)*//(.|\n)*") +var commentCompile = makeRegex("(.)*#(.)*") func isComment(code UNPARSEcode) bool { return commentCompile.MatchString(code.code) @@ -15,11 +15,11 @@ func isBlank(code UNPARSEcode) bool { } func parseComment(code UNPARSEcode, index int, codelines []UNPARSEcode) (any, bool, ArErr) { - split := strings.Split(code.code, "//") + split := strings.Split(code.code, "#") temp := []string{} for i := 0; i < len(split)-1; i++ { temp = append(temp, split[i]) - joined := strings.Join(temp, "//") + joined := strings.Join(temp, "#") resp, worked, _, _ := translateVal(UNPARSEcode{code: joined, realcode: code.realcode, line: code.line, path: code.path}, index, codelines, true) if worked { return resp, true, ArErr{} diff --git a/src/error.go b/src/error.go index c1ae632..ff41ed3 100644 --- a/src/error.go +++ b/src/error.go @@ -2,7 +2,6 @@ package main import ( "fmt" - "os" ) type ArErr struct { @@ -20,6 +19,5 @@ func panicErr(err ArErr) { fmt.Println(" " + err.code) fmt.Println() } - fmt.Println(err.TYPE+":", err.message) - os.Exit(1) + fmt.Printf("\x1b[%dm%s\x1b[0m", 91, fmt.Sprint(err.TYPE, ": ", err.message, "\n")) } diff --git a/src/import.go b/src/import.go index 217dc34..ca739ad 100644 --- a/src/import.go +++ b/src/import.go @@ -99,7 +99,7 @@ func importMod(realpath string, origin string, main bool) ArErr { return translationerr } global := scope{} - _, runimeErr := run(translated, stack{vars, global}) + _, runimeErr, _, _ := run(translated, stack{vars, global}) if runimeErr.EXISTS { return runimeErr } diff --git a/src/input.go b/src/input.go new file mode 100644 index 0000000..d4194f4 --- /dev/null +++ b/src/input.go @@ -0,0 +1,19 @@ +package main + +import ( + "bufio" + "fmt" + "os" +) + +func input(args ...any) string { + output := []any{} + for i := 0; i < len(args); i++ { + output = append(output, anyToArgon(args[i], false, true, 3, 0, true, 0)) + } + fmt.Print(output...) + scanner := bufio.NewScanner(os.Stdin) + scanner.Scan() + input := scanner.Text() + return input +} diff --git a/src/main.go b/src/main.go index 2a6d6cd..7996460 100644 --- a/src/main.go +++ b/src/main.go @@ -16,10 +16,12 @@ func main() { panic(e) } if len(Args) == 0 { - panic("No file specified") + shell() + os.Exit(0) } err := importMod(Args[0], ex, true) if err.EXISTS { panicErr(err) + os.Exit(1) } } diff --git a/src/map.go b/src/map.go index eac4840..1aebfb8 100644 --- a/src/map.go +++ b/src/map.go @@ -45,6 +45,7 @@ func mapGet(r ArMapGet, stack stack) (any, ArErr) { } return m[key], ArErr{} case ArClass: + fmt.Println(m.MAP) if _, ok := m.MAP[key]; !ok { return nil, ArErr{ "KeyError", @@ -60,7 +61,7 @@ func mapGet(r ArMapGet, stack stack) (any, ArErr) { } return nil, ArErr{ "TypeError", - "cannot read " + anyToArgon(key, true, true, 3, 0) + " from type '" + typeof(resp) + "'", + "cannot read " + anyToArgon(key, true, true, 3, 0, false, 0) + " from type '" + typeof(resp) + "'", r.line, r.path, r.code, diff --git a/src/maths constants.go b/src/maths constants.go index 61385a3..d6aa998 100644 --- a/src/maths constants.go +++ b/src/maths constants.go @@ -2,3 +2,4 @@ package main var PI, _ = newNumber().SetString("3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679821480865132823066470938446095505822317253594081284811174502841027019385211055596446229489549303819644288109756659334461284756482337867831652712019091456485669234603486104543266482133936072602491412737245870066063155881748815209209628292540917153643678925903600113305305488204665213841469519415116094330572703657595919530921861173819326117931051185480744623799627495673518857527248912279381830119491298336733624406566430860213949463952247371907021798609437027705392171762931767523846748184676694051320005681271452635608277857713427577896091736371787214684409012249534301465495853710507922796892589235420199561121290219608640344181598136297747713099605187072113499999983729780499510597317328160963185950244594553469083026425223082533446850352619311881710100031378387528865875332083814206171776691473035982534904287554687311595628638823537875937519577818577805321712268066130019278766111959092164201989") var e, _ = newNumber().SetString("2.7182818284590452353602874713526624977572470936999595749669676277240766303535475945713821785251664274274663919320030599218174135966290435729003342952605956307381323286279434907632338298807531952510190115738341879307021540891499348841675092447614606680822648001684774118537423454424371075390777449920695517027618386062613313845830007520449338265602976067371132007093287091274437470472306969772093101416928368190255151086574637721112523897844250569536967707854499699679468644549059879316368892300987931277361782154249992295763514822082698951936680331825288693984964651058209392398294887933203625094431173012381970684161403970198376793206832823764648042953118023287825098194558153017567173613320698112509961818815930416903515988885193458072738667385894228792284998920868058257492796104841984443634632449684875602336248270419786232090021609902353043699418491463140934317381436405462531520961836908887070167683964243781405927145635490613031072085103837505101157477041718986106873969655212671546889570350354") +var infinity, _ = newNumber().SetString("1e1000") diff --git a/src/operations.go b/src/operations.go index 445eed5..7f7f459 100644 --- a/src/operations.go +++ b/src/operations.go @@ -58,6 +58,7 @@ func parseOperations(code UNPARSEcode, index int, codelines []UNPARSEcode) (oper for i := 0; i < len(operations); i++ { values := []any{} current := 0 + totalindex := 1 for l := 0; l < len(code.code); l++ { for j := 0; j < len(operations[i]); j++ { if len(code.code[l:]) >= len(operations[i][j]) && code.code[l:l+len(operations[i][j])] == operations[i][j] { @@ -71,7 +72,7 @@ func parseOperations(code UNPARSEcode, index int, codelines []UNPARSEcode) (oper }, index, codelines, false) if success { - index += respindex - 1 + totalindex += respindex - 1 values = append(values, resp) current = l + len(operations[i][j]) } @@ -87,7 +88,7 @@ func parseOperations(code UNPARSEcode, index int, codelines []UNPARSEcode) (oper path: code.path, }, index, codelines, false) if success { - index += respindex - 1 + totalindex += respindex - 1 values = append(values, resp) return operationType{ i, @@ -95,12 +96,12 @@ func parseOperations(code UNPARSEcode, index int, codelines []UNPARSEcode) (oper code.line, code.realcode, code.path, - }, true, err, index + }, true, err, totalindex } - return operationType{}, false, err, index + return operationType{}, false, err, totalindex } } - return operationType{}, false, ArErr{}, index + return operationType{}, false, ArErr{}, 0 } func compareValues(o operationType, stack stack) (bool, ArErr) { @@ -216,7 +217,7 @@ func calcNegative(o operationType, stack stack) (number, ArErr) { true, } } - output := resp.(number) + output := newNumber().Set(resp.(number)) for i := 1; i < len(o.values); i++ { resp, err := runVal( o.values[i], @@ -242,6 +243,52 @@ func calcNegative(o operationType, stack stack) (number, ArErr) { return output, ArErr{} } +func calcDiv(o operationType, stack stack) (number, ArErr) { + + resp, err := runVal( + o.values[0], + stack, + ) + resp = classVal(resp) + if err.EXISTS { + return nil, err + } + if !isAnyNumber(resp) { + return nil, ArErr{ + "Runtime Error", + "Cannot subtract from type '" + typeof(resp) + "'", + o.line, + o.path, + o.code, + true, + } + } + output := newNumber().Set(resp.(number)) + for i := 1; i < len(o.values); i++ { + resp, err := runVal( + o.values[i], + stack, + ) + resp = classVal(resp) + if err.EXISTS { + return nil, err + } + if typeof(resp) == "number" { + output = output.Quo(output, resp.(number)) + } else { + return nil, ArErr{ + "Runtime Error", + "Cannot divide type '" + typeof(resp) + "'", + o.line, + o.path, + o.code, + true, + } + } + } + return output, ArErr{} +} + func calcAdd(o operationType, stack stack) (any, ArErr) { resp, err := runVal( @@ -254,7 +301,9 @@ func calcAdd(o operationType, stack stack) (any, ArErr) { } var output any = resp if typeof(output) != "number" { - output = anyToArgon(resp, false, true, 3, 0) + output = anyToArgon(resp, false, true, 3, 0, false, 0) + } else { + output = newNumber().Set(output.(number)) } for i := 1; i < len(o.values); i++ { resp, err := runVal( @@ -266,18 +315,65 @@ func calcAdd(o operationType, stack stack) (any, ArErr) { return nil, err } if typeof(output) == "number" && typeof(resp) == "string" { - output = anyToArgon(output, false, true, 3, 0) + output = anyToArgon(output, false, true, 3, 0, false, 0) } if typeof(output) == "number" { - output = newNumber().Add(output.(number), resp.(number)) + output = output.(number).Add(output.(number), resp.(number)) } else { - output = output.(string) + anyToArgon(resp, false, true, 3, 0) + output = output.(string) + anyToArgon(resp, false, true, 3, 0, false, 0) } } return output, ArErr{} } +func calcMul(o operationType, stack stack) (any, ArErr) { + + resp, err := runVal( + o.values[0], + stack, + ) + resp = classVal(resp) + if err.EXISTS { + return nil, err + } + var output any = resp + if typeof(output) != "number" { + output = anyToArgon(resp, false, true, 3, 0, false, 0) + } else { + output = newNumber().Set(output.(number)) + } + for i := 1; i < len(o.values); i++ { + resp, err := runVal( + o.values[i], + stack, + ) + resp = classVal(resp) + if err.EXISTS { + return nil, err + } + if typeof(output) == "number" && typeof(resp) == "string" { + output = anyToArgon(output, false, true, 3, 0, false, 0) + } + if typeof(output) == "number" { + output = output.(number).Mul(output.(number), resp.(number)) + } else if typeof(resp) == "number" { + n, _ := resp.(number).Float64() + output = strings.Repeat(output.(string), int(n)) + } else { + return nil, ArErr{ + "Runtime Error", + "Cannot multiply type '" + typeof(resp) + "'", + o.line, + o.path, + o.code, + true, + } + } + } + return output, ArErr{} +} + func calcAnd(o operationType, stack stack) (any, ArErr) { var output any = false for i := 0; i < len(o.values); i++ { @@ -356,7 +452,7 @@ func calcIn(o operationType, stack stack) (bool, ArErr) { switch x := resp2.(type) { case string: - check := anyToArgon(resp, false, true, 3, 0) + check := anyToArgon(resp, false, true, 3, 0, false, 0) return strings.Contains(x, check), ArErr{} case []any: return stringInSlice(resp, x), ArErr{} @@ -379,7 +475,7 @@ func equals(a any, b any) bool { if typeof(a) == "number" && typeof(b) == "number" { return a.(number).Cmp(b.(number)) == 0 } else if typeof(a) == "string" || typeof(b) == "string" { - return anyToArgon(a, false, true, 3, 0) == anyToArgon(b, false, true, 3, 0) + return anyToArgon(a, false, false, 3, 0, false, 0) == anyToArgon(b, false, false, 3, 0, false, 0) } return reflect.DeepEqual(a, b) } @@ -412,6 +508,10 @@ func runOperation(o operationType, stack stack) (any, ArErr) { return calcAdd(o, stack) case 11: return calcNegative(o, stack) + case 12: + return calcMul(o, stack) + case 13: + return calcDiv(o, stack) } panic("Unknown operation: " + fmt.Sprint(o.operation)) diff --git a/src/run.go b/src/run.go index d7ae645..ee2ad80 100644 --- a/src/run.go +++ b/src/run.go @@ -54,12 +54,15 @@ func runVal(line any, stack stack) (any, ArErr) { } // returns error -func run(translated []any, stack stack) (any, ArErr) { +func run(translated []any, stack stack) (any, ArErr, int, any) { + var output any = nil + count := 0 for _, val := range translated { - _, err := runVal(val, stack) + val, err := runVal(val, stack) + output = val if err.EXISTS { - return nil, err + return nil, err, count, output } } - return nil, ArErr{} + return nil, ArErr{}, count, output } diff --git a/src/shell.go b/src/shell.go new file mode 100644 index 0000000..a753c8c --- /dev/null +++ b/src/shell.go @@ -0,0 +1,36 @@ +package main + +import ( + "fmt" + "os" + "os/signal" +) + +func shell() { + global := stack{vars, scope{}} + c := make(chan os.Signal, 1) + signal.Notify(c, os.Interrupt) + go func() { + for sig := range c { + if sig == os.Interrupt { + fmt.Println("\x1b[0m\n\x1b[32;5;240mBye :)\x1b[0m") + os.Exit(0) + } + } + }() + for { + code := input("\x1b[38;5;240m>>> \x1b[0m\x1b[1;5;240m") + fmt.Print("\x1b[0m") + translated, translationerr := translate([]UNPARSEcode{{code, code, 1, ""}}) + if translationerr.EXISTS { + panicErr(translationerr) + } + _, runimeErr, count, output := run(translated, global) + if runimeErr.EXISTS { + panicErr(runimeErr) + } + if count == 0 { + fmt.Println(anyToArgon(output, true, true, 3, 0, true, 1)) + } + } +} diff --git a/src/string.go b/src/string.go index d1bcb45..982b44b 100644 --- a/src/string.go +++ b/src/string.go @@ -11,6 +11,15 @@ func isString(code UNPARSEcode) bool { return stringCompile.MatchString(code.code) } +func toStringClass(str string) ArClass { + return ArClass{ + value: str, + MAP: ArMap{ + "length": len(str), + }, + } +} + func unquoted( str string, ) (string, error) { @@ -22,7 +31,12 @@ func unquoted( str = str[1 : len(str)-1] str = strings.Replace(str, "\\'", "'", -1) str = "\"" + str + "\"" - return strconv.Unquote(str) + output, err := strconv.Unquote(str) + if err != nil { + return "", err + } + classoutput := (output) + return classoutput, nil } // returns translateString, success, error diff --git a/src/term-class.go b/src/term-class.go index b3392a8..b6c6e80 100644 --- a/src/term-class.go +++ b/src/term-class.go @@ -1,16 +1,98 @@ package main -import "fmt" +import ( + "fmt" + "time" +) -func ArgonLog(args ...any) (any, ArErr) { - output := []any{} - for i := 0; i < len(args); i++ { - output = append(output, anyToArgon(args[i], false, true, 3, 0)) - } - fmt.Println(output...) - return nil, ArErr{} +var timing = ArMap{} + +var plain = ArMap{ + "log": builtinFunc{"log", func(args ...any) (any, ArErr) { + output := []any{} + for i := 0; i < len(args); i++ { + output = append(output, anyToArgon(args[i], false, true, 3, 0, false, 0)) + } + fmt.Println(output...) + return nil, ArErr{} + }}, + "logVal": builtinFunc{"logVal", func(args ...any) (any, ArErr) { + output := []any{} + for i := 0; i < len(args); i++ { + output = append(output, anyToArgon(args[i], true, true, 3, 0, false, 0)) + } + fmt.Println(output...) + return nil, ArErr{} + }}, } var ArTerm = ArMap{ - "log": builtinFunc{"log", ArgonLog}, + "log": builtinFunc{"log", func(args ...any) (any, ArErr) { + output := []any{} + for i := 0; i < len(args); i++ { + output = append(output, anyToArgon(args[i], false, true, 3, 0, true, 1)) + } + fmt.Println(output...) + return nil, ArErr{} + }}, + "logVal": builtinFunc{"logVal", func(args ...any) (any, ArErr) { + output := []any{} + for i := 0; i < len(args); i++ { + output = append(output, anyToArgon(args[i], true, true, 3, 0, true, 1)) + } + fmt.Println(output...) + return nil, ArErr{} + }}, + "print": builtinFunc{"print", func(args ...any) (any, ArErr) { + output := []any{} + for i := 0; i < len(args); i++ { + output = append(output, anyToArgon(args[i], false, false, 3, 0, false, 1)) + } + fmt.Println(output...) + return nil, ArErr{} + }}, + "plain": plain, + "error": builtinFunc{"error", func(args ...any) (any, ArErr) { + output := []any{"error: "} + for i := 0; i < len(args); i++ { + output = append(output, anyToArgon(args[i], false, true, 3, 0, false, 0)) + } + fmt.Printf("\x1b[%dm%s\x1b[0m", 91, fmt.Sprint(output...)+"\n") + return nil, ArErr{} + }, + }, + "warn": builtinFunc{"error", func(args ...any) (any, ArErr) { + output := []any{"warning: "} + for i := 0; i < len(args); i++ { + output = append(output, anyToArgon(args[i], false, true, 3, 0, false, 0)) + } + fmt.Printf("\x1b[%dm%s\x1b[0m", 93, fmt.Sprint(output...)+"\n") + return nil, ArErr{} + }, + }, + "time": builtinFunc{"time", func(args ...any) (any, ArErr) { + var id any = nil + if len(args) > 0 { + id = args[0] + } + timing[id] = time.Now() + return nil, ArErr{} + }, + }, + "timeEnd": builtinFunc{"timeEnd", func(args ...any) (any, ArErr) { + var id any = nil + if len(args) > 0 { + id = args[0] + } + if _, ok := timing[id]; !ok { + return nil, ArErr{TYPE: "TypeError", message: "Cannot find timer with id '" + fmt.Sprint(id) + "'", EXISTS: true} + } + timesince := time.Since(timing[id].(time.Time)) + delete(timing, id) + if id == nil { + id = "Timer" + } + fmt.Printf("\x1b[%dm%s\x1b[0m", 34, fmt.Sprint(anyToArgon(id, false, true, 3, 0, false, 0), ": ", timesince)+"\n") + return nil, ArErr{} + }}, } diff --git a/src/to-argon.go b/src/to-argon.go index 3996e0a..c4eb79d 100644 --- a/src/to-argon.go +++ b/src/to-argon.go @@ -7,34 +7,68 @@ import ( "strings" ) -func anyToArgon(x any, quote bool, simplify bool, depth int, indent int) string { +func anyToArgon(x any, quote bool, simplify bool, depth int, indent int, color bool, plain int) string { + output := []string{} + maybenewline := "" + if plain == 1 { + maybenewline = "\n" + } if depth == 0 { - return "(...)" + if color { + output = append(output, "\x1b[38;5;240m") + } + output = append(output, "(...)") + if color { + output = append(output, "\x1b[0m") + } + return strings.Join(output, "") } switch x := x.(type) { case string: if !quote { - return x + output = append(output, x) + break + } + if color { + output = append(output, "\x1b[33;5;240m") + } + output = append(output, strconv.Quote(x)) + if color { + output = append(output, "\x1b[0m") } - return strconv.Quote(x) case number: + if color { + output = append(output, "\x1b[34;5;240m") + } num, _ := x.Float64() if math.IsNaN(num) { - return "NaN" + output = append(output, "NaN") } else if math.IsInf(num, 1) { - return "infinity" + output = append(output, "infinity") } else if math.IsInf(num, -1) { - return "-infinity" + output = append(output, "-infinity") } else { - if simplify { - return numberToString(x, 0, true) - } - return numberToString(x, 0, false) + output = append(output, numberToString(x, 0, simplify)) + } + if color { + output = append(output, "\x1b[0m") } case bool: - return strconv.FormatBool(x) + if color { + output = append(output, "\x1b[35;5;240m") + } + output = append(output, strconv.FormatBool(x)) + if color { + output = append(output, "\x1b[0m") + } case nil: - return "null" + if color { + output = append(output, "\x1b[31;5;240m") + } + output = append(output, "null") + if color { + output = append(output, "\x1b[0m") + } case ArMap: keys := make([]any, len(x)) @@ -45,16 +79,29 @@ func anyToArgon(x any, quote bool, simplify bool, depth int, indent int) string } output := []string{} for _, key := range keys { - output = append(output, anyToArgon(key, true, true, depth, indent+1)+": "+anyToArgon(x[key], true, true, depth-1, indent+1)) + output = append(output, anyToArgon(key, true, true, depth, (indent+1)*plain, color, plain)+": "+anyToArgon(x[key], true, true, depth-1, indent+1, color, plain)) } - return "{\n" + (strings.Repeat(" ", indent+1)) + strings.Join(output, ",\n"+(strings.Repeat(" ", indent+1))) + "\n" + (strings.Repeat(" ", indent)) + "}" + return "{" + maybenewline + (strings.Repeat(" ", (indent+1)*plain)) + strings.Join(output, ","+maybenewline+(strings.Repeat(" ", (indent+1)*plain))) + maybenewline + (strings.Repeat(" ", indent*plain)) + "}" case builtinFunc: - return "" + if color { + output = append(output, "\x1b[38;5;240m") + } + output = append(output, "") + if color { + output = append(output, "\x1b[0m") + } case Callable: - return "" + if color { + output = append(output, "\x1b[38;5;240m") + } + output = append(output, "") + if color { + output = append(output, "\x1b[0m") + } case ArClass: - return anyToArgon(x.value, false, true, depth-1, indent+1) + return anyToArgon(x.value, quote, simplify, depth, indent, color, plain) default: return fmt.Sprint(x) } + return strings.Join(output, "") } diff --git a/src/translate.go b/src/translate.go index 125b824..41b6b7d 100644 --- a/src/translate.go +++ b/src/translate.go @@ -26,6 +26,11 @@ func translateVal(code UNPARSEcode, index int, codelines []UNPARSEcode, isLine b if worked { return bracket, worked, err, step } + } else if isSetVariable(code) { + setvar, worked, err, step := parseSetVariable(code, index, codelines) + if worked { + return setvar, worked, err, step + } } operation, worked, err, step := parseOperations(code, index, codelines) if worked { @@ -33,9 +38,7 @@ func translateVal(code UNPARSEcode, index int, codelines []UNPARSEcode, isLine b } else if err.EXISTS { return nil, worked, err, step } - if isSetVariable(code) { - return parseSetVariable(code, index, codelines) - } else if isNumber(code) { + if isNumber(code) { return parseNumber(code) } else if isNegative(code) { return parseNegative(code, index, codelines) diff --git a/src/variable.go b/src/variable.go index d28dba1..62d81f3 100644 --- a/src/variable.go +++ b/src/variable.go @@ -49,7 +49,7 @@ func parseVariable(code UNPARSEcode) (accessVariable, bool, ArErr, int) { if blockedVariableNames[name] { return accessVariable{}, false, ArErr{"Naming Error", "Naming Error: \"" + name + "\" is a reserved keyword", code.line, code.path, code.realcode, true}, 1 } - return accessVariable{name: name, code: code.code, line: code.line}, true, ArErr{}, 1 + return accessVariable{name: name, code: code.code, line: code.line, path: code.path}, true, ArErr{}, 1 } func readVariable(v accessVariable, stack stack) (any, ArErr) { diff --git a/test.ar b/test.ar index 9b8d6de..f3e6787 100644 --- a/test.ar +++ b/test.ar @@ -1 +1,4 @@ -term.log(sqrt(10)) \ No newline at end of file +x = 10 +term.log(x) +x = x+1 +term.log(x) \ No newline at end of file