1
0
Fork 0
mirror of https://github.com/suchmememanyskill/TegraExplorer.git synced 2024-12-25 10:56:09 +00:00

implement TScript v2.5

This commit is contained in:
suchmememanyskill 2020-12-28 14:51:59 +01:00
parent 513bd804b1
commit b0dd71bd4f
15 changed files with 1245 additions and 2 deletions

View file

@ -11,6 +11,10 @@
#include <libs/fatfs/ff.h>
#include "../../utils/utils.h"
#include "../../keys/nca.h"
#include "../../script/lexer.h"
#include "../../script/parser.h"
#include "../../script/variables.h"
#include <storage/nx_sd.h>
MenuEntry_t FileMenuEntries[] = {
// Still have to think up the options
@ -66,6 +70,27 @@ void DeleteFile(char *path, FSEntry_t entry){
free(thing);
}
void RunScript(char *path, FSEntry_t entry){
char *thing = CombinePaths(path, entry.name);
u32 size;
char *script = sd_file_read(thing, &size);
free(thing);
if (!script)
return;
gfx_clearscreen();
scriptCtx_t ctx = createScriptCtx();
ctx.script = runLexar(script, size);
free(script);
printError(mainLoop(&ctx));
freeVariableVector(&ctx.varDict);
lexarVectorClear(&ctx.script);
gfx_printf("\nend of script");
hidWait();
}
menuPaths FileMenuPaths[] = {
CopyClipboard,
MoveClipboard,
@ -73,7 +98,7 @@ menuPaths FileMenuPaths[] = {
DeleteFile,
UnimplementedException,
LaunchPayload,
UnimplementedException
RunScript
};
void FileMenu(char *path, FSEntry_t entry){

View file

@ -244,6 +244,8 @@ void gfx_putc(char c)
if (gfx_con.y < 16){
gfx_con.y = YLeftConfig;
gfx_con.x += 16;
if (gfx_con.x > 719)
gfx_con.x = 0;
}
}
else if (c == '\n')

404
source/script/args.c Normal file
View file

@ -0,0 +1,404 @@
#include "args.h"
#include "types.h"
#include "functions.h"
#include "variables.h"
#include <string.h>
#include <mem/heap.h>
#include "../utils/utils.h"
char* utils_copyStringSize(const char* in, int size) {
if (size > strlen(in) || size < 0)
size = strlen(in);
char* out = calloc(size + 1, 1);
//strncpy(out, in, size);
if (size)
memcpy(out, in, size);
return out;
}
// 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;
}
Vector_t extractVars(scriptCtx_t* ctx, lexarToken_t* tokens, u32 len) {
Vector_t args = newVec(sizeof(Variable_t), 5);
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) {
Variable_t res = solveEquation(ctx, &tokens[lastLoc], i - lastLoc, 0);
lastLoc = i + 1;
vecAddElement(&args, res);
}
if (i + 1 >= len) {
Variable_t res = solveEquation(ctx, &tokens[lastLoc], i + 1 - lastLoc, 0);
vecAddElement(&args, res);
}
}
return args;
}
#define ErrValue(err) (Variable_t) {.varType = ErrType, .integerType = err}
#define IntValue(i) (Variable_t) {.varType = IntType, .integerType = i}
#define StrValue(s) (Variable_t) {.varType = StringType, .stringType = s}
#define ELIFTX(x) else if (tokens[i].token == x)
Variable_t getVarFromToken(scriptCtx_t* ctx, lexarToken_t* tokens, int* index, u32 maxLen) {
Variable_t val = { 0 };
int i = *index;
if (tokens[i].token == Variable) {
Variable_t* var = dictVectorFind(&ctx->varDict, tokens[i].text);
if (var != NULL) {
val = *var;
val.free = 0;
}
else {
val = ErrValue(ERRNOVAR);
}
}
ELIFTX(IntLit) {
val = IntValue(tokens[i].val);
}
ELIFTX(StrLit) {
val = StrValue(tokens[i].text);
val.free = 0;
}
ELIFTX(ArrayVariable) {
Variable_t* var = dictVectorFind(&ctx->varDict, tokens[i].text);
i += 2;
if (var == NULL)
return ErrValue(ERRNOVAR);
int argCount = distanceBetweenTokens(&tokens[i], maxLen - 2, LSBracket, RSBracket);
if (argCount < 0)
return ErrValue(ERRSYNTAX);
Variable_t index = solveEquation(ctx, &tokens[i], argCount, 0);
i += argCount;
if (index.varType != IntType)
return ErrValue(ERRINVALIDTYPE);
if (var->vectorType.count <= index.integerType || index.integerType < 0)
return ErrValue(ERRSYNTAX);
switch (var->varType) {
case StringArrayType:
val = StrValue((vecGetArray(char**, var->vectorType))[index.integerType]);
break;
case IntArrayType:
val = IntValue((vecGetArray(int*, var->vectorType))[index.integerType]);
break;
case ByteArrayType:
val = IntValue((vecGetArray(u8*, var->vectorType))[index.integerType]);
break;
default:
return ErrValue(ERRINVALIDTYPE);
}
}
ELIFTX(Function) {
i += 2;
int argCount = distanceBetweenTokens(&tokens[i], maxLen - 2, LBracket, RBracket);
if (argCount < 0)
return ErrValue(ERRSYNTAX);
val = executeFunction(ctx, tokens[i - 2].text, &tokens[i], argCount);
//val = IntValue(1);
i += argCount;
}
ELIFTX(LSBracket) {
i++;
int argCount = distanceBetweenTokens(&tokens[i], maxLen - 1, LSBracket, RSBracket);
if (argCount <= 0)
return ErrValue(ERRSYNTAX);
// ArrayVars should be a Vector_t containing Variable_t's. Not implemented yet!
Vector_t arrayVars = extractVars(ctx, &tokens[i], argCount);
Variable_t* variables = vecGetArray(Variable_t*, arrayVars);
int type = variables[0].varType;
if (!(type == StringType || type == IntType))
return ErrValue(ERRINVALIDTYPE);
val.varType = (type + 2);
val.free = 1;
val.vectorType = newVec((type == IntType) ? sizeof(int) : sizeof(char*), arrayVars.count);
for (int i = 0; i < arrayVars.count; i++) {
if (variables[i].varType != type)
return ErrValue(ERRINVALIDTYPE); // Free-ing issue!!
if (type == StringType) {
char* temp = CpyStr(variables[i].stringType);
vecAddElement(&val.vectorType, temp);
}
else {
vecAddElement(&val.vectorType, variables[i].integerType);
}
}
i += argCount;
freeVariableVector(&arrayVars);
}
ELIFTX(LBracket) {
i++;
int argCount = distanceBetweenTokens(&tokens[i], maxLen - 1, LBracket, RBracket);
if (argCount < 0)
return ErrValue(ERRSYNTAX);
val = solveEquation(ctx, &tokens[i], argCount, 0);
i += argCount;
}
else {
// ERR
return ErrValue(ERRSYNTAX);
}
*index = i;
return val;
}
int matchTypes(Variable_t d1, Variable_t d2, int type) {
return (d1.varType == d2.varType && d1.varType == type);
}
#define ELIFT(token) else if (localOpToken == token)
Variable_t solveEquation(scriptCtx_t* ctx, lexarToken_t* tokens, u32 len, u8 shouldFree) {
Variable_t res = { 0 };
u8 lastToken = 0;
u8 invertValue = 0;
lexarToken_t* varToken = NULL;
for (int i = 0; i < len; i++) {
if (tokens[i].token == Not)
invertValue = !invertValue;
else if (tokens[i].token == ArrayVariableAssignment || tokens[i].token == VariableAssignment) {
varToken = &tokens[i];
if (tokens[i].token == ArrayVariableAssignment) {
int distance = distanceBetweenTokens(&tokens[i] + 2, len, LSBracket, RSBracket);
i += distance + 2;
}
}
else if (tokens[i].token >= Variable && tokens[i].token <= LSBracket) {
Variable_t val = getVarFromToken(ctx, tokens, &i, len - i);
if (val.varType == ErrType)
return val;
if (val.varType == IntType && invertValue) {
val.integerType = !val.integerType;
}
invertValue = 0;
if (lastToken) {
u16 localOpToken = lastToken; // do we need local op token?
lastToken = 0;
if (matchTypes(res, val, IntType)) {
if (localOpToken == Plus)
res.integerType += val.integerType;
ELIFT(Minus)
res.integerType -= val.integerType;
ELIFT(Multiply)
res.integerType *= val.integerType;
ELIFT(Division) {
if (!val.integerType)
res = ErrValue(ERRDIVBYZERO);
else
res.integerType = res.integerType / val.integerType;
}
ELIFT(Mod)
res.integerType %= val.integerType;
ELIFT(Smaller)
res.integerType = res.integerType < val.integerType;
ELIFT(SmallerEqual)
res.integerType = res.integerType <= val.integerType;
ELIFT(Bigger)
res.integerType = res.integerType > val.integerType;
ELIFT(BiggerEqual)
res.integerType = res.integerType >= val.integerType;
ELIFT(EqualEqual)
res.integerType = res.integerType == val.integerType;
ELIFT(NotEqual)
res.integerType = res.integerType != val.integerType;
ELIFT(LogicAND) {
res.integerType = res.integerType && val.integerType;
if (!res.integerType)
break;
}
ELIFT(LogicOR) {
res.integerType = res.integerType || val.integerType;
if (res.integerType)
break;
}
ELIFT(AND)
res.integerType = res.integerType & val.integerType;
ELIFT(OR)
res.integerType = res.integerType | val.integerType;
else
return ErrValue(ERRBADOPERATOR);
}
else if (matchTypes(res, val, StringType)) {
if (localOpToken == Plus) {
char* buff = calloc(strlen(res.stringType) + strlen(val.stringType) + 1, 1);
strcpy(buff, res.stringType);
strcat(buff, val.stringType);
if (res.free) free(res.stringType); // we should replace these with variablefree
if (val.free) free(val.stringType);
res.stringType = buff;
res.free = 1;
}
ELIFT(EqualEqual) {
res.typeUnion = IntType;
int compRes = !strcmp(res.stringType, val.stringType);
if (res.free) free(res.stringType);
if (val.free) free(val.stringType);
res.integerType = compRes;
res.free = 0;
}
ELIFT(Minus) {
if (!strcmp(res.stringType + strlen(res.stringType) - strlen(val.stringType), val.stringType)) {
*(res.stringType + strlen(res.stringType) - strlen(val.stringType)) = 0;
}
if (val.free) free(val.stringType);
}
ELIFT(Division) {
int valLen = strlen(val.stringType);
if (!valLen) {
res = ErrValue(ERRSYNTAX);
continue;
}
char* start = res.stringType;
char* find = NULL;
//char** arr = malloc(20); // should be dynamic
Vector_t arr = newVec(sizeof(char**), 10);
char* temp;
while ((find = (strstr(start, val.stringType))) != NULL) {
temp = utils_copyStringSize(start, find - start);
vecAddElement(&arr, temp);
start = find + valLen;
}
temp = utils_copyStringSize(start, res.stringType + strlen(res.stringType) - start);
vecAddElement(&arr, temp);
if (res.free) free(res.stringType); // do we free here?
if (val.free) free(val.stringType);
res.varType = StringArrayType;
res.free = 1;
res.vectorType = arr;
}
else
return ErrValue(ERRBADOPERATOR);
}
else if ((res.varType == IntArrayType || res.varType == ByteArrayType) && val.varType == IntType) {
if (localOpToken == Plus) {
Vector_t newV = vecCopy(&res.vectorType);
freeVariable(res);
res.vectorType = newV;
res.free = 1;
if (res.varType == IntArrayType)
vecAddElement(&res.vectorType, val.integerType);
else {
u8 in = ((u8)val.integerType & 0xFF);
vecAddElement(&res.vectorType, in);
}
}
}
else
return ErrValue(ERRBADOPERATOR);
}
else {
res = val;
}
}
else if (tokens[i].token >= Plus && tokens[i].token <= OR) {
lastToken = tokens[i].token;
}
}
if (varToken != NULL) {
if (varToken->token == VariableAssignment) {
dict_t newVar = newDict(CpyStr(varToken->text), res);
dictVectorAdd(&ctx->varDict, newVar);
}
else {
Variable_t* var = dictVectorFind(&ctx->varDict, varToken->text);
if (var != NULL) {
if (var->varType - 2 == res.varType || (var->varType == ByteArrayType && res.varType == IntType)) {
int distance = distanceBetweenTokens(varToken + 2, len, LSBracket, RSBracket);
if (distance < 0) {
// ERR
return ErrValue(ERRSYNTAX);
}
Variable_t index = solveEquation(ctx, varToken + 2, distance, 0);
if (index.varType != IntType) {
// ERR
}
else if (index.integerType < 0 || var->vectorType.count <= index.integerType) {
// ERR
}
else {
if (var->varType == IntArrayType) {
int* arr = vecGetArray(int*, var->vectorType);
arr[index.integerType] = res.integerType;
}
else if (var->varType == StringArrayType) {
char** arr = vecGetArray(char**, var->vectorType);
arr[index.integerType] = CpyStr(res.stringType);
}
else if (var->varType == ByteArrayType) {
u8* arr = vecGetArray(u8*, var->vectorType);
arr[index.integerType] = res.integerType & 0xFF;
}
}
}
else {
// ERR
}
}
else {
//ERR
}
}
}
else {
if (shouldFree) // we should get rid of this ugly free. why not set .free to 0 when assigning it then free in parser.c?
freeVariable(res);
}
return res;
}

7
source/script/args.h Normal file
View file

@ -0,0 +1,7 @@
#pragma once
#include "types.h"
char* utils_copyStringSize(const char* in, int size);
Variable_t solveEquation(scriptCtx_t* ctx, lexarToken_t* tokens, u32 len, u8 shouldFree);
int distanceBetweenTokens(lexarToken_t* tokens, u32 len, int openToken, int closeToken);
Vector_t extractVars(scriptCtx_t* ctx, lexarToken_t* tokens, u32 len);

134
source/script/functions.c Normal file
View file

@ -0,0 +1,134 @@
#include "types.h"
#include "args.h"
#include "variables.h"
#include <string.h>
#include "../gfx/gfx.h"
#include <mem/heap.h>
#include "lexer.h"
#define scriptFunction(name) Variable_t name(scriptCtx_t *ctx, Variable_t *vars, u32 varLen)
scriptFunction(funcIf) {
setCurIndentInstruction(ctx, (vars[0].integerType == 0), 0, -1);
return NullVar;
}
scriptFunction(funcPrint) {
for (u32 i = 0; i < varLen; i++) {
if (vars[i].varType == IntType)
gfx_printf("%d", vars[i].integerType);
else if (vars[i].varType == StringType)
gfx_printf("%s", vars[i].stringType);
else if (vars[i].varType == IntArrayType) {
gfx_printf("[");
int* v = vecGetArray(int*, vars[i].vectorType);
for (u32 j = 0; j < vars[i].vectorType.count; j++)
gfx_printf((j + 1 == vars[i].vectorType.count) ? "%d" : "%d, ", v[j]);
gfx_printf("]");
}
}
return NullVar;
}
scriptFunction(funcPrintln) {
funcPrint(ctx, vars, varLen);
gfx_printf("\n");
return NullVar;
}
scriptFunction(funcWhile) {
setCurIndentInstruction(ctx, (vars[0].integerType == 0), 0, ctx->startEquation);
return NullVar;
}
scriptFunction(funcElse) {
indentInstructor_t* curInstruction = getCurIndentInstruction(ctx);
setCurIndentInstruction(ctx, !curInstruction->skip, 0, -1);
return NullVar;
}
scriptFunction(funcLen) {
if (vars[0].varType >= IntArrayType && vars[0].varType <= ByteArrayType)
return IntVal(vars[0].vectorType.count);
else if (vars[0].varType == StringType) {
if (vars[0].stringType != NULL)
return IntVal(strlen(vars[0].stringType));
}
return ErrVar(ERRINVALIDTYPE);
}
scriptFunction(funcMakeByteArray){
u8 *buff = malloc(vars[0].vectorType.count);
vecDefArray(int*, entries, vars[0].vectorType);
for (int i = 0; i < vars[0].vectorType.count; i++)
buff[i] = (u8)(entries[i] & 0xFF);
Vector_t v = vecFromArray(buff, vars[0].vectorType.count, sizeof(u8));
return newVar(ByteArrayType, 1, .vectorType = v);
}
u8 singleIntArray[] = { IntArrayType };
u8 singleInt[] = { IntType };
u8 singleAny[] = { varArgs };
functionStruct_t scriptFunctions[] = {
{"if", funcIf, 1, singleInt},
{"print", funcPrint, varArgs, NULL},
{"println", funcPrintln, varArgs, NULL},
{"while", funcWhile, 1, singleInt},
{"else", funcElse, 0, NULL},
{"len", funcLen, 1, singleAny},
{"byte", funcMakeByteArray, 1, singleIntArray},
};
Variable_t executeFunction(scriptCtx_t* ctx, char* func_name, lexarToken_t *start, u32 len) {
Vector_t args = { 0 };
if (len > 0) {
args = extractVars(ctx, start, len);
Variable_t* vars = vecGetArray(Variable_t*, args);
for (int i = 0; i < args.count; i++) {
if (vars[i].varType == ErrType)
return vars[i];
}
}
Variable_t* vars = vecGetArray(Variable_t*, args);
for (u32 i = 0; i < ARRAY_SIZE(scriptFunctions); i++) {
if (scriptFunctions[i].argCount == args.count || scriptFunctions[i].argCount == varArgs) {
if (!strcmp(scriptFunctions[i].key, func_name)) {
if (scriptFunctions[i].argCount != varArgs && scriptFunctions[i].argCount != 0) {
u8 argsMatch = 1;
for (u32 j = 0; j < args.count; j++) {
if (vars[j].varType != scriptFunctions[i].typeArray[j] && scriptFunctions[i].typeArray[j] != varArgs) {
argsMatch = 0;
break;
}
}
if (!argsMatch)
continue;
}
Variable_t ret = scriptFunctions[i].value(ctx, vars, args.count);
freeVariableVector(&args);
return ret;
}
}
}
Variable_t* var = dictVectorFind(&ctx->varDict, func_name);
if (var != NULL) {
if (var->varType == JumpType) {
setCurIndentInstruction(ctx, 0, 1, ctx->curPos);
ctx->curPos = var->integerType - 1;
return NullVar;
}
}
return ErrVar(ERRNOFUNC);
}

View file

@ -0,0 +1,4 @@
#pragma once
#include "variables.h"
Variable_t executeFunction(scriptCtx_t* ctx, char* func_name, lexarToken_t* start, u32 len);

269
source/script/lexer.c Normal file
View file

@ -0,0 +1,269 @@
#include "lexer.h"
#include "types.h"
#include "args.h"
#include <mem/heap.h>
static inline int isValidWord(char c) {
char r = c | 0x20;
return ((r >= 'a' && r <= 'z') || c == '_');
}
static inline int isValidNum(char c) {
return (c >= '0' && c <= '9');
}
static inline int isValidVar(char c) {
return (isValidWord(c) || isValidNum(c));
}
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})
typedef struct {
u8 tokenC;
u8 tokenN;
} lexarTranslation_t;
lexarTranslation_t lexarTranslations[] = {
{'}', RCBracket},
{',', Seperator},
{'+', Plus},
{'-', Minus},
{'*', Multiply},
{'/', Division},
{'%', Mod},
{'<', Smaller},
{'>', Bigger},
{'!', Not},
{')', RBracket},
{']', RSBracket},
{'(', LBracket},
{'{', LCBracket},
{'=', Equal},
{'[', LSBracket},
{'\0', 0},
};
/*
Should we make vars with next char being '(' a function and vars with an equals (or [x] wait how are we gonna spot that) after it to be an assignmentVar
*/
char lexarDebugGetTokenC(u8 tokenN) {
for (int i = 0; lexarTranslations[i].tokenC; i++) {
if (lexarTranslations[i].tokenN == tokenN) {
return lexarTranslations[i].tokenC;
}
}
if (tokenN == EquationSeperator)
return ';';
return '?';
}
/*
* !! we need to remake this
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);
}
*/
void lexarVectorClear(Vector_t *v){
vecPDefArray(lexarToken_t*, entries, v);
for (int i = 0; i < v->count; i++){
if (entries[i].token != IntLit && entries[i].text != NULL){
free(entries[i].text);
}
}
vecFreePtr(v);
}
#define ELIFC(c) else if (*in == c)
Vector_t runLexar(const char* in, u32 len) {
const char *start = in;
Vector_t vec = newVec(sizeof(lexarToken_t), 16);
// store last var for re-assignment
// var -> func if next obj is '('
// var -> assignment if next obj is '='
// var -> arrassignment if next obj is '[' and before '=' is ']'
// maybe measure len between ( ) and [ ], so this doesn't have to be done during runtime?
// We also have to support (()). maybe if '(' set indent level, then if ')' minus indent level, set len. indent level contains {u8 level, u16 token, u16 startoffset}
while ((in - start) < len) {
lexarToken_t* lx = vecGetArray(lexarToken_t*, vec);
if ((lx[vec.count - 2].token == StrLit || lx[vec.count - 2].token == IntLit || lx[vec.count - 2].token == Variable || lx[vec.count - 2].token == RSBracket || lx[vec.count - 2].token == RBracket)
&& (lx[vec.count - 1].token == Variable || lx[vec.count - 1].token == LCBracket || lx[vec.count - 1].token == RCBracket)) {
lexarToken_t holder = lx[vec.count - 1];
lx[vec.count - 1] = makeLexarToken(EquationSeperator, 0);
vecAddElement(&vec, holder);
lx = vecGetArray(lexarToken_t*, vec);
}
if (isValidWord(*in)) {
char* startWord = in;
in++;
while (isValidVar(*in))
in++;
vecAddElement(&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;
vecAddElement(&vec, makeLexarToken(IntLit, parse));
continue;
}
ELIFC('(') {
if (lx[vec.count - 1].token == Variable)
lx[vec.count - 1].token = Function;
vecAddElement(&vec, makeLexarToken(LBracket, 0));
}
ELIFC('[') {
if (lx[vec.count - 1].token == Variable)
lx[vec.count - 1].token = ArrayVariable;
vecAddElement(&vec, makeLexarToken(LSBracket, 0));
}
ELIFC('=') { // Do we need to keep = if the vars are assignments anyway?
if (lx[vec.count - 1].token == Variable)
lx[vec.count - 1].token = VariableAssignment;
else if (lx[vec.count - 1].token == RSBracket) {
int back = 1;
while (lx[vec.count - back].token != ArrayVariable) {
back++;
if (vec.count - back < 0)
break; // major error
}
if (lx[vec.count - back].token == ArrayVariable) {
lx[vec.count - back].token = ArrayVariableAssignment;
}
}
}
ELIFC('{') {
if (lx[vec.count - 1].token == VariableAssignment) {
lx[vec.count - 1].token = FunctionAssignment;
}
vecAddElement(&vec, makeLexarToken(LCBracket, 0));
}
ELIFC('"') {
char* startStr = ++in;
int len = 0;
while (*in != '"') {
in++;
}
len = in - startStr;
char* storage = malloc(len + 1);
int pos = 0;
for (int i = 0; i < len; i++) {
if (startStr[i] == '\\') {
if (startStr[i + 1] == 'n') {
storage[pos++] = '\n';
i++;
continue;
}
if (startStr[i + 1] == 'r') {
storage[pos++] = '\r';
i++;
continue;
}
}
storage[pos++] = startStr[i];
}
storage[pos] = '\0';
vecAddElement(&vec, makeLexarToken(StrLit, storage));
}
ELIFC('#') {
while (*in != '\n')
in++;
}
ELIFC('&') {
if (in[1] == '&') {
vecAddElement(&vec, makeLexarToken(LogicAND, 0));
in++;
}
else {
vecAddElement(&vec, makeLexarToken(AND, 0));
}
}
ELIFC('|') {
if (in[1] == '|') {
vecAddElement(&vec, makeLexarToken(LogicOR, 0));
in++;
}
else {
vecAddElement(&vec, makeLexarToken(OR, 0));
}
}
else {
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)
vecAddElement(&vec, makeLexarToken(val, 0));
continue;
}
in++;
}
lexarToken_t* lx = vecGetArray(lexarToken_t*, vec);
if ((lx[vec.count - 2].token == StrLit || lx[vec.count - 2].token == IntLit || lx[vec.count - 2].token == Variable || lx[vec.count - 2].token == RSBracket || lx[vec.count - 2].token == RBracket)
&& (lx[vec.count - 1].token == Variable || lx[vec.count - 1].token == LCBracket || lx[vec.count - 1].token == RCBracket)) {
lexarToken_t holder = lx[vec.count - 1];
lx[vec.count - 1] = makeLexarToken(EquationSeperator, 0);
vecAddElement(&vec, holder);
}
vecAddElement(&vec, makeLexarToken(EquationSeperator, 0));
return vec;
}

6
source/script/lexer.h Normal file
View file

@ -0,0 +1,6 @@
#pragma once
#include "types.h"
Vector_t runLexar(const char* in, u32 len);
char lexarDebugGetTokenC(u8 tokenN);
void lexarVectorClear(Vector_t *v);

109
source/script/parser.c Normal file
View file

@ -0,0 +1,109 @@
#include "args.h"
#include "types.h"
#include "variables.h"
#include "lexer.h"
#include "../gfx/gfx.h"
#include "../utils/utils.h"
#include <mem/heap.h>
#define scriptResultCreate(resCode, nearToken) (scriptResult_t) {resCode, nearToken, 1}
#define scriptResultCreateLen(resCode, nearToken, len) (scriptResult_t) {resCode, nearToken, len}
scriptResult_t runFunction(scriptCtx_t* ctx, u32 len) {
lexarToken_t* tokens = vecGetArray(lexarToken_t*, ctx->script);
Variable_t res = solveEquation(ctx, &tokens[ctx->startEquation], len, 1);
if (res.varType == ErrType) {
return scriptResultCreateLen(res.integerType, &tokens[ctx->startEquation], len);
}
return scriptResultCreate(0, 0);
}
#define RUNFUNCWITHPANIC(ctx, len) scriptResult_t res = runFunction(ctx, len); if (res.resCode != 0) return res
static inline int checkIfVar(u8 token) {
return (token == StrLit || token == IntLit || token == Variable || token == RSBracket || token == ArrayVariable);
}
scriptResult_t mainLoop(scriptCtx_t* ctx) {
ctx->startEquation = 0;
lexarToken_t* lexArr = vecGetArray(lexarToken_t*, ctx->script);
for (ctx->curPos = 0; ctx->curPos < ctx->script.count; ctx->curPos++) {
u32 i = ctx->curPos;
lexarToken_t curToken = lexArr[i];
if (curToken.token == EquationSeperator) {
RUNFUNCWITHPANIC(ctx, ctx->curPos - ctx->startEquation);
ctx->startEquation = ctx->curPos + 1;
}
else if (curToken.token == FunctionAssignment) {
setCurIndentInstruction(ctx, 1, 0, -1);
dict_t x = newDict(CpyStr(curToken.text), newVar(JumpType, 0, .integerType = ctx->curPos + 1));
vecAddElement(&ctx->varDict, x);
}
else if (curToken.token == LCBracket) {
indentInstructor_t* ins = getCurIndentInstruction(ctx);
if (ins->active) {
if (ins->skip) {
int distance = distanceBetweenTokens(&lexArr[i + 1], ctx->script.count - i - 1, LCBracket, RCBracket);
if (distance < 0)
return scriptResultCreate(ERRSYNTAX, &lexArr[i]);
ctx->curPos += distance + 1;
}
else
ctx->indentIndex++;
}
else
return scriptResultCreate(ERRINACTIVEINDENT, &lexArr[i]);
ctx->startEquation = ctx->curPos + 1;
}
else if (curToken.token == RCBracket) {
ctx->indentIndex--;
indentInstructor_t* ins = getCurIndentInstruction(ctx);
if (ins->active && ins->jump) {
ctx->curPos = ins->jumpLoc - 1;
}
ins->active = 0;
ctx->startEquation = ctx->curPos + 1;
}
}
return scriptResultCreate(0, 0);
}
void printToken(lexarToken_t* token) {
switch (token->token) {
case Variable:
case VariableAssignment:
case Function:
case FunctionAssignment:
case ArrayVariable:
case ArrayVariableAssignment:
gfx_printf("%s", token->text);
break;
case StrLit:
//printf("%d: '%s'\n", vec.tokens[i].token, vec.tokens[i].text);
gfx_printf("\"%s\"", token->text);
break;
case IntLit:
//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;
}
}
void printError(scriptResult_t res) {
if (res.resCode) {
gfx_printf("Error %d found!\nNear: ", res.resCode);
for (int i = 0; i < res.len; i++) {
printToken(&res.nearToken[i]);
}
}
}

6
source/script/parser.h Normal file
View file

@ -0,0 +1,6 @@
#pragma once
#include "types.h"
scriptResult_t mainLoop(scriptCtx_t* ctx);
void printError(scriptResult_t res);

140
source/script/types.h Normal file
View file

@ -0,0 +1,140 @@
#pragma once
#include <utils/types.h>
#include "../utils/vector.h"
enum Tokens {
Invalid = 0,
Variable = 1,
ArrayVariable,
Function,
LBracket,
StrLit,
IntLit,
LSBracket,
VariableAssignment,
ArrayVariableAssignment,
FunctionAssignment,
RBracket,
RCBracket,
LCBracket,
Seperator,
Plus,
Minus,
Multiply,
Division,
Mod,
Smaller,
SmallerEqual,
Bigger,
BiggerEqual,
Equal,
EqualEqual,
Not,
NotEqual,
LogicAND,
LogicOR,
RSBracket,
AND,
OR,
EquationSeperator,
};
typedef struct {
u8 token;
union {
char* text;
int val;
};
} lexarToken_t;
enum Errors {
ERRBADOPERATOR = 1,
ERRDOUBLENOT,
ERRSYNTAX,
ERRINVALIDTYPE,
ERRNOVAR,
ERRNOFUNC,
ERRINACTIVEINDENT,
ERRDIVBYZERO
};
enum Variables {
IntType = 0,
StringType,
IntArrayType,
StringArrayType,
ByteArrayType,
JumpType,
DictType,
NullType,
ErrType,
};
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 function : 1;
};
u8 container;
};
int jumpLoc;
} indentInstructor_t;
typedef struct {
union {
struct {
u8 varType : 7;
u8 free : 1;
};
u8 typeUnion;
};
union {
int integerType;
char* stringType;
Vector_t vectorType;
};
} Variable_t;
typedef struct {
char* key;
Variable_t value;
} dict_t;
typedef struct {
Vector_t indentInstructors; // Type indentInstructor_t
Vector_t varDict; // Type dict_t
Vector_t script; // Type lexarToken_t
u32 startEquation;
u32 curPos;
u8 indentIndex;
} scriptCtx_t;
typedef Variable_t(*func_int_ptr)(scriptCtx_t* ctx, Variable_t *vars, u32 len);
typedef struct {
char* key;
func_int_ptr value;
u8 argCount;
u8* typeArray;
} functionStruct_t;
typedef struct {
int resCode;
lexarToken_t* nearToken;
u32 len;
} scriptResult_t;
#define newDict(strName, var) (dict_t) {strName, var}
#define newVar(var, frii, value) (Variable_t) {.varType = var, .free = frii, value}
#define varArgs 255
#define NullVar newVar(NullType, 0, 0)
#define ErrVar(err) newVar(ErrType, 0, err)
#define IntVal(val) newVar(IntType, 0, val)

105
source/script/variables.c Normal file
View file

@ -0,0 +1,105 @@
#include "variables.h"
#include "types.h"
#include <string.h>
#include <mem/heap.h>
void freeVariable(Variable_t dv) {
if (!dv.free)
return;
switch (dv.varType) {
case StringType:
FREE(dv.stringType);
break;
case StringArrayType:;
char** strArray = vecGetArray(char**, dv.vectorType);
for (u32 i = 0; i < dv.vectorType.count; i++){
FREE(strArray[i]);
}
case IntArrayType:
case ByteArrayType:
vecFree(dv.vectorType);
break;
}
}
void freeVariableVector(Vector_t *v) {
Variable_t* vars = vecGetArrayPtr(v, Variable_t*);
for (int i = 0; i < v->count; i++) {
freeVariable(vars[i]);
}
vecFreePtr(v);
}
void freeDictVector(Vector_t *v) {
dict_t* dic = vecGetArrayPtr(v, dict_t*);
for (int i = 0; i < v->count; i++) {
FREE(dic[i].key);
freeVariable(dic[i].value);
}
vecFreePtr(v);
}
Variable_t* dictVectorFind(Vector_t* v, const char* key) {
dict_t* dic = vecGetArrayPtr(v, dict_t*);
for (int i = 0; i < v->count; i++) {
if (!strcmp(dic[i].key, key))
return &dic[i].value;
}
return NULL;
}
void dictVectorAdd(Vector_t* v, dict_t add) {
if (add.key == NULL)
return;
Variable_t* var = dictVectorFind(v, add.key);
if (var != NULL) {
if ((var->varType >= StringType && var->varType <= ByteArrayType && var->varType == add.value.varType) && (add.value.stringType == var->stringType || add.value.vectorType.data == var->vectorType.data))
return;
freeVariable(*var);
*var = add.value;
free(add.key);
return;
}
else {
vecAddElement(v, add);
}
}
scriptCtx_t createScriptCtx() {
scriptCtx_t s = {
.indentInstructors = newVec(sizeof(indentInstructor_t), 64),
.varDict = newVec(sizeof(dict_t), 8),
.startEquation = 0,
.curPos = 0
};
return s;
}
// We should rewrite this to actually use the vector!
u8 setIndentInstruction(scriptCtx_t* ctx, u8 level, u8 skip, u8 func, int jumpLoc) {
if (level >= 64)
return 1;
indentInstructor_t* instructors = vecGetArray(indentInstructor_t*, ctx->indentInstructors);
indentInstructor_t* instructor = &instructors[level];
instructor->skip = skip;
instructor->active = 1;
instructor->function = func;
instructor->jump = (jumpLoc >= 0) ? 1 : 0;
instructor->jumpLoc = jumpLoc;
return 0;
}
indentInstructor_t* getCurIndentInstruction(scriptCtx_t* ctx) {
indentInstructor_t* instructors = vecGetArray(indentInstructor_t*, ctx->indentInstructors);
return &instructors[ctx->indentIndex];
}

16
source/script/variables.h Normal file
View file

@ -0,0 +1,16 @@
#pragma once
#include "types.h"
void dictVectorAdd(Vector_t* v, dict_t add);
Variable_t* dictVectorFind(Vector_t* v, const char* key);
void freeDictVector(Vector_t* v);
void freeVariableVector(Vector_t* v);
void freeVariable(Variable_t dv);
scriptCtx_t createScriptCtx();
u8 setIndentInstruction(scriptCtx_t* ctx, u8 level, u8 skip, u8 func, int jumpLoc);
indentInstructor_t* getCurIndentInstruction(scriptCtx_t* ctx);
static inline u8 setCurIndentInstruction(scriptCtx_t* ctx, u8 skip, u8 func, int jumpLoc) {
return setIndentInstruction(ctx, ctx->indentIndex, skip, func, jumpLoc);
}

View file

@ -45,4 +45,11 @@ bool vecAdd(Vector_t* v, void* elem, u32 sz)
memcpy((char*)v->data + usedbytes, elem, sz);
v->count++;
return true;
}
Vector_t vecCopy(Vector_t* orig) {
Vector_t dst = newVec(orig->elemSz, orig->count);
memcpy(dst.data, orig->data, orig->count * orig->elemSz);
dst.count = orig->count;
return dst;
}

View file

@ -9,12 +9,21 @@ typedef struct {
// u32 typeTag;
} Vector_t;
#define FREE(x) free(x); x = NULL;
#define vecAddElem(v, elem) vecAdd(v, &elem, sizeof(elem))
#define vecAddElement(v, elem) vecAdd(v, &elem, sizeof(elem))
#define vecDefArray(type, varName, vec) type varName = (type)((vec).data)
#define vecGetArray(type, vec) (type)((vec).data)
#define vecPDefArray(type, varName, vec) type varName = (type)((vec)->data)
#define vecPGetArray(type, vec) (type)((vec)->data)
#define vecFreePtr(vec) FREE(vec->data)
#define vecFree(vec) FREE(vec.data)
#define vecGetCapacity(vec) (vec.capacity / vec.elemSz)
#define vecGetArrayPtr(vec, type) (type)((vec)->data)
Vector_t newVec(u32 typesz, u32 preallocate);
Vector_t vecFromArray(void* array, u32 count, u32 typesz);
bool vecAdd(Vector_t* v, void* elem, u32 sz);
bool vecAdd(Vector_t* v, void* elem, u32 sz);
Vector_t vecCopy(Vector_t* orig);