add crude firmware dumping script

source/script/genericClass.c

@@ -255,8 +255,6 @@ Variable_t* callMemberFunctionDirect(Variable_t* var, char* memberName, Variable
 void freeVariableInternal(Variable_t* referencedTarget) {
 	switch (referencedTarget->variableType) {
 		case StringClass:
-			if (referencedTarget->string.free)
-				gfx_printf("FREE STRING GETTING FREED AAA");
 			FREE(referencedTarget->string.value);
 			break;
 		case StringArrayClass:

source/script/intClass.c

@@ -1,7 +1,9 @@
 #include "intClass.h"
+#include "StringClass.h"
 #include "compat.h"
 #include <malloc.h>
 #include <string.h>
+#include <utils/sprintf.h>
 
 IntClass_t createIntClass(s64 in) {
 	IntClass_t a = { in };
@@ -20,6 +22,12 @@ ClassFunction(printIntVariable) {
 	return &emptyClass;
 }
 
+ClassFunction(intToStr) {
+	char buff[64] = {0};
+	s_printf(buff, "%d", getIntValue(caller));
+	return newStringVariablePtr(CpyStr(buff), 0, 1);
+}
+
 #define IntOpFunction(name, op) ClassFunction(name) { s64 i1 = getIntValue(caller); s64 i2 = getIntValue(*args); return newIntVariablePtr((i1 op i2)); }
 
 IntOpFunction(addInt, +)
@@ -52,6 +60,7 @@ u8 oneIntArgInt[] = { IntClass };
 ClassFunctionTableEntry_t intFunctions[] = {
 	{"print", printIntVariable, 0, 0},
 	{"not", notInt, 0, 0},
+	{"str", intToStr, 0, 0},
 	IntOpFunctionEntry("+", addInt),
 	IntOpFunctionEntry("-", minusInt),
 	IntOpFunctionEntry("*", multInt),

source/script/standardLibrary.c

@@ -11,6 +11,10 @@
 #ifndef WIN32
 #include "../storage/mountmanager.h"
 #include "../keys/keys.h"
+#include "../fs/readers/folderReader.h"
+#include "../fs/fscopy.h"
+#include <mem/heap.h>
+#include "../keys/nca.h"
 #endif
 
 ClassFunction(stdIf) {
@@ -122,6 +126,79 @@ ClassFunction(stdSetPixel) {
 	gfx_set_pixel_horz(args[0]->integer.value, args[1]->integer.value, color);
 	return &emptyClass;
 }
+
+ClassFunction(stdReadDir){
+	Vector_t dict = newVec(sizeof(Dict_t), 4);
+	Variable_t* resPtr = newIntVariablePtr(0);
+	Dict_t temp = {.name = CpyStr("result"), .var = resPtr};
+	vecAdd(&dict, temp);
+
+	Variable_t fileNamesArray = {.variableType = StringArrayClass, .solvedArray.vector = newVec(sizeof(char*), 0)};
+	Variable_t dirNamesArray = {.variableType = StringArrayClass, .solvedArray.vector = newVec(sizeof(char*), 0)};
+	Variable_t fileSizeArray = {.variableType = IntArrayClass, .solvedArray.vector = newVec(sizeof(s64), 0)};
+
+	DIR dir;
+	if ((resPtr->integer.value = f_opendir(&dir, args[0]->string.value))){
+		Variable_t ret = {.variableType = DictionaryClass, .dictionary.vector = dict};
+		return copyVariableToPtr(ret);
+	}
+
+	FILINFO fno;
+	while (!(resPtr->integer.value = f_readdir(&dir, &fno)) && fno.fname[0]){
+		char *name = CpyStr(fno.fname);
+		if (fno.fattrib & AM_DIR){
+			vecAdd(&dirNamesArray.solvedArray.vector, name);
+		}
+		else {
+			vecAdd(&fileNamesArray.solvedArray.vector, name);
+			s64 size = fno.fsize;
+			vecAdd(&fileSizeArray.solvedArray.vector, size);
+		}
+	}
+
+	f_closedir(&dir);
+
+	temp.name = CpyStr("files");
+	temp.var = copyVariableToPtr(fileNamesArray);
+	vecAdd(&dict, temp);
+
+	temp.name = CpyStr("folders");
+	temp.var = copyVariableToPtr(dirNamesArray);
+	vecAdd(&dict, temp);
+	
+	temp.name = CpyStr("fileSizes");
+	temp.var = copyVariableToPtr(fileSizeArray);
+	vecAdd(&dict, temp);
+
+	Variable_t ret = {.variableType = DictionaryClass, .dictionary.vector = dict};
+	return copyVariableToPtr(ret);
+}
+
+ClassFunction(stdFileCopy){
+	ErrCode_t e = FileCopy(args[0]->string.value, args[1]->string.value, 0);
+	return newIntVariablePtr(e.err);
+}
+
+ClassFunction(stdMkdir){
+	return newIntVariablePtr(f_mkdir(args[0]->string.value));
+}
+
+// Broken????
+ClassFunction(stdGetMemUsage){
+	heap_monitor_t mon;
+	heap_monitor(&mon, false);
+	Dict_t a = {.name = CpyStr("used"), .var = newIntVariablePtr((s64)mon.used)};
+	Dict_t b = {.name = CpyStr("total"), .var = newIntVariablePtr((s64)mon.total)};
+	Variable_t ret = {.variableType = DictionaryClass, .dictionary.vector = newVec(sizeof(Dict_t), 2)};
+	vecAdd(&ret, a);
+	vecAdd(&ret, b);
+	return copyVariableToPtr(ret);
+}
+
+ClassFunction(stdGetNcaType){
+	int type = GetNcaType(args[0]->string.value);
+	return newIntVariablePtr(type);
+}
 #else
 ClassFunction(stdMountSysmmc){
 	return newIntVariablePtr(0);
@@ -132,12 +209,29 @@ ClassFunction(stdMountSave){
 ClassFunction(stdSetPixel) {
 	return newIntVariablePtr(0);
 }
+
+ClassFunction(stdReadDir){
+	return newIntVariablePtr(0);
+}
+
+ClassFunction(stdFileCopy){
+	return newIntVariablePtr(0);
+}
+
+ClassFunction(stdMkdir){
+	return newIntVariablePtr(0);
+}
+
+ClassFunction(stdGetMemUsage) {
+	return newIntVariablePtr(0);
+}
 #endif
 
 u8 oneIntoneFunction[] = { IntClass, FunctionClass };
 u8 doubleFunctionClass[] = { FunctionClass, FunctionClass };
 u8 oneStringArgStd[] = {StringClass};
 u8 threeIntsStd[] = { IntClass, IntClass, IntClass };
+u8 twoStringArgStd[] = {StringClass, StringClass};
 
 ClassFunctionTableEntry_t standardFunctionDefenitions[] = {
 	{"if", stdIf, 2, oneIntoneFunction},
@@ -150,6 +244,11 @@ ClassFunctionTableEntry_t standardFunctionDefenitions[] = {
 	{"break", stdBreak, 0, 0},
 	{"dict", stdDict, 0, 0},
 	{"setpixel", stdSetPixel, 3, threeIntsStd},
+	{"readdir", stdReadDir, 1, oneStringArgStd},
+	{"filecopy", stdFileCopy, 2, twoStringArgStd},
+	{"mkdir", stdMkdir, 1, oneStringArgStd},
+	{"memory", stdGetMemUsage, 0, 0},
+	{"ncatype", stdGetNcaType, 1, oneStringArgStd},
 };
 
 ClassFunctionTableEntry_t* searchStdLib(char* funcName) {