Open-Argon/argon-v3
1
0
Fork 0
mirror of https://github.com/Open-Argon/argon-v3.git synced 2025-12-06 00:46:07 +00:00
Code Issues Packages Projects Releases Wiki Activity

fix parsing taking really long

Browse Source
This commit is contained in:
William Bell
2023-06-29 23:45:23 +01:00
parent af934e0429
commit 88129528f4
7 changed files with 563 additions and 621 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
src/array.go
View File

@@ -559,8 +559,7 @@ func ArArray(arr []any) ArObject {
for i, v := range arr {
res, err := runOperation(operationType{
operation: 8,
value1: v,
value2: args[0].(ArObject).obj["__value__"].([]any)[i],
values: []any{v, 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,
value2: args[0],
values: []any{v, 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,
value2: args[0],
values: []any{v, args[0]},
}, stack{}, 0)
if err.EXISTS {
return nil, err

11
src/built-ins.go
View File

@@ -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)
}

3
src/ifstatement.go
View File

@@ -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

3
src/map.go
View File

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

1006
src/operations.go
View File

File diff suppressed because it is too large Load Diff

151
src/translate.go
View File

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

1
tests/brainfuck.ar
View File

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