fix parsing taking really long

src/array.go

@@ -559,8 +559,7 @@ func ArArray(arr []any) ArObject {
 			for i, v := range arr {
 				res, err := runOperation(operationType{
 					operation: 8,
-					value1:    v,
+					values:    []any{v, args[0].(ArObject).obj["__value__"].([]any)[i]},
-					value2:    args[0].(ArObject).obj["__value__"].([]any)[i],
 				}, stack{}, 0)
 				if err.EXISTS {
 					return nil, err
@@ -584,8 +583,7 @@ func ArArray(arr []any) ArObject {
 			for _, v := range arr {
 				res, err := runOperation(operationType{
 					operation: 9,
-					value1:    v,
+					values:    []any{v, args[0]},
-					value2:    args[0],
 				}, stack{}, 0)
 				if err.EXISTS {
 					return nil, err
@@ -610,8 +608,7 @@ func ArArray(arr []any) ArObject {
 			for _, v := range arr {
 				res, err := runOperation(operationType{
 					operation: 9,
-					value1:    v,
+					values:    []any{v, args[0]},
-					value2:    args[0],
 				}, stack{}, 0)
 				if err.EXISTS {
 					return nil, err

src/built-ins.go

@@ -342,5 +342,16 @@ func makeGlobal() ArObject {
 		}
 		return ArString(typeof(a[0])), ArErr{}
 	}}
+	vars["sha256"] = builtinFunc{"sha256", func(a ...any) (any, ArErr) {
+		if len(a) != 1 {
+			return nil, ArErr{TYPE: "sha256", message: "sha256 takes 1 argument, got " + fmt.Sprint(len(a)), EXISTS: true}
+		}
+		a[0] = ArValidToAny(a[0])
+		switch x := a[0].(type) {
+		case string:
+			return ArString(sha256Hash(x)), ArErr{}
+		}
+		return nil, ArErr{TYPE: "TypeError", message: "Cannot hash type '" + typeof(a[0]) + "'", EXISTS: true}
+	}}
 	return Map(vars)
 }

src/ifstatement.go

@@ -50,8 +50,7 @@ func parseIfStatement(code UNPARSEcode, index int, codeline []UNPARSEcode) (ifst
 				},
 				i,
 				codeline,
-				0,
+				0)
-			)
 			if err.EXISTS || !worked {
 				if j == 1 {
 					return ifstatement{}, worked, err, step

src/map.go

@@ -285,8 +285,7 @@ func Map(m anymap) ArObject {
 				}
 				val, err := runOperation(operationType{
 					operation: 9,
-					value1:    v,
+					values:    []any{v, a[k]},
-					value2:    a[k],
 				}, stack{}, 0)
 				if err.EXISTS {
 					return val, err

src/translate.go

@@ -11,7 +11,30 @@ type UNPARSEcode struct {
 	path     string
 }
 
+var knownFailures = []string{}
+var knownFailuresErrs = []ArErr{}
+
+func StringExists(arr []string, target string) (bool, ArErr) {
+	for i, str := range arr {
+		if str == target {
+			return true, knownFailuresErrs[i]
+		}
+	}
+	return false, ArErr{}
+}
+
 func translateVal(code UNPARSEcode, index int, codelines []UNPARSEcode, isLine int) (any, bool, ArErr, int) {
+	known, knownErr := StringExists(knownFailures, code.code)
+	if known {
+		return nil, false, ArErr{
+			knownErr.TYPE,
+			knownErr.message,
+			code.line,
+			code.path,
+			code.realcode,
+			true,
+		}, 1
+	}
 	var (
 		resp   any   = nil
 		worked bool  = false
@@ -20,36 +43,91 @@ func translateVal(code UNPARSEcode, index int, codelines []UNPARSEcode, isLine i
 	)
 	if isLine == 2 {
 		if isDeleteVariable(code) {
-			return parseDelete(code, index, codelines)
+			resp, worked, err, i = parseDelete(code, index, codelines)
+			if !worked {
+				knownFailures = append(knownFailures, code.code)
+				knownFailuresErrs = append(knownFailuresErrs, err)
+			}
+			return resp, worked, err, i
 		} else if isComment(code) {
 			resp, worked, err, i = parseComment(code, index, codelines)
 			if worked {
 				return resp, worked, err, i
 			}
 		} else if isReturn(code) {
-			return parseReturn(code, index, codelines)
+			resp, worked, err, i = parseReturn(code, index, codelines)
+			if !worked {
+				knownFailures = append(knownFailures, code.code)
+				knownFailuresErrs = append(knownFailuresErrs, err)
+			}
+			return resp, worked, err, i
 		} else if isBreak(code) {
-			return parseBreak(code)
+			resp, worked, err, i = parseBreak(code)
+			if !worked {
+				knownFailures = append(knownFailures, code.code)
+				knownFailuresErrs = append(knownFailuresErrs, err)
+			}
+			return resp, worked, err, i
 		} else if isContinue(code) {
-			return parseContinue(code)
+			resp, worked, err, i = parseContinue(code)
+			if !worked {
+				knownFailures = append(knownFailures, code.code)
+				knownFailuresErrs = append(knownFailuresErrs, err)
+			}
+			return resp, worked, err, i
 		} else if isIfStatement(code) {
-			return parseIfStatement(code, index, codelines)
+			resp, worked, err, i = parseIfStatement(code, index, codelines)
+			if !worked {
+				knownFailures = append(knownFailures, code.code)
+				knownFailuresErrs = append(knownFailuresErrs, err)
+			}
+			return resp, worked, err, i
 		} else if isWhileLoop(code) {
-			return parseWhileLoop(code, index, codelines)
+			resp, worked, err, i = parseWhileLoop(code, index, codelines)
+			if !worked {
+				knownFailures = append(knownFailures, code.code)
+				knownFailuresErrs = append(knownFailuresErrs, err)
+			}
+			return resp, worked, err, i
 		} else if isForeverLoop(code) {
-			return parseForeverLoop(code, index, codelines)
+			resp, worked, err, i = parseForeverLoop(code, index, codelines)
+			if !worked {
+				knownFailures = append(knownFailures, code.code)
+				knownFailuresErrs = append(knownFailuresErrs, err)
+			}
+			return resp, worked, err, i
 		} else if isForLoop(code) {
-			return parseForLoop(code, index, codelines)
+			resp, worked, err, i = parseForLoop(code, index, codelines)
+			if !worked {
+				knownFailures = append(knownFailures, code.code)
+				knownFailuresErrs = append(knownFailuresErrs, err)
+			}
+			return resp, worked, err, i
 		} else if isGenericImport(code) {
-			return parseGenericImport(code, index, codelines)
+			resp, worked, err, i = parseGenericImport(code, index, codelines)
+			if !worked {
+				knownFailures = append(knownFailures, code.code)
+				knownFailuresErrs = append(knownFailuresErrs, err)
+			}
+			return resp, worked, err, i
 		} else if isTryCatch(code) {
-			return parseTryCatch(code, index, codelines)
+			resp, worked, err, i = parseTryCatch(code, index, codelines)
+			if !worked {
+				knownFailures = append(knownFailures, code.code)
+				knownFailuresErrs = append(knownFailuresErrs, err)
+			}
+			return resp, worked, err, i
 		}
 	}
 
 	if isLine >= 1 {
 		if isDoWrap(code) {
-			return parseDoWrap(code, index, codelines)
+			resp, worked, err, i = parseDoWrap(code, index, codelines)
+			if !worked {
+				knownFailures = append(knownFailures, code.code)
+				knownFailuresErrs = append(knownFailuresErrs, err)
+			}
+			return resp, worked, err, i
 		}
 	}
 
@@ -84,9 +162,19 @@ func translateVal(code UNPARSEcode, index int, codelines []UNPARSEcode, isLine i
 		}
 	}
 	if isNumber(code) {
-		return parseNumber(code)
+		resp, worked, err, i = parseNumber(code)
+		if !worked {
+			knownFailures = append(knownFailures, code.code)
+			knownFailuresErrs = append(knownFailuresErrs, err)
+		}
+		return resp, worked, err, i
 	} else if isString(code) {
-		return parseString(code)
+		resp, worked, err, i = parseString(code)
+		if !worked {
+			knownFailures = append(knownFailures, code.code)
+			knownFailuresErrs = append(knownFailuresErrs, err)
+		}
+		return resp, worked, err, i
 	} else if issquareroot(code) {
 		resp, worked, err, i = parseSquareroot(code, index, codelines)
 		if worked {
@@ -100,7 +188,12 @@ func translateVal(code UNPARSEcode, index int, codelines []UNPARSEcode, isLine i
 		}
 	}
 	if isVariable(code) {
-		return parseVariable(code)
+		resp, worked, err, i = parseVariable(code)
+		if !worked {
+			knownFailures = append(knownFailures, code.code)
+			knownFailuresErrs = append(knownFailuresErrs, err)
+		}
+		return resp, worked, err, i
 	}
 	if isArray(code) {
 		resp, worked, err, i = parseArray(code, index, codelines)
@@ -110,6 +203,12 @@ func translateVal(code UNPARSEcode, index int, codelines []UNPARSEcode, isLine i
 	} else if isMap(code) {
 		resp, worked, err, i = parseMap(code, index, codelines)
 	}
+	if isnot(code) {
+		resp, worked, err, i = parseNot(code, index, codelines, isLine)
+		if worked {
+			return resp, worked, err, i
+		}
+	}
 	{
 		operation, worked, err, step := parseOperations(code, index, codelines)
 		if worked {
@@ -118,12 +217,6 @@ func translateVal(code UNPARSEcode, index int, codelines []UNPARSEcode, isLine i
 			return nil, worked, err, step
 		}
 	}
-	if isnot(code) {
-		resp, worked, err, i = parseNot(code, index, codelines, isLine)
-		if worked {
-			return resp, worked, err, i
-		}
-	}
 	if isCall(code) {
 		resp, worked, err, i = parseCall(code, index, codelines)
 		if worked {
@@ -131,15 +224,29 @@ func translateVal(code UNPARSEcode, index int, codelines []UNPARSEcode, isLine i
 		}
 	}
 	if isNegative(code) {
-		return parseNegative(code, index, codelines)
+		resp, worked, err, i = parseNegative(code, index, codelines)
+		if !worked {
+			knownFailures = append(knownFailures, code.code)
+			knownFailuresErrs = append(knownFailuresErrs, err)
+		}
+		return resp, worked, err, i
 	} else if isMapGet(code) {
-		return mapGetParse(code, index, codelines)
+		resp, worked, err, i = mapGetParse(code, index, codelines)
+		if !worked {
+			knownFailures = append(knownFailures, code.code)
+			knownFailuresErrs = append(knownFailuresErrs, err)
+		}
+		return resp, worked, err, i
 	} else if isIndexGet(code) {
 		resp, worked, err, i = indexGetParse(code, index, codelines)
 		if worked {
 			return resp, worked, err, i
 		}
 	}
+	if !worked {
+		knownFailures = append(knownFailures, code.code)
+		knownFailuresErrs = append(knownFailuresErrs, err)
+	}
 	return resp, worked, err, i
 }
 

tests/brainfuck.ar

@@ -30,5 +30,4 @@ let interpret(code) = do
             else loops.pop()
         code_ptr = code_ptr + 1
 
-term.log("hello worldf")
 interpret('>+++++++++[<++++++++>-]<.>+++++++[<++++>-]<+.+++++++..+++.>>>++++++++[<++++>-]<.>>>++++++++++[<+++++++++>-]<---.<<<<.+++.------.--------.>>+.>++++++++++.')