From 63d7616053c0de6870e34ee8f501852dc33f69d4 Mon Sep 17 00:00:00 2001 From: William Bell Date: Sat, 17 Jun 2023 00:57:17 +0100 Subject: [PATCH] update how powers work --- .DS_Store | Bin 6148 -> 6148 bytes build | 2 +- src/call.go | 2 +- src/debug.go | 2 +- src/getIndex.go | 15 ++++++------ src/json.go | 7 +++--- src/main.go | 1 + src/operations.go | 53 ++++++++++++++++++++++++++++++++++------ src/parseImport.go | 15 ++++++++++-- src/translate.go | 12 ++++----- src/trycatch.go | 4 +-- tests/csv_test.ar | 4 ++- tests/diff.ar | 19 ++++++++++++++ tests/memoryLeakTest.ar | 2 +- tests/stack test.ar | 2 +- 15 files changed, 107 insertions(+), 33 deletions(-) create mode 100644 tests/diff.ar diff --git a/.DS_Store b/.DS_Store index 89b42961bec610a21a7ff127773e0a2cb3c7f15c..e26f8c018153f25be2f0b6813fe8fd56e72dad52 100644 GIT binary patch delta 586 zcmZ9KKX21O7{=e%4mc?VUs@*tAqMb*R0(BZVW=9y02M+BO;tJKPh>k6_f+T3y>nCA zB})fJqRvcANNgGV1z7k9h>rjpuyL_n6}aKv=brbu-<@=K(mZLts~e@I*?xU??>3fZ z-LntGFtK#HjK8KPD3B1caFPVE2mtU)ki<--&E_{k&@fAvE?ecw(v{__*KAT=TSdif?vH83owmBUQ-Lz9!9#ckJFo}GFoXB-5zgQqPtl@PsV~X_nc4WACB*mV*mgE delta 80 zcmZoMXfc=|#>B`mu~2NHo+2aD#DLwC4MbQb^Rs;2{FjZ3akBykJIlm|Pn+2}_&I>; dHVblmXP(S2Vky7?1dI#}Oi-F-bA-qmW&mYq5>NmD diff --git a/build b/build index a16ee8e..721870d 100755 --- a/build +++ b/build @@ -1 +1 @@ -go build -ldflags "-s -w" -o bin/argon ./src \ No newline at end of file +go build -trimpath -ldflags="-s -w" -o bin/argon ./src \ No newline at end of file diff --git a/src/call.go b/src/call.go index 4554de8..85a3726 100644 --- a/src/call.go +++ b/src/call.go @@ -84,7 +84,7 @@ func runCall(c call, stack stack, stacklevel int) (any, ArErr) { c.line, c.code, c.path, - }, stack, stacklevel) + }, stack, stacklevel+1) if !err.EXISTS { callable = callable_ } diff --git a/src/debug.go b/src/debug.go index f6d2566..3d3743a 100644 --- a/src/debug.go +++ b/src/debug.go @@ -7,7 +7,7 @@ import ( var debug = os.Getenv("__ARGON_DEBUG__") == "true" -func debugPrintln(a ...interface{}) { +func debugPrintln(a ...any) { if debug { go func() { defer func() { diff --git a/src/getIndex.go b/src/getIndex.go index 9d56d05..f1d4dc4 100644 --- a/src/getIndex.go +++ b/src/getIndex.go @@ -26,6 +26,14 @@ func mapGet(r ArMapGet, stack stack, stacklevel int) (any, ArErr) { if err.EXISTS { return nil, err } + + switch m := resp.(type) { + case ArObject: + if obj, ok := m.obj[r.args[0]]; ok { + return obj, ArErr{} + } + } + switch m := resp.(type) { case ArObject: if callable, ok := m.obj["__getindex__"]; ok { @@ -47,13 +55,6 @@ func mapGet(r ArMapGet, stack stack, stacklevel int) (any, ArErr) { } } - switch m := resp.(type) { - case ArObject: - if obj, ok := m.obj[r.args[0]]; ok { - return obj, ArErr{} - } - } - key, err := runVal(r.args[0], stack, stacklevel+1) if err.EXISTS { return nil, err diff --git a/src/json.go b/src/json.go index 0336f75..312a19b 100644 --- a/src/json.go +++ b/src/json.go @@ -46,8 +46,8 @@ func jsonstringify(obj any, level int) (string, error) { output := []string{} obj = ArValidToAny(obj) switch x := obj.(type) { - case ArObject: - for key, value := range x.obj { + case anymap: + for key, value := range x { str, err := jsonstringify(value, level+1) if err != nil { return "", err @@ -89,6 +89,7 @@ var ArJSON = Map(anymap{ if typeof(args[0]) != "string" { return nil, ArErr{TYPE: "Runtime Error", message: "parse takes a string not a '" + typeof(args[0]) + "'", EXISTS: true} } + args[0] = ArValidToAny(args[0]) return jsonparse(args[0].(string)), ArErr{} }}, "stringify": builtinFunc{"stringify", func(args ...any) (any, ArErr) { @@ -99,6 +100,6 @@ var ArJSON = Map(anymap{ if err != nil { return nil, ArErr{TYPE: "Runtime Error", message: err.Error(), EXISTS: true} } - return str, ArErr{} + return ArString(str), ArErr{} }}, }) diff --git a/src/main.go b/src/main.go index 6f6ff0c..a200b27 100644 --- a/src/main.go +++ b/src/main.go @@ -16,6 +16,7 @@ func newscope() ArObject { func main() { debugPrintln("In debug mode...") + if !debug { defer func() { if r := recover(); r != nil { diff --git a/src/operations.go b/src/operations.go index 2b614ae..dac4c96 100644 --- a/src/operations.go +++ b/src/operations.go @@ -46,6 +46,8 @@ var operations = [][]string{ "**", }} +var one = newNumber().SetInt64(1) + type operationType struct { operation int values []any @@ -242,9 +244,9 @@ func compareValues(o operationType, stack stack, stacklevel int) (bool, ArErr) { true, } case 8: - return notequals(resp, resp2, o, stack, stacklevel) + return notequals(resp, resp2, o, stack, stacklevel+1) case 9: - return equals(resp, resp2, o, stack, stacklevel) + return equals(resp, resp2, o, stack, stacklevel+1) default: return false, ArErr{ "Runtime Error", @@ -818,12 +820,49 @@ func calcPower(o operationType, stack stack, stacklevel int) (number, ArErr) { return nil, err } if typeof(resp) == "number" { - n1, _ := output.Float64() - n2, _ := resp.(number).Float64() - output = newNumber().SetFloat64(math.Pow(n1, n2)) - if output == nil { - output = infinity + n := newNumber().Set(resp.(number)) + if n.Cmp(newNumber().SetInt64(10)) <= 0 { + toOut := newNumber().SetInt64(1) + clone := newNumber().Set(output) + nAbs := (abs(newNumber().Set(n))) + j := newNumber() + for ; j.Cmp(nAbs) < 0; j.Add(j, one) { + toOut.Mul(toOut, clone) + } + + nAbs.Sub(nAbs, j) + if nAbs.Cmp(newNumber()) < 0 { + j.Sub(j, one) + n1, _ := toOut.Float64() + n2, _ := nAbs.Float64() + calculated := newNumber().SetFloat64(math.Pow(n1, n2)) + if calculated == nil { + calculated = infinity + } + toOut.Mul(toOut, calculated) + } + if n.Cmp(newNumber()) < 0 { + toOut.Quo(newNumber().SetInt64(1), toOut) + } + output.Set(toOut) + } else if n.Cmp(newNumber().SetInt64(1)) != 0 { + n1, _ := output.Float64() + n2, _ := n.Float64() + calculated := newNumber().SetFloat64(math.Pow(n1, n2)) + if calculated == nil { + calculated = infinity + } + output.Mul(output, calculated) } + + /* + n1, _ := output.Float64() + n2, _ := resp.(number).Float64() + output = newNumber().SetFloat64(math.Pow(n1, n2)) + if output == nil { + output = infinity + } + */ } else { return nil, ArErr{ "Runtime Error", diff --git a/src/parseImport.go b/src/parseImport.go index 8c90a51..f59db60 100644 --- a/src/parseImport.go +++ b/src/parseImport.go @@ -70,6 +70,17 @@ func runImport(importOBJ ArImport, stack stack, stacklevel int) (any, ArErr) { } return nil, err } + setindex, ok := stack[len(stack)-1].obj["__setindex__"] + if !ok { + return nil, ArErr{ + "Import Error", + "could not find __setindex__ in module scope", + importOBJ.line, + importOBJ.path, + importOBJ.code, + true, + } + } switch x := importOBJ.values.(type) { case []string: for _, v := range x { @@ -77,10 +88,10 @@ func runImport(importOBJ ArImport, stack stack, stacklevel int) (any, ArErr) { if !ok { return nil, ArErr{"Import Error", "could not find value " + anyToArgon(v, true, false, 3, 0, false, 0) + " in module " + anyToArgon(path, true, false, 3, 0, false, 0), importOBJ.line, importOBJ.path, importOBJ.code, true} } - stack[len(stack)-1].obj[v] = val + builtinCall(setindex, []any{v, val}) } case string: - stack[len(stack)-1].obj[x] = stackMap + builtinCall(setindex, []any{x, stackMap}) } return nil, ArErr{} } diff --git a/src/translate.go b/src/translate.go index 81d3543..ecc9dcf 100644 --- a/src/translate.go +++ b/src/translate.go @@ -104,12 +104,6 @@ func translateVal(code UNPARSEcode, index int, codelines []UNPARSEcode, isLine i return resp, worked, err, i } } - if isCall(code) { - resp, worked, err, i = parseCall(code, index, codelines) - if worked { - return resp, worked, err, i - } - } { operation, worked, err, step := parseOperations(code, index, codelines) if worked { @@ -118,6 +112,12 @@ func translateVal(code UNPARSEcode, index int, codelines []UNPARSEcode, isLine i return nil, worked, err, step } } + if isCall(code) { + resp, worked, err, i = parseCall(code, index, codelines) + if worked { + return resp, worked, err, i + } + } if isNegative(code) { return parseNegative(code, index, codelines) } else if isMapGet(code) { diff --git a/src/trycatch.go b/src/trycatch.go index 1fd0c52..bbafe45 100644 --- a/src/trycatch.go +++ b/src/trycatch.go @@ -57,7 +57,7 @@ func parseTryCatch(code UNPARSEcode, index int, codelines []UNPARSEcode) (TryCat } func runTryCatch(t TryCatch, stack stack, stacklevel int) (any, ArErr) { - val, err := runVal(t.Try, stack, stacklevel) + val, err := runVal(t.Try, stack, stacklevel+1) if err.EXISTS { vars := anymap{} vars[t.errorName] = Map(anymap{ @@ -67,7 +67,7 @@ func runTryCatch(t TryCatch, stack stack, stacklevel int) (any, ArErr) { "path": err.path, "code": err.code, }) - val, err = runVal(t.Catch, append(stack, Map(vars)), stacklevel) + val, err = runVal(t.Catch, append(stack, Map(vars)), stacklevel+1) if err.EXISTS { return nil, err } diff --git a/tests/csv_test.ar b/tests/csv_test.ar index ba68519..5da29fe 100644 --- a/tests/csv_test.ar +++ b/tests/csv_test.ar @@ -1,3 +1,5 @@ import "csv" as csv -term.log(csv.read("tests/test.csv")) \ No newline at end of file +let table = (csv.read("tests/test.csv")) + +term.log(number(table[::-1][0][::-1][0])) \ No newline at end of file diff --git a/tests/diff.ar b/tests/diff.ar new file mode 100644 index 0000000..fe0c42e --- /dev/null +++ b/tests/diff.ar @@ -0,0 +1,19 @@ +let zero = 1/infinity +let diff(f) = (x) = (f(x + zero) - f(x)) / zero + +let count = 0 + +let f(x) = do + count = count + 1 + term.log(count) + return x^10+x^9+x^8+x^7+x^6+x^5+x^4+x^3+x^2+x+1 +x = 100 +d = 0 + +forever do + n = f(x) + term.log("f"+("'"*d)+"("+x+") = "+n) + if (n == 0) break + f = diff(f) + d = d + 1 + count = 0 \ No newline at end of file diff --git a/tests/memoryLeakTest.ar b/tests/memoryLeakTest.ar index 6fc19ec..74660ee 100644 --- a/tests/memoryLeakTest.ar +++ b/tests/memoryLeakTest.ar @@ -1,6 +1,6 @@ f() = do a = [] - for (i from 0 to 10000) a.append(i) + for (i from 0 to 100000) a.append(i) term.log("start") f() diff --git a/tests/stack test.ar b/tests/stack test.ar index a22007d..4bcaceb 100644 --- a/tests/stack test.ar +++ b/tests/stack test.ar @@ -1,4 +1,4 @@ -x = 10 +let x = 10 do let x = 20