update how powers work

build

@@ -1 +1 @@
-go build -ldflags "-s -w" -o bin/argon ./src
+go build -trimpath -ldflags="-s -w" -o bin/argon ./src

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_
 			}

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() {

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

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:
+	case anymap:
-		for key, value := range x.obj {
+		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{}
 	}},
 })

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 {

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()
+			n := newNumber().Set(resp.(number))
-			n2, _ := resp.(number).Float64()
+			if n.Cmp(newNumber().SetInt64(10)) <= 0 {
-			output = newNumber().SetFloat64(math.Pow(n1, n2))
+				toOut := newNumber().SetInt64(1)
-			if output == nil {
+				clone := newNumber().Set(output)
-				output = infinity
+				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",

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{}
 }

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) {

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
 		}

tests/csv_test.ar

@@ -1,3 +1,5 @@
 import "csv" as csv
 
-term.log(csv.read("tests/test.csv"))
+let table = (csv.read("tests/test.csv"))
+
+term.log(number(table[::-1][0][::-1][0]))

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

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()

tests/stack test.ar

@@ -1,4 +1,4 @@
-x = 10
+let x = 10
 
 do
   let x = 20