hotfix for 11.0.0. Bump version to 2.0.5

Makefile

@@ -11,7 +11,7 @@ include $(DEVKITARM)/base_rules
 IPL_LOAD_ADDR := 0x40003000
 LPVERSION_MAJOR := 3
 LPVERSION_MINOR := 0
-LPVERSION_BUGFX := 4
+LPVERSION_BUGFX := 5
 
 ################################################################################
 

source/gfx/gfx.c

@@ -540,11 +540,6 @@ void gfx_boxGrey(int x0, int y0, int x1, int y1, u8 shade){
 		memset(gfx_ctxt.fb + y * gfx_ctxt.stride + y0, shade, (y1 - y0 + 1) * 4);
 	}
 }
-
-void gfx_setPixel(int x, int y, u32 color) {
-	*(gfx_ctxt.fb + (YLEFT - x) * gfx_ctxt.stride + y) = color;
-}
-
 /*
 void gfx_boxGrey_old(int x0, int y0, int x1, int y1, u8 shade){
 	for (int y = y0; y <= y1; y++){

source/gfx/gfx.h

@@ -53,7 +53,6 @@ void gfx_set_rect_argb(const u32 *buf, u32 size_x, u32 size_y, u32 pos_x, u32 po
 void gfx_render_bmp_argb(const u32 *buf, u32 size_x, u32 size_y, u32 pos_x, u32 pos_y);
 void gfx_box(int x0, int y0, int x1, int y1, u32 color);
 void gfx_boxGrey(int x0, int y0, int x1, int y1, u8 shade);
-void gfx_setPixel(int x, int y, u32 color);
 
 /*
 #define GFX_SETPOSCORRECTED(x, y) gfx_con_setpos(y - YLEFT, x)

source/hos/pkg1.c

@@ -43,6 +43,7 @@ static const pkg1_id_t _pkg1_ids[] = {
 	{ "20190809135709", 9, {0x2ec10,   0x5573, 0,  1, 12, HASH_ORDER_700_10x, 0x6495, 0x1d807} }, //9.0.0 - 9.0.1
 	{ "20191021113848", 10,{0x2ec10,   0x5573, 0,  1, 12, HASH_ORDER_700_10x, 0x6495, 0x1d807} }, //9.1.0
 	{ "20200303104606", 10,{0x30ea0,   0x5e4b, 0,  1, 12, HASH_ORDER_700_10x, 0x663c, 0x1d9a4} }, //10.0.0
+	{ "20201030110885", 10,{0x30ea0,   0x5e4b, 0,  1, 12, HASH_ORDER_700_10x, 0x663c, 0x1d9a4} }, //11.0.0
 	{ NULL } //End.
 };
 

source/tegraexplorer/common/types.h

@@ -58,6 +58,4 @@ typedef struct {
 } gpt_entry_rule;
 
 #define isFS 0x80
-#define isBOOT 0x2
+#define isBOOT 0x2
-
-typedef void (*func_void_ptr)();

source/tegraexplorer/fs/filemenu.c

@@ -204,7 +204,7 @@ int filemenu(menu_entry file){
             while (hidRead()->buttons);
             */
 
-            startScript(fsutil_getnextloc(currentpath, file.name));
+            runScript(fsutil_getnextloc(currentpath, file.name));
             fsreader_readfolder(currentpath);
             break;
         case FILE_HEXVIEW:

source/tegraexplorer/gfx/gfxutils.c

@@ -23,7 +23,7 @@ void gfx_clearscreen(){
     gfx_boxGrey(0, 703, 1279, 719, 0xFF);
     gfx_boxGrey(0, 0, 1279, 15, 0xFF);
     gfx_con_setpos(0, 0);
-    gfx_printf("Tegraexplorer v2.0.4 | Battery: %3d%%\n", battery >> 8);
+    gfx_printf("Tegraexplorer v2.0.5 | Battery: %3d%%\n", battery >> 8);
 
     RESETCOLOR;
 }

source/tegraexplorer/script/args.c

@@ -1,281 +0,0 @@
-#include "args.h"
-#include "parser.h"
-#include "scriptCtx.h"
-#include "lexer.h"
-#include "functions.h"
-#include "list.h"
-#include <string.h>
-#include "../../mem/heap.h"
-#include "../utils/utils.h"
-
-// do not include first openToken!
-int distanceBetweenTokens(lexarToken_t* tokens, u32 len, int openToken, int closeToken) {
-    int i = 0;
-    int layer = 0;
-    for (; i < len; i++) {
-        if (tokens[i].token == openToken)
-            layer++;
-        else if (tokens[i].token == closeToken) {
-            if (layer == 0)
-                return i;
-            layer--;
-        }
-    }
-
-    return -1;
-}
-
-dictValue_t getVarFromToken(scriptCtx_t* ctx, lexarToken_t* tokens, int* index, u32 maxLen) {
-    dictValue_t val = { 0 };
-    val.free = 0;
-    int i = *index;
-    u8 not = 0;
-    
-    if (tokens[i].token == Not) {
-        not = 1;
-        i++;
-    }
-
-    if (tokens[i].token == Not)
-        return ErrDictValue(ERRDOUBLENOT);
-
-    if (tokens[i].token == Variable) {
-        char* funcName = tokens[i].text;
-
-        if (tokens[i + 1].token == LBracket) {
-            i += 2;
-
-            int argCount = distanceBetweenTokens(&tokens[i], maxLen - 2, LBracket, RBracket);
-            if (argCount < 0)
-                return ErrDictValue(ERRSYNTAX);
-
-            ctx->args_loc.tokens = &tokens[i];
-            ctx->args_loc.stored = argCount;
-            val = executeFunction(ctx, funcName);
-            
-            i += argCount;
-        }
-        else if (tokens[i + 1].token == LSBracket) {
-            dictValue_t* var = varVectorFind(&ctx->vars, tokens[i].text);
-            i += 2;
-
-            if (var == NULL)
-                return ErrDictValue(ERRNOVAR);
-
-            int argCount = distanceBetweenTokens(&tokens[i], maxLen - 2, LSBracket, RSBracket);
-            if (argCount < 0)
-                return ErrDictValue(ERRSYNTAX);
-
-            dictValue_t index = solveEquation(ctx, &tokens[i], argCount);
-            i += argCount;
-
-            if (index.varType != IntType)
-                return ErrDictValue(ERRINVALIDTYPE);
-
-            if (var->arrayLen <= index.integer || index.integer < 0)
-                return ErrDictValue(ERRSYNTAX);
-
-            switch (var->varType) {
-                case StringArrayType:
-                    val = StrDictValue(var->stringArray[index.integer]);
-                    break;
-                case IntArrayType:
-                    val = IntDictValue(var->integerArray[index.integer]);
-                    break;
-                case ByteArrayType:
-                    val = IntDictValue(var->byteArray[index.integer]);
-                    break;
-                default:
-                    return ErrDictValue(ERRINVALIDTYPE);
-            } 
-        }
-        else {
-            dictValue_t* var = varVectorFind(&ctx->vars, tokens[i].text);
-
-            if (var != NULL) {
-                if (var->type == IntType) {
-                    val = IntDictValue(var->integer);
-                }
-                else if (var->type == StringType){
-                    val = StrDictValue(util_cpyStr(var->string));
-                    val.free = 1;
-                }
-                else {
-                    val = *var;
-                    val.free = 0;
-                }
-            }
-            else
-                return ErrDictValue(ERRNOVAR);
-        }
-    }
-    else if (tokens[i].token == LSBracket) {
-        i++;
-
-        int argCount = distanceBetweenTokens(&tokens[i], maxLen - 1, LSBracket, RSBracket);
-        if (argCount <= 0)
-            return ErrDictValue(-5);
-
-        varVector_t arrayVars = extractVars(ctx, &tokens[i], argCount);
-        int type = arrayVars.vars[0].value.varType;
-        if (!(type == StringType || type == IntType))
-            return ErrDictValue(ERRINVALIDTYPE);
-
-        val.type = (type + 2) | FREEINDICT;
-        val.arrayLen = arrayVars.stored;
-        val.integerArray = calloc(val.arrayLen, (type == IntType) ? sizeof(int) : sizeof(char*));
-        val.free = (type == StringType) ? 1 : 0;
-
-        for (int i = 0; i < arrayVars.stored; i++) {
-            if (arrayVars.vars[i].value.varType != type)
-                return ErrDictValue(ERRINVALIDTYPE); // Free-ing issue!!
-
-            if (type == StringType) {
-                val.stringArray[i] = util_cpyStr(arrayVars.vars[i].value.string);
-            }
-            else {
-                val.integerArray[i] = arrayVars.vars[i].value.integer;
-            }
-        }
-
-        i += argCount;
-        varVectorFree(&arrayVars);
-    }
-    else if (tokens[i].token == LBracket) {
-        i += 1;
-        int argCount = distanceBetweenTokens(&tokens[i], maxLen - 1, LBracket, RBracket);
-        if (argCount < 0)
-            return ErrDictValue(ERRSYNTAX);
-
-        val = solveEquation(ctx, &tokens[i], argCount);
-        i += argCount;
-    }
-    else if (tokens[i].token == IntLit) {
-        val = IntDictValue(tokens[i].val);
-    }
-    else if (tokens[i].token == StrLit) {
-        val = StrDictValue(tokens[i].text); // Do we need to copy the string here? if we set var.free = 0, it shouldn't matter
-        val.free = 0;
-    }
-    else {
-        // ERR
-        return ErrDictValue(ERRNOVAR);
-    }
-
-    if (not) {
-        if (val.type == IntType)
-            val.integer = !val.integer;
-        else
-            return ErrDictValue(ERRINVALIDTYPE);
-    }
-
-    *index = i;
-    return val;
-}
-
-int matchTypes(dictValue_t d1, dictValue_t d2, int type) {
-    return (d1.varType == d2.varType && d1.varType == type);
-}
-
-#define ELIFT(token) else if (localOpToken == token)
-
-dictValue_t solveEquation(scriptCtx_t *ctx, lexarToken_t* tokens, u32 len) {
-    dictValue_t res = { 0 };
-    u16 lastToken = 0;
-        
-    for (int i = 0; i < len; i++) {
-        if (tokens[i].token == Variable || tokens[i].token == StrLit || tokens[i].token == IntLit || tokens[i].token == Not || tokens[i].token == LBracket || tokens[i].token == LSBracket){
-            dictValue_t val = getVarFromToken(ctx, tokens, &i, len - i);
-
-            if (val.type == ErrType)
-                return val;
-
-            if (lastToken) {
-                u16 localOpToken = lastToken; // do we need local op token?
-                lastToken = 0;
-
-                if (matchTypes(res, val, IntType)) {
-                    if (localOpToken == Plus)
-                        res.integer += val.integer;
-                    ELIFT(Minus)
-                        res.integer -= val.integer;
-                    ELIFT(Multiply)
-                        res.integer *= val.integer;
-                    ELIFT(Division)
-                        res.integer /= val.integer;
-                    ELIFT(Mod)
-                        res.integer %= val.integer;
-                    ELIFT(Smaller)
-                        res.integer = res.integer < val.integer;
-                    ELIFT(SmallerEqual)
-                        res.integer = res.integer <= val.integer;
-                    ELIFT(Bigger)
-                        res.integer = res.integer > val.integer;
-                    ELIFT(BiggerEqual)
-                        res.integer = res.integer >= val.integer;
-                    ELIFT(EqualEqual)
-                        res.integer = res.integer == val.integer;
-                    ELIFT(NotEqual)
-                        res.integer = res.integer != val.integer;
-                    ELIFT(LogicAND) {
-                        res.integer = res.integer && val.integer;
-                        if (!res.integer)
-                            break;
-                    }
-                    ELIFT(LogicOR) {
-                        res.integer = res.integer || val.integer;
-                        if (res.integer)
-                            break;
-                    }
-                    ELIFT(AND)
-                        res.integer = res.integer & val.integer;
-                    ELIFT(OR)
-                        res.integer = res.integer | val.integer;
-                    else
-                        return ErrDictValue(ERRBADOPERATOR);
-                }
-                else if (matchTypes(res, val, StringType)) {
-                    if (localOpToken == Plus) {
-                        char* buff = calloc(strlen(res.string) + strlen(val.string) + 1, 1);
-                        strcpy(buff, res.string);
-                        strcat(buff, val.string);
-                        if (res.free)
-                            free(res.string);
-                        if (val.free)
-                            free(val.string);
-                        res.string = buff;
-                    }
-                    ELIFT(EqualEqual) {
-                        res.type = IntType;
-                        int compRes = !strcmp(res.string, val.string);
-                        if (res.free)
-                            free(res.string);
-                        if (val.free)
-                            free(val.string);
-                        res.integer = compRes;
-                        res.free = 0;
-                    }
-                    ELIFT(Minus) {
-                        if (!strcmp(res.string + strlen(res.string) - strlen(val.string), val.string)) {
-                            *(res.string + strlen(res.string) - strlen(val.string)) = 0;
-                        }
-
-                        free(val.string);
-                    }
-                    else 
-                        return ErrDictValue(ERRBADOPERATOR);
-                }
-                else
-                    return ErrDictValue(ERRBADOPERATOR);
-            }
-            else {
-                res = val;
-            }
-        }
-        else if (tokens[i].token >= Plus && tokens[i].token <= OR) {
-            lastToken = tokens[i].token;
-        }
-    }
-
-    return res;
-}

source/tegraexplorer/script/args.h

@@ -1,6 +0,0 @@
-#pragma once
-#include "types.h"
-
-char* createStrOutTextHolder(textHolder_t t);
-dictValue_t solveEquation(scriptCtx_t* ctx, lexarToken_t* tokens, u32 len);
-int distanceBetweenTokens(lexarToken_t* tokens, u32 len, int openToken, int closeToken);

source/tegraexplorer/script/functions.c

@@ -1,177 +1,664 @@
-#include "functions.h"
-#include "list.h"
-#include "args.h"
-#include "parser.h"
-#include "lexer.h"
-#include "types.h"
-#include "scriptCtx.h"
-#include "../../gfx/gfx.h"
-#include "../../mem/heap.h"
 #include <string.h>
+#include <stdlib.h>
+#include "../../mem/heap.h"
+#include "../gfx/gfxutils.h"
+#include "../emmc/emmc.h"
+#include "../../utils/types.h"
+#include "../../libs/fatfs/ff.h"
+#include "../../utils/sprintf.h"
 #include "../../hid/hid.h"
+#include "../../gfx/gfx.h"
+#include "../../utils/util.h"
+#include "../../storage/emummc.h"
+#include "parser.h"
+#include "../common/common.h"
+#include "../fs/fsactions.h"
+#include "variables.h"
+#include "../utils/utils.h"
+#include "functions.h"
+#include "../fs/fsutils.h"
+#include "../../utils/sprintf.h"
+#include "../fs/fsactions.h"
+#include "../emmc/emmcoperations.h"
+#include "../emmc/emmcmenu.h"
 
-dictValue_t funcPrint(scriptCtx_t* ctx, varVector_t* args) {
+extern FIL scriptin;
-	for (int i = 0; i < args->stored; i++) {
+extern char **argv;
-		switch (args->vars[i].value.varType) {
+extern u32 argc;
-		case IntType:
+extern int forceExit;
-			gfx_printf("%d", args->vars[i].value.integer);
+extern short currentlyMounted;
-			break;
-		case StringType:
-			gfx_printf("%s", args->vars[i].value.string);
-			break;
-		}
-	}
 
-	return NullDictValue();
+int parseIntInput(char *in, int *out){
+    if (in[0] == '@'){
+        if (str_int_find(in, out))
+            return -1;
+    }
+    else
+        *out = atoi(in);
+    
+    return 0;
+}
+/*
+int parseJmpInput(char *in, u64 *out){
+    if (in[0] == '?'){
+        if (str_jmp_find(in, out))
+            return -1;
+        else
+            return 0;
+    }
+    else
+        return -1;
+}
+*/
+
+int parseStringInput(char *in, char **out){
+    if (in[0] == '$'){
+        if (str_str_find(in, out))
+            return -1;
+        else
+            return 0;
+    }
+    else{
+        *out = in; 
+        return 0;
+    }
 }
 
-dictValue_t funcPrintln(scriptCtx_t* ctx, varVector_t* args) {
+#pragma GCC push_options
-	funcPrint(ctx, args);
+#pragma GCC optimize ("Os")
-	gfx_printf("\n");
+
-	return NullDictValue();
+u32 currentcolor = COLOR_WHITE;
+int part_printf(){
+    SWAPCOLOR(currentcolor);
+    for (int i = 0; i < argc; i++){
+        if (argv[i][0] == '@'){
+            int toprintint;
+            if (parseIntInput(argv[i], &toprintint))
+                return INFUNC_FAIL;
+
+            gfx_printf("%d", toprintint);
+        }
+        else {
+            char *toprintstring;
+            if (parseStringInput(argv[i], &toprintstring))
+                return INFUNC_FAIL;
+
+            gfx_printf(toprintstring);
+        }
+    }
+
+    gfx_printf("\n");
+    return 0;
 }
 
-dictValue_t funcIf(scriptCtx_t* ctx, varVector_t* args) {
+int part_print_int(){
-	if (args->vars[0].value.varType == IntType) {
+    int toprint;
-		setCurIndentInstruction(ctx, (args->vars[0].value.integer == 0), -1);
+    if (parseIntInput(argv[0], &toprint))
-		return NullDictValue();
+        return INFUNC_FAIL;
-	}
+    
-
+    SWAPCOLOR(currentcolor);
-	return ErrDictValue(ERRINVALIDTYPE);
+    gfx_printf("%s: %d\n", argv[0], toprint);
+    return 0;
 }
 
-dictValue_t scriptElse(scriptCtx_t* ctx, varVector_t* args) {
+int part_Wait(){
-	indentInstructor_t curInstruction = getCurIndentInstruction(ctx);
+    int arg;
-	setCurIndentInstruction(ctx, !curInstruction.skip, -1);
+    u32 begintime;
-	return NullDictValue();
+    SWAPCOLOR(currentcolor);
+
+    if (parseIntInput(argv[0], &arg))
+        return INFUNC_FAIL;
+
+    begintime = get_tmr_s();
+
+    while (begintime + arg > get_tmr_s()){
+        gfx_printf("\r<Wait %d seconds> ", (begintime + arg) - get_tmr_s());
+    }
+
+    gfx_printf("\r                 \r");
+    return 0;
 }
 
-dictValue_t scriptWhile(scriptCtx_t* ctx, varVector_t* args) {
+int part_Check(){
-	if (args->vars[0].value.varType == IntType) {
+    int left, right;
-		setCurIndentInstruction(ctx, (args->vars[0].value.integer == 0), ctx->lastTokenPos);
+    if (parseIntInput(argv[0], &left))
-		return NullDictValue();
+        return INFUNC_FAIL;
-	}
+    if (parseIntInput(argv[2], &right))
+        return INFUNC_FAIL;
 
-	return ErrDictValue(ERRINVALIDTYPE);
+    if (!strcmp(argv[1], "=="))
+        return (left == right);
+    else if (!strcmp(argv[1], "!="))
+        return (left != right);
+    else if (!strcmp(argv[1], ">="))
+        return (left >= right);
+    else if (!strcmp(argv[1], "<="))
+        return (left <= right);
+    else if (!strcmp(argv[1], ">"))
+        return (left > right);
+    else if (!strcmp(argv[1], "<"))
+        return (left < right);
+    else
+        return INFUNC_FAIL;
 }
 
-dictValue_t scriptLen(scriptCtx_t* ctx, varVector_t* args) {
+int part_if(){
-	if (args->vars[0].value.varType >= IntArrayType && args->vars[0].value.varType <= ByteArrayType)
+    int condition;
-		return IntDictValue(args->vars[0].value.arrayLen);
+    if (parseIntInput(argv[0], &condition))
-	else if (args->vars[0].value.varType == StringType) {
+        return INFUNC_FAIL;
-		if (args->vars[0].value.string != NULL)
-			return IntDictValue(strlen(args->vars[0].value.string));
-	}
 
-	return ErrDictValue(ERRINVALIDTYPE);
+    getfollowingchar('{');
+
+    if (!condition)
+        skipbrackets();
+    
+    return 0;
+
+    /*
+    if (condition)
+        return 0;
+    else {
+        skipbrackets();
+        return 0;
+    }
+    */
 }
 
-dictValue_t scriptMakeByteArray(scriptCtx_t* ctx, varVector_t* args) {
+int part_if_args(){
-	if (args->vars[0].value.varType == IntArrayType) {
+    int condition;
-		u8* buff = calloc(args->vars[0].value.arrayLen, 1);
+    if ((condition = part_Check()) < 0)
-		for (int i = 0; i < args->vars[0].value.arrayLen; i++) {
+        return INFUNC_FAIL;
-			buff[i] = (u8)(args->vars[0].value.integerArray[i] & 0xFF);
-		}
 
-		return DictValueCreate(ByteArrayType | FREEINDICT, args->vars[0].value.arrayLen, buff);
+    getfollowingchar('{');
-	}
 
-	return ErrDictValue(ERRINVALIDTYPE);
+    if (!condition)
+        skipbrackets();
+    
+    return 0;
 }
 
-dictValue_t scriptWait(scriptCtx_t*ctx, varVector_t* args){
+int part_Math(){
-	Inputs* input = hidWait();
+    int left, right;
-	
+    if (parseIntInput(argv[0], &left))
-	return IntDictValue(input->buttons);
+        return INFUNC_FAIL;
+    if (parseIntInput(argv[2], &right))
+        return INFUNC_FAIL;
+    
+    switch (argv[1][0]){
+        case '+':
+            return left + right;
+        case '-':
+            return left - right;
+        case '*':
+            return left * right;
+        case '/':
+            return left / right;
+    }
+    return INFUNC_FAIL;
 }
 
-dictValue_t scriptSetPixel(scriptCtx_t *ctx, varVector_t* args){
+int part_SetInt(){
-	int pixelArgs[5] = {0};
+    int out;
-
+    parseIntInput(argv[0], &out);
-	for (int i = 0; i < args->stored; i++){
+    return out;
-		if (args->vars[i].value.varType != IntType)
-			return ErrDictValue(ERRINVALIDTYPE);
-		pixelArgs[i] = args->vars[i].value.integer;
-	}
-
-	u32 color = 0xFF000000 | ((pixelArgs[2] & 0xFF) << 16) | ((pixelArgs[3] & 0xFF) << 8) | ((pixelArgs[4] & 0xFF));
-
-	gfx_setPixel(pixelArgs[0], pixelArgs[1], color);
-	return NullDictValue();
 }
 
-const static str_fnc_struct functions[] = {
+int part_SetString(){
-	{"print", funcPrint, {0x40}},
+    char *arg0;
-	{"println", funcPrintln, {0x40}},
+    if (parseStringInput(argv[0], &arg0))
-	{"if", funcIf, {1}},
+        return INFUNC_FAIL;
-	{"while", scriptWhile, {1}},
+    if (argv[1][0] != '$')
-	{"else", scriptElse, {0}},
+        return INFUNC_FAIL;
-	{"len", scriptLen, {1}},
+
-	{"byte", scriptMakeByteArray, {1}},
+    str_str_add(argv[1], arg0);
-	{"wait", scriptWait, {0}},
+    return 0;
-	{"setPixel", scriptSetPixel, {5}},
+}
-	{NULL, NULL, {0}},
+
+int part_SetStringIndex(){
+    int index;
+    char *out;
+    if (parseIntInput(argv[0], &index))
+        return INFUNC_FAIL;
+    if (argv[1][0] != '$')
+        return INFUNC_FAIL;
+    if (str_str_index(index, &out))
+        return INFUNC_FAIL;
+
+    str_str_add(argv[1], out);
+    return 0;
+}
+
+int part_goto(){
+    int target = 0;
+    if (parseIntInput(argv[0], &target))
+        return INFUNC_FAIL;
+
+    str_int_add("@RETURN", (int)f_tell(&scriptin));
+
+    f_lseek(&scriptin, target);
+    return 0;
+}
+
+int part_invert(){
+    int arg;
+    if (parseIntInput(argv[0], &arg))
+        return INFUNC_FAIL;
+    return (arg) ? 0 : 1;
+}
+
+int part_fs_exists(){
+    char *path;
+    if (parseStringInput(argv[0], &path))
+        return INFUNC_FAIL;
+    
+    return fsutil_checkfile(path);
+}
+
+int part_ConnectMMC(){
+    char *arg;
+    parseStringInput(argv[0], &arg);
+
+    if (!strcmp(arg, "SYSMMC"))
+        connect_mmc(SYSMMC);
+    else if (!strcmp(arg, "EMUMMC"))
+        connect_mmc(EMUMMC);
+    else
+        return INFUNC_FAIL;
+
+    return 0;
+}
+
+int part_MountMMC(){
+    char *arg;
+    parseStringInput(argv[0], &arg);
+    return mount_mmc(arg, 2);
+}
+
+int part_Pause(){
+    Inputs *input = hidWaitMask(KEY_A | KEY_B | KEY_X | KEY_Y | KEY_POW | KEY_VOLP | KEY_VOLM | KEY_LUP | KEY_LDOWN | KEY_LLEFT | KEY_LRIGHT);
+
+    str_int_add("@BTN_POWER", input->pow);
+    str_int_add("@BTN_VOL+", input->volp);
+    str_int_add("@BTN_VOL-", input->volm);
+    str_int_add("@BTN_A", input->a);
+    str_int_add("@BTN_B", input->b);
+    str_int_add("@BTN_X", input->x);
+    str_int_add("@BTN_Y", input->y);
+    str_int_add("@BTN_UP", input->Lup);
+    str_int_add("@BTN_DOWN", input->Ldown);
+    str_int_add("@BTN_LEFT", input->Lleft);
+    str_int_add("@BTN_RIGHT", input->Lright);
+    str_int_add("@JOYCONN", hidConnected());
+    
+    return input->buttons;
+}
+
+int part_addstrings(){
+    char *combined, *left, *middle;
+    if (parseStringInput(argv[0], &left))
+        return INFUNC_FAIL;
+    if (parseStringInput(argv[1], &middle))
+        return INFUNC_FAIL;
+    if (argv[2][0] != '$')
+        return INFUNC_FAIL;
+    
+    combined = calloc(strlen(left) + strlen(middle) + 1, sizeof(char));
+    sprintf(combined, "%s%s", left, middle);
+    
+    str_str_add(argv[2], combined);
+    free(combined);
+    return 0;
+}
+
+int part_setColor(){
+    char *arg;
+    if (parseStringInput(argv[0], &arg))
+        return INFUNC_FAIL;
+
+    if (!strcmp(arg, "RED"))
+        currentcolor = COLOR_RED;
+    else if (!strcmp(arg, "ORANGE"))
+        currentcolor = COLOR_ORANGE;
+    else if (!strcmp(arg, "YELLOW"))
+        currentcolor = COLOR_YELLOW;
+    else if (!strcmp(arg, "GREEN"))
+        currentcolor = COLOR_GREEN;
+    else if (!strcmp(arg, "BLUE"))
+        currentcolor = COLOR_BLUE;
+    else if (!strcmp(arg, "VIOLET"))
+        currentcolor = COLOR_VIOLET;
+    else if (!strcmp(arg, "WHITE"))
+        currentcolor = COLOR_WHITE;
+    else
+        return INFUNC_FAIL;
+
+    return 0;
+}
+
+int part_Exit(){
+    forceExit = true;
+    return 0;
+}
+
+int part_fs_Move(){
+    char *left, *right;
+
+    if (parseStringInput(argv[0], &left))
+        return INFUNC_FAIL;
+    if (parseStringInput(argv[1], &right))
+        return INFUNC_FAIL;
+
+    int res;
+    res = f_rename(left, right);
+    if (res)
+        res = f_rename(left, right);
+    
+    return res;
+}
+
+int part_fs_Delete(){
+    char *arg;
+
+    if (parseStringInput(argv[0], &arg))
+        return INFUNC_FAIL;
+
+    int res;
+    res = f_unlink(arg);
+    if (res)
+        res = f_unlink(arg);
+    
+    return res;
+}
+
+int part_fs_DeleteRecursive(){
+    char *arg;
+
+    if (parseStringInput(argv[0], &arg))
+        return INFUNC_FAIL;
+
+    return fsact_del_recursive(arg);
+}
+
+int part_fs_Copy(){
+    char *left, *right;
+
+    if (parseStringInput(argv[0], &left))
+        return INFUNC_FAIL;
+    if (parseStringInput(argv[1], &right))
+        return INFUNC_FAIL;
+
+    return fsact_copy(left, right, COPY_MODE_PRINT);
+}
+
+int part_fs_CopyRecursive(){
+    char *left, *right;
+
+    if (parseStringInput(argv[0], &left))
+        return INFUNC_FAIL;
+    if (parseStringInput(argv[1], &right))
+        return INFUNC_FAIL;
+
+    return fsact_copy_recursive(left, right);
+}
+
+int part_fs_MakeDir(){
+    char *arg;
+
+    if (parseStringInput(argv[0], &arg))
+        return INFUNC_FAIL;
+
+    int res;
+    res = f_mkdir(arg);
+    if (res)
+        res = f_mkdir(arg);
+    
+    return res;
+}
+
+DIR dir;
+FILINFO fno;
+int isdirvalid = false;
+int part_fs_OpenDir(){
+    char *path;
+
+    if (parseStringInput(argv[0], &path))
+        return INFUNC_FAIL;
+
+    if (f_opendir(&dir, path))
+        return INFUNC_FAIL;
+    
+    isdirvalid = true;
+    str_int_add("@ISDIRVALID", isdirvalid);
+    return 0;
+}
+
+int part_fs_CloseDir(){
+    if (!isdirvalid)
+        return 0;
+
+    f_closedir(&dir);
+    isdirvalid = false;
+    str_int_add("@ISDIRVALID", isdirvalid);
+    return 0;
+}
+
+int part_fs_ReadDir(){
+    if (!isdirvalid)
+        return INFUNC_FAIL;
+
+    if (!f_readdir(&dir, &fno) && fno.fname[0]){
+        str_str_add("$FILENAME", fno.fname);
+        str_int_add("@ISDIR", (fno.fattrib & AM_DIR) ? 1 : 0);
+    }
+    else {
+        part_fs_CloseDir();
+    }
+
+    return 0;
+}
+
+int part_setPrintPos(){
+    int left, right;
+
+    if (parseIntInput(argv[0], &left))
+        return INFUNC_FAIL;
+
+    if (parseIntInput(argv[1], &right))
+        return INFUNC_FAIL;
+
+    if (left > 78)
+        return INFUNC_FAIL;
+
+    if (right > 42)
+        return INFUNC_FAIL;
+
+    gfx_con_setpos(left * 16, right * 16);
+    return 0;
+}
+
+int part_stringcompare(){
+    char *left, *right;
+
+    if (parseStringInput(argv[0], &left))
+        return INFUNC_FAIL;
+    if (parseStringInput(argv[1], &right))
+        return INFUNC_FAIL;
+
+    return (strcmp(left, right)) ? 0 : 1;
+}
+
+int part_fs_combinePath(){
+    char *combined, *left, *middle;
+    if (parseStringInput(argv[0], &left))
+        return INFUNC_FAIL;
+    if (parseStringInput(argv[1], &middle))
+        return INFUNC_FAIL;
+    if (argv[2][0] != '$')
+        return INFUNC_FAIL;
+    
+    combined = fsutil_getnextloc(left, middle);
+    
+    str_str_add(argv[2], combined);
+    free(combined);
+    return 0;
+}
+
+int part_mmc_dumpPart(){
+    char *left, *right;
+
+    if (parseStringInput(argv[0], &left))
+        return INFUNC_FAIL;
+    if (parseStringInput(argv[1], &right))
+        return INFUNC_FAIL;
+
+    if (!strcmp(left, "BOOT")){
+        return emmcDumpBoot(right);
+    }
+    else {
+        return emmcDumpSpecific(left, right);
+    }
+}
+
+int part_mmc_restorePart(){
+    char *path;
+
+    if (parseStringInput(argv[0], &path))
+        return INFUNC_FAIL;
+
+    if (currentlyMounted < 0)
+        return INFUNC_FAIL;
+
+    return mmcFlashFile(path, currentlyMounted, false);   
+}
+
+int part_fs_extractBisFile(){
+    char *path, *outfolder;
+
+    if (parseStringInput(argv[0], &path))
+        return INFUNC_FAIL;
+    if (parseStringInput(argv[1], &outfolder))
+        return INFUNC_FAIL;
+
+    return extract_bis_file(path, outfolder);
+}
+
+int part_clearscreen(){
+    gfx_clearscreen();
+    return 0;
+}
+
+int part_getPos(){
+    return (int)f_tell(&scriptin);
+}
+
+int part_subString(){
+    char *str, *sub;
+    int start, size;
+
+    if (parseStringInput(argv[0], &str))
+        return INFUNC_FAIL;
+    if (parseIntInput(argv[1], &start))
+        return INFUNC_FAIL;
+    if (parseIntInput(argv[2], &size))
+        return INFUNC_FAIL;
+    if (argv[3][0] != '$')
+        return INFUNC_FAIL;
+
+    if (start >= strlen(str))
+        return INFUNC_FAIL;
+
+    sub = utils_copyStringSize(str + start, size);
+    str_str_add(argv[3], sub);
+    free(sub);
+    return 0;
+}
+
+int part_inputString(){
+    char *start, *out;
+    int len;
+
+    if (parseStringInput(argv[0], &start))
+        return INFUNC_FAIL;
+    if (parseIntInput(argv[1], &len))
+        return INFUNC_FAIL;
+    if (argv[2][0] != '$')
+        return INFUNC_FAIL;
+
+    if (len > 39)
+        return INFUNC_FAIL;
+
+    out = utils_InputText(start, len);
+    if (out == NULL)
+        return 1;
+
+    str_str_add(argv[2], out);
+    free(out);
+    return 0;
+}
+
+int part_strLen(){
+    char *in;
+
+    if (parseStringInput(argv[0], &in))
+        return INFUNC_FAIL;
+
+    return strlen(in);
+}
+
+str_fnc_struct functions[] = {
+    {"printf", part_printf, 255},
+    {"printInt", part_print_int, 1},
+    {"setPrintPos", part_setPrintPos, 2},
+    {"clearscreen", part_clearscreen, 0},
+    {"if", part_if, 1},
+    {"if", part_if_args, 3}, // function overloading
+    {"math", part_Math, 3},
+    {"check", part_Check, 3},
+    {"setInt", part_SetInt, 1},
+    {"goto", part_goto, 1},
+    {"setString", part_SetString, 2},
+    {"setStringIndex", part_SetStringIndex, 2},
+    {"setColor", part_setColor, 1},
+    {"combineStrings", part_addstrings, 3},
+    {"compareStrings", part_stringcompare, 2},
+    {"subString", part_subString, 4},
+    {"inputString", part_inputString, 3},
+    {"stringLength", part_strLen, 1},
+    {"invert", part_invert, 1},
+    {"fs_exists", part_fs_exists, 1},
+    {"fs_move", part_fs_Move, 2},
+    {"fs_mkdir", part_fs_MakeDir, 1},
+    {"fs_del", part_fs_Delete, 1},
+    {"fs_delRecursive", part_fs_DeleteRecursive, 1},
+    {"fs_copy", part_fs_Copy, 2},
+    {"fs_copyRecursive", part_fs_CopyRecursive, 2},
+    {"fs_openDir", part_fs_OpenDir, 1},
+    {"fs_closeDir", part_fs_CloseDir, 0},
+    {"fs_readDir", part_fs_ReadDir, 0},
+    {"fs_combinePath", part_fs_combinePath, 3},
+    {"fs_extractBisFile", part_fs_extractBisFile, 2},
+    {"mmc_connect", part_ConnectMMC, 1},
+    {"mmc_mount", part_MountMMC, 1},
+    {"mmc_dumpPart", part_mmc_dumpPart, 2},
+    {"mmc_restorePart", part_mmc_restorePart, 1},
+    {"getPosition", part_getPos, 0},
+    {"pause", part_Pause, 0},
+    {"wait", part_Wait, 1},
+    {"exit", part_Exit, 0},
+    {NULL, NULL, 0}
 };
 
-varVector_t extractVars(scriptCtx_t* ctx, lexarToken_t* tokens, u32 len) {
+#pragma GCC pop_options
-	varVector_t args = varVectorInit(4);
-	int lastLoc = 0;
-	for (int i = 0; i < len; i++) {
-		if (tokens[i].token == LSBracket) {
-			int distance = distanceBetweenTokens(&tokens[i + 1], len - i - 1, LSBracket, RSBracket);
-			i += distance + 1;
-		}
-		if (tokens[i].token == Seperator) {
-			dictValue_t res = solveEquation(ctx, &tokens[lastLoc], i - lastLoc);
-			lastLoc = i + 1;
-			varVectorAdd(&args, DictCreate(NULL, res));
-		}
 
-		if (i + 1 >= len) {
+int run_function(char *func_name, int *out){
-			dictValue_t res = solveEquation(ctx, &tokens[lastLoc], i + 1 - lastLoc);
+    for (u32 i = 0; functions[i].key != NULL; i++){
-			varVectorAdd(&args, DictCreate(NULL, res));
+        if (!strcmp(functions[i].key, func_name)){
-		}
+            if (argc != functions[i].arg_count && functions[i].arg_count != 255)
-	}
+                continue;
 
-	return args;
+            *out = functions[i].value();
-}
+            return (*out == INFUNC_FAIL) ? -1 : 0;
-
+        }
-dictValue_t executeFunction(scriptCtx_t* ctx, char* func_name) {
+    }
-	int argCount = 0;
+    return -2;
-	varVector_t args = { 0 };
-
-	if (ctx->args_loc.stored > 0) {
-		args = extractVars(ctx, ctx->args_loc.tokens, ctx->args_loc.stored);
-
-		for (int i = 0; i < args.stored; i++) {
-			if (args.vars[i].value.varType == ErrType)
-				return args.vars[i].value;
-		}
-
-		argCount = args.stored;
-	}
-
-	for (u32 i = 0; functions[i].key != NULL; i++) {
-		if (!strcmp(functions[i].key, func_name)) {
-			if (argCount != functions[i].argCount && !functions[i].varArgs)
-				continue;
-
-			dictValue_t val = functions[i].value(ctx, &args);
-			// free args
-			varVectorFree(&args);
-			return val;
-		}
-	}
-
-	dictValue_t* var = varVectorFind(&ctx->vars, func_name);
-	if (var != NULL) {
-		if (var->type == JumpType) {
-			setCurIndentInstruction(ctx, 0, ctx->curPos);
-			ctx->curPos = var->integer - 1;
-			ctx->lastToken.token = Invalid;
-			return NullDictValue();
-		}
-	}
-
-	return ErrDictValue(ERRNOFUNC);
 }

source/tegraexplorer/script/functions.h

@@ -1,10 +1,13 @@
 #pragma once
-#include "types.h"
+#include "../../utils/types.h"
 
-#define BIT(n) (1U << n)
+typedef void (*func_void_ptr)();
+typedef int (*func_int_ptr)();
 
-#define VARARGS(x) {x, 1, 0}
+typedef struct {
-#define OPERATORARGS(x) {x, 0, 1}
+    char *key;
+    func_int_ptr value;
+    u8 arg_count;
+} str_fnc_struct;
 
-dictValue_t executeFunction(scriptCtx_t* ctx, char* func_name);
+int run_function(char *func_name, int *out);
-varVector_t extractVars(scriptCtx_t* ctx, lexarToken_t* tokens, u32 len);

source/tegraexplorer/script/lexer.c

@@ -1,195 +0,0 @@
-#include "lexer.h"
-#include "parser.h"
-#include "args.h"
-#include "../utils/utils.h"
-#include "../../mem/heap.h"
-#include <string.h>
-
-static inline int isValidWord(char c) {
-	char r = c | 0x20;
-	return (r >= 'a' && r <= 'z');
-}
-
-static inline int isValidVar(char c) {
-	char r = c | 0x20;
-	return ((r >= 'a' && r <= 'z') || (r >= '0' && r <= '9'));
-}
-
-static inline int isValidNum(char c) {
-	return (c >= '0' && c <= '9');
-}
-
-static inline int isValidHexNum(char c) {
-	char r = c | 0x20;
-	return (isValidNum(r) || (r >= 'a' && r <= 'f'));
-}
-
-#define makeLexarToken(token, var) (lexarToken_t) {token, {var}}
-#define makeLexarIntToken(intVar) (lexarToken_t) {IntLit, .val = intVar}
-
-typedef struct {
-	u8 tokenC;
-	u16 tokenN;
-} lexarTranslation_t;
-
-lexarTranslation_t lexarTranslations[] = {
-	{'(', LBracket},
-	{')', RBracket},
-	{'{', LCBracket},
-	{'}', RCBracket},
-	{',', Seperator},
-	{'+', Plus},
-	{'-', Minus},
-	{'*', Multiply},
-	{'/', Division},
-	{'%', Mod},
-	{'<', Smaller},
-	{'>', Bigger},
-	{'=', Equal},
-	{'!', Not},
-	{'[', LSBracket},
-	{']', RSBracket},
-	{'\0', 0},
-};
-
-char lexarDebugGetTokenC(u16 tokenN) {
-	for (int i = 0; lexarTranslations[i].tokenC; i++) {
-		if (lexarTranslations[i].tokenN == tokenN) {
-			return lexarTranslations[i].tokenC;
-		}
-	}
-
-	return '?';
-}
-
-lexarVector_t lexarVectorInit(int startSize) {
-	lexarVector_t l = { 0 };
-	l.tokens = calloc(startSize, sizeof(lexarVector_t));
-	l.len = startSize;
-	l.stored = 0;
-	return l;
-}
-
-void lexarVectorAdd(lexarVector_t* vec, lexarToken_t token) {
-	if (vec->stored >= vec->len) {
-		vec->len *= 2;
-		//vec->tokens = realloc(vec->tokens, vec->len * sizeof(lexarToken_t));
-		void *temp = calloc(vec->len, sizeof(lexarToken_t));
-		memcpy(temp, vec->tokens, vec->len / 2 * sizeof(lexarToken_t));
-		free(vec->tokens);
-		vec->tokens = temp;
-	}
-
-	vec->tokens[vec->stored++] = token;
-}
-
-void lexarVectorClear(lexarVector_t* vec) {
-	for (int i = 0; i < vec->stored; i++) {
-		if (vec->tokens[i].token == Variable || vec->tokens[i].token == StrLit)
-			if (vec->tokens[i].text != NULL)
-				free(vec->tokens[i].text);
-	}
-	free(vec->tokens);
-}
-
-#define ELIFC(c) else if (*in == c)
-
-lexarVector_t lexarGo(const char* in) {
-	lexarVector_t vec = lexarVectorInit(16);
-
-	while (*in) {
-		if (isValidWord(*in)) {
-			char* startWord = in;
-			in++;
-			while (isValidVar(*in))
-				in++;
-
-			lexarVectorAdd(&vec, makeLexarToken(Variable, utils_copyStringSize(startWord, in - startWord)));
-			continue;
-		}
-		else if (isValidNum(*in) || (*in == '-' && isValidNum(in[1]))) {
-			int parse = 0;
-			u8 negative = (*in == '-');
-			if (negative)
-				in++;
-
-			if (*in == '0' && (in[1] | 0x20) == 'x') {
-				in += 2;
-				while (isValidHexNum(*in)) {
-					parse = parse * 16 + (*in & 0x0F) + (*in >= 'A' ? 9 : 0);
-					in++;
-				}
-			}
-			else while (isValidNum(*in)) {
-				parse = parse * 10 + *in++ - '0';
-			}
-
-			if (negative)
-				parse *= -1;
-
-			lexarVectorAdd(&vec, makeLexarIntToken(parse));
-			continue;
-		}
-		ELIFC('"') {
-			char* startStr = ++in;
-			while (*in != '"')
-				in++;
-
-			lexarVectorAdd(&vec, makeLexarToken(StrLit, utils_copyStringSize(startStr, in - startStr)));
-			in++;
-			continue;
-		}
-		ELIFC('#') {
-			while (*in != '\n')
-				in++;
-			
-			in++;
-			continue;
-		}
-		ELIFC('&') {
-			if (in[1] == '&') {
-				lexarVectorAdd(&vec, makeLexarToken(LogicAND, 0));
-				in++;
-			}
-			else {
-				lexarVectorAdd(&vec, makeLexarToken(AND, 0));
-			}
-
-			in++;
-			continue;
-		}
-		ELIFC('|') {
-			if (in[1] == '|') {
-				lexarVectorAdd(&vec, makeLexarToken(LogicOR, 0));
-				in++;
-			}
-			else {
-				lexarVectorAdd(&vec, makeLexarToken(OR, 0));
-			}
-
-			in++;
-			continue;
-		}
-
-		int val = 0;
-
-		for (int i = 0; lexarTranslations[i].tokenC; i++) {
-			if (lexarTranslations[i].tokenC == *in) {
-				val = lexarTranslations[i].tokenN;
-				break;
-			}
-		}
-
-		in++;
-
-		if (*in == '=' && val >= Smaller && val <= Not) {
-			val++;
-			in++;
-		}
-
-		if (val != Invalid)
-			lexarVectorAdd(&vec, makeLexarToken(val, 0));
-	}
-
-	return vec;
-}

source/tegraexplorer/script/lexer.h

@@ -1,6 +0,0 @@
-#pragma once
-#include "types.h"
-
-lexarVector_t lexarGo(const char* in);
-char lexarDebugGetTokenC(u16 tokenN);
-void lexarVectorClear(lexarVector_t* vec);

source/tegraexplorer/script/list.c

@@ -1,88 +0,0 @@
-#include "list.h"
-#include <string.h> 
-#include "types.h"
-#include "../../mem/heap.h"
-
-void freeDictValue(dictValue_t dv) {
-	if (dv.string == NULL)
-		return;
-
-	switch (dv.varType) {
-		case StringType:
-		case IntArrayType:
-		case ByteArrayType: // As it's a union with the biggest object being a pointer, this should be the same
-			free(dv.string);
-			break;
-		case StringArrayType:
-			for (unsigned int i = 0; i < dv.arrayLen; i++)
-				free(dv.stringArray[i]);
-
-			free(dv.stringArray);
-	}
-}
-
-void freeDict(dict_t* dict) {
-	freeDictValue(dict->value);
-	free(dict->key);
-	free(dict);
-}
-
-varVector_t varVectorInit(int startSize) {
-	varVector_t vec = { 0 };
-
-	vec.vars = calloc(startSize, sizeof(dict_t));
-	vec.len = startSize;
-	vec.stored = 0;
-	return vec;
-}
-
-dictValue_t* varVectorFind(varVector_t* vec, const char* key) {
-	for (int i = 0; i < vec->stored; i++) {
-		if (!strcmp(vec->vars[i].key, key))
-			return &vec->vars[i].value;
-	}
-
-	return NULL;
-}
-
-void varVectorAdd(varVector_t* vec, dict_t add) {
-	dictValue_t* var = NULL;
-	if (add.key != NULL)
-		var = varVectorFind(vec, add.key);
-
-	if (var != NULL) {
-		freeDictValue(*var);
-		*var = add.value;
-		free(add.key);
-		return;
-	}
-
-	if (vec->stored >= vec->len) {
-		vec->len *= 2;
-		dict_t* old = vec->vars;
-		//vec->vars = realloc(old, vec->len * sizeof(dict_t));
-		void *temp = calloc(vec->len, sizeof(dict_t));
-		memcpy(temp, vec->vars, vec->len / 2 * sizeof(dict_t));
-		free(vec->vars);
-		vec->vars = temp;
-		if (vec->vars == NULL) {
-			free(old);
-		}		
-	}
-
-	vec->vars[vec->stored] = add;
-	vec->stored++;
-}
-
-void varVectorFree(varVector_t* vec) {
-	for (int i = 0; i < vec->stored; i++) {
-		dict_t *var = &vec->vars[i];
-		if (var->key != NULL) {
-			free(var->key);
-			var->key = NULL;
-		}
-		if (var->value.free)
-			freeDictValue(var->value);
-	}
-	free(vec->vars);
-}

source/tegraexplorer/script/list.h

@@ -1,25 +0,0 @@
-#pragma once
-#include "types.h"
-
-#define dictValSetInt(dictVal, i) dictVal.integer = i; dictVal.type = IntType;
-#define dictValSetStr(dictVal, str) dictVal.string = strdup(str); dictVal.type = StringType;
-#define dictValSetJump(dictVal, i) dictVal.integer = i; dictVal.type = JumpType;
-
-#define dictValInt(i) (dictValue_t) {IntType, 0, i}
-
-#define DictCreate(key, value) (dict_t) {key, value}
-#define DictValueCreate(type, arrayLen, val) (dictValue_t) {type, arrayLen, val}
-
-void freeDictValue(dictValue_t dv);
-void freeDict(dict_t* dict);
-
-varVector_t varVectorInit(int startSize);
-void varVectorAdd(varVector_t* vec, dict_t add);
-dictValue_t* varVectorFind(varVector_t* vec, const char* key);
-
-static inline void freeDictValueOnVar(dictValue_t dv) {
-	if (dv.free)
-		freeDictValue(dv);
-}
-
-void varVectorFree(varVector_t* vec);

source/tegraexplorer/script/parser.c

@@ -1,263 +1,307 @@
-#include "args.h"
-#include "parser.h"
-#include "types.h"
-#include "list.h"
-#include "functions.h"
-#include "scriptCtx.h"
-#include "lexer.h"
 #include <string.h>
 #include "../../mem/heap.h"
-#include "../utils/utils.h"
-#include "../../storage/nx_sd.h"
-#include "../../gfx/gfx.h"
-#include "../../hid/hid.h"
 #include "../gfx/gfxutils.h"
+#include "../emmc/emmc.h"
+#include "../../utils/types.h"
+#include "../../libs/fatfs/ff.h"
+#include "../../utils/sprintf.h"
+#include "../../utils/btn.h"
+#include "../../gfx/gfx.h"
+#include "../../utils/util.h"
+#include "../../storage/emummc.h"
+#include "parser.h"
+#include "../common/common.h"
+#include "../fs/fsactions.h"
+#include "functions.h"
+#include "variables.h"
+#include "../fs/fsreader.h"
+#include "../utils/utils.h"
+#include "../../hid/hid.h"
 
-//#define DPRINTF(str, ...) printf(str, __VA_ARGS__)
+int countchars(const char* in, char target) {
-#define DPRINTF 
+    u32 len = strlen(in);
-
+    u32 count = 0;
-#define findNextCharsCtx(ctx, targets) findNextChars(&(ctx->curPos), targets)
+    
-
+    for (u32 i = 0; i < len; i++) {
-int checkIfVar(u16 token) {
+        if (in[i] == '"'){
-    return (token == StrLit || token == IntLit || token == Variable || token == RSBracket);
+            while (in[++i] != '"'){
-}
+                if (i >= len)
-
+                    return -1;
-void printToken(lexarToken_t* token) {
-    switch (token->token) {
-    case 1:
-        gfx_printf("%s ", token->text);
-        break;
-    case 6:
-        //printf("%d: '%s'\n", vec.tokens[i].token, vec.tokens[i].text);
-        gfx_printf("\"%s\" ", token->text);
-        break;
-    case 7:
-        //printf("%d: %d\n", vec.tokens[i].token, vec.tokens[i].val);
-        gfx_printf("%d ", token->val);
-        break;
-    default:
-        //printf("%d: %c\n", vec.tokens[i].token, lexarDebugGetTokenC(vec.tokens[i].token));
-        gfx_printf("%c ", lexarDebugGetTokenC(token->token));
-        break;
-    }
-}
-
-scriptResult_t runFunction(scriptCtx_t* ctx) {
-    dictValue_t res = solveEquation(ctx, &ctx->script->tokens[ctx->startEq], ctx->curPos - ctx->startEq);
-
-    if (res.varType == ErrType)
-        return scriptResultCreate(res.integer, &ctx->script->tokens[ctx->startEq]);
-
-    ctx->startEq = ctx->curPos;
-    if (ctx->varToken.token != Invalid) { // we should not assign null's
-        ctx->varToken.token = Invalid;
-        if (ctx->varIndexSet) {
-            ctx->varIndexSet = 0;
-            dictValue_t* arrayVal = varVectorFind(&ctx->vars, ctx->varToken.text);
-            if (!(arrayVal == NULL || arrayVal->arrayLen <= ctx->varIndex)) {
-                if (arrayVal->varType == IntArrayType && res.varType == IntType) {
-                    arrayVal->integerArray[ctx->varIndex] = res.integer;
-                }
-                else if (arrayVal->varType == StringArrayType && res.varType == StringType) {
-                    free(arrayVal->stringArray[ctx->varIndex]);
-                    arrayVal->stringArray[ctx->varIndex] = res.string;
-                }
-                else if (arrayVal->varType == ByteArrayType && res.varType == IntType) {
-                    arrayVal->byteArray[ctx->varIndex] = (u8)(res.integer & 0xFF);
-                }
-                else {
-                    return scriptResultCreate(ERRINVALIDTYPE, &ctx->script->tokens[ctx->startEq]);
-                }
-            }
-            else {
-                return scriptResultCreate(ERRNOVAR, &ctx->script->tokens[ctx->startEq]);
             }
         }
-        else {
+        if (in[i] == target)
-            varVectorAdd(&ctx->vars, DictCreate(util_cpyStr(ctx->varToken.text), res));
+            count++;
-        }
-    }
-    else {
-        freeDictValueOnVar(res);
     }
 
-    return scriptResultCreate(0, 0);
+    return count;
 }
 
-// TODO
+char **argv = NULL;
-// Make sure mem gets free'd properly
+u32 argc;
-// Fix bug that custom functions cannot be run from end of script
+u32 splitargs(const char* in) {
-// add arrays
+    // arg like '5, "6", @arg7'
+    u32 i = 0, count = 1, len = strlen(in), curcount = 0, begin, end;
 
-#define RUNFUNCWITHPANIC(ctx) scriptResult_t res = runFunction(ctx); if (res.resCode != 0) return res
+    count += countchars(in, ',');
 
-scriptResult_t mainLoop(scriptCtx_t* ctx) {
+    if (!count)
-    for (ctx->curPos = 0; ctx->curPos < ctx->script->stored; ctx->curPos++) {
+        return 0;
-        u32 i = ctx->curPos;
+    
-        lexarToken_t curToken = ctx->script->tokens[i];
+    argv = calloc(count + 1, sizeof(char*));
-        //printToken(&curToken);
+    
-
+    while (i < len && curcount < count) {
-        if (checkIfVar(ctx->lastToken.token) && curToken.token == Variable) {
+        if (in[i] == ' ' || in[i] == ','){
-            RUNFUNCWITHPANIC(ctx);
-        }
-        else if (curToken.token == Equal) {
-            // Set last var to lastToken, if lastToken is var
-
-            if (ctx->lastToken.token == RSBracket) {
-                int layer = 0;
-                i = ctx->lastTokenPos - 1;
-                for (; i > 0; i--) {
-                    if (ctx->script->tokens[i].token == RSBracket)
-                        layer++;
-                    else if (ctx->script->tokens[i].token == LSBracket) {
-                        if (layer == 0)
-                            break;
-                        layer--;
-                    }
-                }
-
-                i--;
-
-                if (ctx->script->tokens[i].token == Variable) {
-                    dictValue_t index = solveEquation(ctx, &ctx->script->tokens[i + 2], ctx->lastTokenPos - i - 2);
-                    ctx->lastTokenPos = i;
-                    ctx->lastToken = ctx->script->tokens[i];
-
-                    if (index.varType == IntType) {
-                        ctx->varIndex = index.integer;
-                        ctx->varIndexSet = 1;
-
-                        if (ctx->varIndexSet) {
-                            dictValue_t* arrayVal = varVectorFind(&ctx->vars, ctx->varToken.text);
-                            if (arrayVal == NULL) {
-                                return scriptResultCreate(ERRSYNTAX, &ctx->script->tokens[ctx->curPos]);
-                            }
-                           if (ctx->varIndex < 0 || ctx->varIndex >= arrayVal->arrayLen || arrayVal->varType < IntArrayType)
-                               return scriptResultCreate(ERRSYNTAX, &ctx->script->tokens[ctx->curPos]);
-                        }
-                    }
-                    else
-                        return scriptResultCreate(ERRINVALIDTYPE, &ctx->script->tokens[ctx->curPos]);
-                }
-                else 
-                    return scriptResultCreate(ERRSYNTAX, &ctx->script->tokens[ctx->curPos]);
-            }
-
-            if (ctx->lastToken.token == Variable) {
-                ctx->startEq = ctx->curPos + 1;
-                ctx->varToken = ctx->lastToken;
-            }
-            else
-                return scriptResultCreate(ERRSYNTAX, &ctx->script->tokens[ctx->curPos]);
-
-            //printf("Setting token %s to next assignment", ctx->lastToken.text);
-
-            // !! check prev for ] for arrays
-        }
-        else if (curToken.token == LBracket) {
             i++;
-            int distance = distanceBetweenTokens(&ctx->script->tokens[i], ctx->script->stored - i, LBracket, RBracket);
-            if (distance < 0)
-                return scriptResultCreate(ERRSYNTAX, &ctx->script->tokens[ctx->curPos]);
-
-            i += distance;
-            ctx->curPos = i;
-
-            if (ctx->curPos + 1 >= ctx->script->stored && checkIfVar(ctx->lastToken.token)) {
-                solveEquation(ctx, &ctx->script->tokens[ctx->startEq], i + 1 - ctx->startEq);
-            }
             continue;
         }
-        else if (curToken.token == LCBracket) {
+        
-            if (ctx->lastToken.token == Equal && ctx->varToken.token == Variable) {
+        begin = i;
-                varVectorAdd(&ctx->vars, DictCreate(util_cpyStr(ctx->varToken.text), DictValueCreate(JumpType, 0, ctx->curPos)));
-                ctx->varToken.token = Invalid;
-                setCurIndentInstruction(ctx, 1, -1);
-            }
 
-            if (checkIfVar(ctx->lastToken.token)) {
+        while (strrchr(" ,)", in[i]) == NULL){
-                RUNFUNCWITHPANIC(ctx);
+            if (in[i] == '"'){
-            }
+                begin = i + 1;
-
+                while (in[++i] != '"'){
-            ctx->startEq = ctx->curPos + 1;
+                    if (in[i] == '\0')
-
+                        return 0;
-            indentInstructor_t ins = getCurIndentInstruction(ctx);
-            if (ins.active) {
-                if (ins.skip) {
-                    int distance = distanceBetweenTokens(&ctx->script->tokens[i + 1], ctx->script->stored - i - 1, LCBracket, RCBracket);
-                    if (distance < 0)
-                        return scriptResultCreate(ERRSYNTAX, &ctx->script->tokens[ctx->curPos]);
-                    ctx->curPos += distance + 1;
-                    ctx->startEq = ctx->curPos + 1;
-                }
-                else {
-                    ctx->indentLevel++;
                 }
             }
-            else
-                return scriptResultCreate(ERRINACTIVEINDENT, &ctx->script->tokens[ctx->curPos]);
-        }
-        else if (curToken.token == RCBracket) {
-            if (checkIfVar(ctx->lastToken.token)) {
-                RUNFUNCWITHPANIC(ctx);
-                if (i != ctx->curPos)
-                    continue;
-            }
 
-            ctx->indentLevel--;
+            if (in[i] == '\0')
+                return 0;
 
-            indentInstructor_t ins = getCurIndentInstruction(ctx);
+            i++;
-            if (ins.active && ins.jump) {
-                ctx->curPos = ins.jumpLoc - 1;
-            }
-
-            ctx->startEq = ctx->curPos + 1;
-        }
-        else if (ctx->curPos + 1 >= ctx->script->stored && checkIfVar(ctx->lastToken.token)) {
-            solveEquation(ctx, &ctx->script->tokens[ctx->startEq], i + 1 - ctx->startEq);
         }
 
-        ctx->lastToken = ctx->script->tokens[ctx->curPos];
+        end = i;
-        ctx->lastTokenPos = ctx->curPos;
+
+        if (in[i - 1] == '"'){
+            end--;
+        }
+            
+        argv[curcount++] = utils_copyStringSize(in + begin, (u32)(end - begin));
     }
-
+    return curcount;
-    return scriptResultCreate(0, 0);
 }
 
-const char* functionFails[] = {
+FIL scriptin;
-    "An invalid operation was performed",
+UINT endByte = 0;
-    "Double Nots are not allowed",
+int forceExit = false;
-    "A syntax error was found",
+char currentchar = 0;
-    "The recieved type was incorrect",
-    "The variable could not be found",
-    "The specified function could not be found",
-    "An inactive indent was found"
-};
 
-void startScript(char* path) {
+char getnextchar(){
-    char* file = sd_file_read(path, NULL);
+    f_read(&scriptin, &currentchar, sizeof(char), &endByte);
+    
+    if (sizeof(char) != endByte)
+        forceExit = true;
 
-    if (file == NULL)
+    //gfx_printf("|%c|", currentchar);
+    return currentchar;
+}
+
+void getfollowingchar(char end){
+    while (currentchar != end && !f_eof(&scriptin)){
+        if (currentchar == '"'){
+            while (getnextchar() != '"' && !f_eof(&scriptin));
+        }
+        getnextchar();
+    }
+}
+
+void getnextvalidchar(){
+    while ((!((currentchar >= '?' && currentchar <= 'Z') || (currentchar >= 'a' && currentchar <= 'z') || currentchar == '#') && !f_eof(&scriptin)) /*|| currentchar == ';' */)
+        getnextchar();
+}
+
+char *makestr(u32 size, char ignore){
+    char *str;
+    u32 count = 0;
+
+    str = calloc(size + 1, sizeof(char));
+    for (u32 i = 0; i < size; i++){
+        getnextchar();
+        if (ignore != 0 && ignore == currentchar)
+            continue;
+                
+        str[count++] = currentchar;
+    }
+        
+    return str;
+}
+
+char *readtilchar(char end, char ignore){
+    FSIZE_t offset, size;
+
+    offset = f_tell(&scriptin);
+    getfollowingchar(end);
+    size = f_tell(&scriptin) - offset;
+
+    if (size <= 0)
+        return NULL;
+
+    f_lseek(&scriptin, offset - 1);
+
+    return makestr((u32)size, ignore);
+}
+
+
+char *funcbuff = NULL;
+void functionparser(){
+    char *unsplitargs;
+
+    /*
+    if (funcbuff != NULL)
+        free(funcbuff);
+    */
+
+    funcbuff = readtilchar('(', ' ');
+
+    getfollowingchar('(');
+    getnextchar();
+
+    unsplitargs = readtilchar(')', 0);
+
+    if (unsplitargs != NULL){
+        argc = splitargs(unsplitargs);
+        getnextchar();
+    }
+    else {
+        argc = 0;
+    }
+    getnextchar();
+
+    free(unsplitargs);
+}
+
+char *gettargetvar(){
+    char *variable = NULL;
+
+    variable = readtilchar('=', ' ');
+
+    getfollowingchar('=');
+    getnextchar();
+
+    return variable;
+}
+
+void mainparser(){
+    char *variable = NULL;
+    int res, out = 0;
+
+    getnextvalidchar();
+
+    if (f_eof(&scriptin))
         return;
 
-    gfx_clearscreen();
+    if (currentchar == '#'){
-
+        getfollowingchar('\n');
-    scriptCtx_t ctx = createScriptCtx();
+        return;
-    lexarVector_t vec = lexarGo(file);
-    free(file);
-    ctx.script = &vec;
-
-    scriptResult_t res = mainLoop(&ctx);
-    gfx_printf("end of script\n");
-
-    if (res.resCode) {
-        gfx_printf("[ERROR] %d\n%s\nNear:", res.resCode, functionFails[res.resCode - 1]);
-        printToken(res.nearToken);
     }
-   
+
-    gfx_printf("\n\n");
+    if (currentchar == '@'){
-    //mainLoop2(&ctx, &vec);
+        variable = gettargetvar();
-    lexarVectorClear(&vec);
+        getnextvalidchar();
-    destroyScriptCtx(&ctx);
+    }
-    hidWait();
+
+    functionparser();
+
+    res = run_function(funcbuff, &out);
+    if (res < 0){
+        printerrors = true;
+        //gfx_printf("%s|%s|%d", funcbuff, argv[0], argc);
+        //btn_wait();
+        int lineNumber = 1;
+        u64 end = f_tell(&scriptin);
+        f_lseek(&scriptin, 0);
+
+        while (f_tell(&scriptin) < end && !f_eof(&scriptin)){
+            if (getnextchar() == '\n')
+                lineNumber++;
+        }
+
+        gfx_errDisplay((res == -1) ? funcbuff : "run_function", (res == -1) ? ERR_IN_FUNC : ERR_SCRIPT_LOOKUP_FAIL, lineNumber);
+        forceExit = true;
+        //gfx_printf("Func: %s\nArg1: %s\n", funcbuff, argv[0]);
+    }
+    else {
+        str_int_add("@RESULT", out);
+
+        if (variable != NULL)
+            str_int_add(variable, out);
+    }
+
+    //gfx_printf("\nGoing to next func %c\n", currentchar);
+
+    if (funcbuff != NULL){
+         free(funcbuff);
+         funcbuff = NULL;
+    }
+
+    if (argv != NULL) {
+        for (int i = 0; argv[i] != NULL; i++)
+            free(argv[i]);
+        free(argv);
+        argv = NULL;
+    }
+
+    if (variable != NULL){
+        free(variable);
+    }
+}
+
+void skipbrackets(){
+    u32 bracketcounter = 0;
+
+    getfollowingchar('{');
+    getnextchar();
+
+    while ((currentchar != '}' || bracketcounter != 0) && !f_eof(&scriptin)){
+        if (currentchar == '{')
+            bracketcounter++;
+        else if (currentchar == '}')
+            bracketcounter--;
+
+        getnextchar();
+    }
+}
+
+extern u32 currentcolor;
+extern char *currentpath;
+void runScript(char *path){
+    int res;
+    char *path_local = NULL;
+    forceExit = false;
+    currentchar = 0;
+    currentcolor = COLOR_WHITE;
+    gfx_clearscreen();
+    utils_copystring(path, &path_local);
+
+    res = f_open(&scriptin, path, FA_READ | FA_OPEN_EXISTING);
+    if (res != FR_OK){
+        gfx_errDisplay("ParseScript", res, 1);
+        return;
+    }
+
+    printerrors = false;
+    
+    //add builtin vars
+    str_int_add("@EMUMMC", emu_cfg.enabled);
+    str_int_add("@RESULT", 0);
+    str_int_add("@JOYCONN", hidConnected());
+    str_str_add("$CURRENTPATH", currentpath);
+
+    //str_int_printall();
+
+    while (!f_eof(&scriptin) && !forceExit){
+        mainparser();
+    }
+
+    printerrors = true;
+    //str_int_printall();
+
+    f_close(&scriptin);
+    str_int_clear();
+    //str_jmp_clear();
+    str_str_clear();
+    free(path_local);
+    //btn_wait();
 }

source/tegraexplorer/script/parser.h

@@ -1,9 +1,7 @@
 #pragma once
 
-#include "types.h"
+#define INFUNC_FAIL (int)0xC0000000
-//#define DictValue(type, val, len) (dictValue_t) {type, len, val}
 
-#define scriptResultCreate(resCode, funcName) (scriptResult_t) {resCode, funcName}
+void runScript(char *path);
-
+void skipbrackets();
-void startScript(char* path);
+void getfollowingchar(char end);
-char* readFile(char* path);

source/tegraexplorer/script/scriptCtx.c

@@ -1,37 +0,0 @@
-#include "scriptCtx.h"
-#include "list.h"
-#include "malloc.h"
-#include "types.h"
-
-scriptCtx_t createScriptCtx() {
-	scriptCtx_t ctx;
-
-	ctx.indentInstructors = calloc(sizeof(indentInstructor_t), 64);
-	ctx.indentLevel = 0;
-	ctx.vars = varVectorInit(16);
-	ctx.script = NULL;
-	ctx.lastToken.token = 0;
-	ctx.varToken.token = 0;
-	ctx.startEq = 0;
-	ctx.varIndexStruct = 0;
-
-	return ctx;
-}
-
-void destroyScriptCtx(scriptCtx_t* ctx) {
-	// TODO
-	varVectorFree(&ctx->vars);
-	free(ctx->indentInstructors);
-}
-
-u8 setIndentInstruction(scriptCtx_t* ctx, u8 level, u8 skip, int jumpLoc) {
-	if (level >= 64)
-		return 1;
-
-	ctx->indentInstructors[level].skip = skip;
-	ctx->indentInstructors[level].active = 1;
-	ctx->indentInstructors[level].jump = (jumpLoc >= 0) ? 1 : 0;
-	ctx->indentInstructors[level].jumpLoc = jumpLoc;
-
-	return 0;
-}

source/tegraexplorer/script/scriptCtx.h

@@ -1,19 +0,0 @@
-#pragma once
-#include "types.h"
-
-#define TEXTHOLDEREMPTY() (textHolder_t) {0}
-#define TEXTHOLDER(start, len) (textHolder_t) {start, len, 1}
-
-u8 setIndentInstruction(scriptCtx_t* ctx, u8 level, u8 skip, int jumpLoc);
-void destroyScriptCtx(scriptCtx_t* ctx);
-scriptCtx_t createScriptCtx();
-static inline indentInstructor_t getCurIndentInstruction(scriptCtx_t* ctx);
-static inline u8 setCurIndentInstruction(scriptCtx_t* ctx, u8 skip, int jumpLoc);
-
-static inline u8 setCurIndentInstruction(scriptCtx_t* ctx, u8 skip, int jumpLoc) {
-	return setIndentInstruction(ctx, ctx->indentLevel, skip, jumpLoc);
-}
-
-static inline indentInstructor_t getCurIndentInstruction(scriptCtx_t* ctx) {
-	return ctx->indentInstructors[ctx->indentLevel];
-}

source/tegraexplorer/script/types.h

@@ -1,174 +0,0 @@
-#pragma once
-
-typedef unsigned char u8;
-typedef unsigned short u16;
-typedef unsigned int u32;
-
-typedef struct {
-	u16 token;
-	union {
-		char* text;
-		int val;
-	};
-} lexarToken_t;
-
-typedef struct {
-	lexarToken_t* tokens;
-	u32 len;
-	u32 stored;
-} lexarVector_t;
-
-enum Tokens {
-	Invalid = 0,
-	Variable = 1,
-	LBracket,
-	RBracket,
-	RCBracket,
-	LCBracket,
-	StrLit,
-	IntLit,
-	Seperator,
-	Plus,
-	Minus,
-	Multiply,
-	Division,
-	Mod,
-	Smaller,
-	SmallerEqual,
-	Bigger,
-	BiggerEqual,
-	Equal,
-	EqualEqual,
-	Not,
-	NotEqual,
-	LogicAND,
-	LogicOR,
-	LSBracket,
-	RSBracket,
-	AND,
-	OR
-};
-
-enum Errors {
-	ERRBADOPERATOR = 1,
-	ERRDOUBLENOT,
-	ERRSYNTAX,
-	ERRINVALIDTYPE,
-	ERRNOVAR,
-	ERRNOFUNC,
-	ERRINACTIVEINDENT
-};
-
-typedef struct { // this is to keep track of how many {} we passed. Keep an internal var with the "indentation level", +1 for {, -1 for }. have an array with the following def on what to do (on func: enter, set indentation & jump back, on while, jump to while, use while as if, on if simply set true or false)
-	union {
-		struct {
-			u8 active : 1;
-			u8 skip : 1;
-			u8 jump : 1;
-		};
-		u8 container;
-	};
-	int jumpLoc;
-} indentInstructor_t;
-
-typedef struct {
-	char* start;
-	u32 len;
-	union {
-		struct {
-			u8 set : 1;
-		};
-		u8 options;
-	};
-} textHolder_t;
-
-typedef struct {
-	int resCode;
-	lexarToken_t* nearToken;
-} scriptResult_t;
-
-#define JumpDictValue(jump) (dictValue_t) {{JumpType}, 0, .integer = jump}
-#define StrDictValue(str) (dictValue_t) {{StringType}, 0, .string = str}
-#define ErrDictValue(err) (dictValue_t) {{ErrType}, 0, .integer = err}
-#define NullDictValue() (dictValue_t) {{NullType}, 0, .integer = 0}
-#define IntArrDictValue(arr, len) (dictValue_t) {{IntArrayType}, len, .integerArray = arr}
-#define StringArrDictValue(arr, len) (dictValue_t) {{StringArrayType}, len, .stringArray = arr}
-#define IntDictValue(i) (dictValue_t) {{IntType}, 0, .integer = i}
-
-enum {
-	IntType = 0,
-	StringType,
-	IntArrayType,
-	StringArrayType,
-	ByteArrayType,
-	JumpType,
-	DictType,
-	NullType,
-	ErrType,
-};
-
-typedef struct {
-	union {
-		u8 type;
-		struct {
-			u8 varType : 7;
-			u8 free : 1;
-		};
-	};
-	unsigned int arrayLen;
-	union {
-		int integer;
-		char* string;
-		unsigned char* byteArray;
-		int* integerArray;
-		char** stringArray;
-	};
-} dictValue_t;
-
-typedef struct {
-	char* key;
-	dictValue_t value;
-} dict_t;
-
-typedef struct {
-	dict_t* vars;
-	u32 len;
-	u32 stored;
-} varVector_t;
-
-typedef struct {
-	indentInstructor_t* indentInstructors;
-	u8 indentLevel; // -> max 63
-	varVector_t vars;
-	lexarVector_t* script;
-	lexarToken_t lastToken;
-	lexarToken_t varToken;
-	u32 startEq;
-	u32 curPos;
-	u32 lastTokenPos;
-	lexarVector_t args_loc;
-	union {
-		u32 varIndexStruct;
-		struct {
-			u32 varIndex : 31;
-			u32 varIndexSet : 1;
-		};
-	};
-} scriptCtx_t;
-
-typedef dictValue_t(*func_int_ptr)(scriptCtx_t* ctx, varVector_t* args);
-
-typedef struct {
-	char* key;
-	func_int_ptr value;
-	union {
-		u8 args;
-		struct {
-			u8 argCount : 6;
-			u8 varArgs : 1;
-			u8 operatorParse : 1;
-		};
-	};
-} str_fnc_struct;
-
-#define FREEINDICT 0x80

source/tegraexplorer/script/variables.c

@@ -0,0 +1,250 @@
+#include <string.h>
+#include "../../mem/heap.h"
+#include "../gfx/gfxutils.h"
+#include "../emmc/emmc.h"
+#include "../../utils/types.h"
+#include "../../libs/fatfs/ff.h"
+#include "../../utils/sprintf.h"
+#include "../../utils/btn.h"
+#include "../../gfx/gfx.h"
+#include "../../utils/util.h"
+#include "../../storage/emummc.h"
+#include "parser.h"
+#include "../common/common.h"
+#include "../fs/fsactions.h"
+#include "variables.h"
+#include "../utils/utils.h"
+
+static dict_str_int *str_int_table = NULL;
+static dict_str_str *str_str_table = NULL;
+//static dict_str_loc *str_jmp_table = NULL;
+
+int str_int_add(char *key, int value){
+    char *key_local;
+    dict_str_int *keyvaluepair;
+
+    utils_copystring(key, &key_local);
+    
+    keyvaluepair = calloc(1, sizeof(dict_str_int));
+    keyvaluepair->key = key_local;
+    keyvaluepair->value = value;
+    keyvaluepair->next = NULL;
+
+    if (str_int_table == NULL){
+        str_int_table = keyvaluepair;
+    }
+    else {
+        dict_str_int *temp;
+        temp = str_int_table;
+        while (temp != NULL){
+            if (!strcmp(temp->key, key_local)){
+                free(keyvaluepair);
+                free(key_local);
+                temp->value = value;
+                return 0;
+            }
+
+            if (temp->next == NULL){
+                temp->next = keyvaluepair;
+                return 0;
+            }
+
+            temp = temp->next;
+        }
+    }
+
+    return 0;
+}
+
+int str_int_find(char *key, int *out){
+    dict_str_int *temp;
+    temp = str_int_table;
+    while (temp != NULL){
+        if (!strcmp(temp->key, key)){
+            *out = temp->value;
+            return 0;
+        }
+        temp = temp->next;
+    }
+
+    return -1;
+}
+
+void str_int_clear(){
+    dict_str_int *cur, *next;
+    cur = str_int_table;
+
+    while (cur != NULL){
+        next = cur->next;
+        free(cur->key);
+        free(cur);
+        cur = next;
+    }
+    str_int_table = NULL;
+}
+
+void str_int_printall(){
+    dict_str_int *temp;
+    temp = str_int_table;
+    while (temp != NULL){
+        gfx_printf("%s -> %d\n", temp->key, temp->value);
+        temp = temp->next;
+    }
+}
+/*
+int str_jmp_add(char *key, u64 value){
+    char *key_local;
+    dict_str_loc *keyvaluepair;
+
+    //gfx_printf("Adding |%s|\n", key_local);
+
+    utils_copystring(key, &key_local);
+
+    keyvaluepair = calloc(1, sizeof(dict_str_loc));
+    keyvaluepair->key = key_local;
+    keyvaluepair->value = value;
+    keyvaluepair->next = NULL;
+    
+    if (str_jmp_table == NULL){
+        str_jmp_table = keyvaluepair;
+    }
+    else {
+        dict_str_loc *temp;
+        temp = str_jmp_table;
+        while (temp != NULL){
+            if (!strcmp(temp->key, key_local)){
+                free(keyvaluepair);
+                free(key_local);
+
+                temp->value = value;
+                return 0;
+            }
+
+            if (temp->next == NULL){
+                temp->next = keyvaluepair;
+                return 0;
+            }
+
+            temp = temp->next;
+        }
+    }
+
+    return 0;
+}
+
+int str_jmp_find(char *key, u64 *out){
+    dict_str_loc *temp;
+    temp = str_jmp_table;
+    //gfx_printf("Searching |%s|\n", key);
+    while (temp != NULL){
+        if (!strcmp(temp->key, key)){
+            //gfx_printf("Key found!\n", temp->value);
+            *out = temp->value;
+            return 0;
+        }
+        temp = temp->next;
+    }
+
+    //gfx_printf("no key!\n");
+    return -1;
+}
+
+void str_jmp_clear(){
+    dict_str_loc *cur, *next;
+    cur = str_jmp_table;
+
+    while (cur != NULL){
+        next = cur->next;
+        free(cur->key);
+        free(cur);
+        cur = next;
+    }
+    str_jmp_table = NULL;
+}
+*/
+
+int str_str_add(char *key, char *value){
+    char *key_local, *value_local;
+    dict_str_str *keyvaluepair;
+    //gfx_printf("Adding |%s|\n", key_local);
+    utils_copystring(value, &value_local);
+    utils_copystring(key, &key_local);
+
+    keyvaluepair = calloc(1, sizeof(dict_str_str));
+    keyvaluepair->key = key_local;
+    keyvaluepair->value = value_local;
+    keyvaluepair->next = NULL;
+    
+    if (str_str_table == NULL){
+        str_str_table = keyvaluepair;
+    }
+    else {
+        dict_str_str *temp;
+        temp = str_str_table;
+        while (temp != NULL){
+            if (!strcmp(temp->key, key_local)){
+                free(keyvaluepair);
+                free(key_local);
+                
+                free(temp->value);
+                temp->value = value_local;
+                return 0;
+            }
+
+            if (temp->next == NULL){
+                temp->next = keyvaluepair;
+                return 0;
+            }
+
+            temp = temp->next;
+        }
+    }
+
+    return 0;
+}
+
+int str_str_find(char *key, char **out){
+    dict_str_str *temp;
+    temp = str_str_table;
+
+    while (temp != NULL){
+        if (!strcmp(temp->key, key)){
+            *out = temp->value;
+            return 0;
+        }
+        temp = temp->next;
+    }
+
+    return -1;
+}
+
+int str_str_index(int index, char **out){
+    dict_str_str *temp;
+    temp = str_str_table;
+
+    for (int i = 0; i < index; i++){
+        if (temp == NULL)
+            return -1;
+        temp = temp->next;
+    }
+
+    if (temp == NULL)
+        return -1;
+
+    *out = temp->value;
+    return 0;
+}
+
+void str_str_clear(){
+    dict_str_str *cur, *next;
+    cur = str_str_table;
+
+    while (cur != NULL){
+        next = cur->next;
+        free(cur->key);
+        free(cur->value);
+        free(cur);
+        cur = next;
+    }
+    str_str_table = NULL;
+}

source/tegraexplorer/script/variables.h

@@ -0,0 +1,34 @@
+#pragma once
+#include "../../utils/types.h"
+
+typedef struct _dict_str_int {
+    char *key;
+    int value;
+    struct _dict_str_int *next;
+} dict_str_int;
+
+typedef struct _dict_str_str {
+    char *key;
+    char *value;
+    struct _dict_str_str *next;
+} dict_str_str;
+
+typedef struct _dict_str_loc {
+    char *key;
+    u64 value;
+    struct _dict_str_loc *next;
+} dict_str_loc;
+
+int str_int_add(char *key, int value);
+int str_int_find(char *key, int *out);
+void str_int_clear();
+void str_int_printall();
+/*
+int str_jmp_add(char *key, u64 value);
+int str_jmp_find(char *key, u64 *out);
+void str_jmp_clear();
+*/
+int str_str_add(char *key, char *value);
+int str_str_find(char *key, char **out);
+int str_str_index(int index, char **out);
+void str_str_clear();

source/tegraexplorer/utils/utils.c

@@ -202,10 +202,4 @@ char *utils_copyStringSize(const char *in, int size){
     //strncpy(out, in, size);
     memcpy(out, in, size);
     return out;
-}
-
-char* util_cpyStr(const char* in){
-    char *out = malloc(strlen(in) + 1);
-    strcpy(out, in);
-    return out;
 }

source/tegraexplorer/utils/utils.h

@@ -24,5 +24,4 @@ int utils_mmcMenu();
 void utils_copystring(const char *in, char **out);
 char *utils_InputText(char *start, int maxLen);
 void utils_takeScreenshot();
-char *utils_copyStringSize(const char *in, int size);
+char *utils_copyStringSize(const char *in, int size);
-char* util_cpyStr(const char* in);