berkus
/
essence-os
mirror of https://gitlab.com/nakst/essence
1
0
Fork 0
Code Releases Activity
essence-os/util/script.c

8001 lines
288 KiB
C
Raw Blame History

// TODO Basic missing features:
// - Maps: T[int], T[str].
// - Control flow: break, continue.
// - Other operators: integer modulo.
// - Named optional arguments with default values.
// - Using declared types from imported modules.
// - struct inheritance.
// TODO Syntax sugar: (ideas)
// - Pipe operator? e.g. <e := expression> | <f := function pointer> (...) ==> f(e, ...)
// - Dot operator for functions? e.g. <f := function pointer> . ==> f()
// TODO Larger missing features:
// - Serialization.
// - Debugging.
// - Verbose mode, where every external call is logged, every variable modification is logged, every line is logged, etc? Saving output to file.
// - Saving and showing the stack trace of where T_ERR values were created in assertion failure messages.
// TODO Cleanup:
// - Cleanup the code in External- functions and ScriptExecuteFunction using macros for common stack and heap operations.
// - Cleanup the ImportData/ExecutionContext/FunctionBuilder structures and their relationships.
// - Cleanup the variables/stack arrays.
// - Cleanup the platform layer.
// TODO Safety:
// - Safety against extremely large scripts?
// - Loading untrusted bytecode files?
// TODO Miscellaneous:
// - Inlining small strings.
// - Exponent notation in numeric literals.
// - Block comments.
// - More escape sequences in string literals.
// - Setting the initial values of global variables.
// - Better handling of memory allocation failures.
// - Operation arguments are evaluated in the opposite order to functions?
// - Shrink lists during garbage collection.
#include <stdint.h>
#include <stddef.h>
#include <stdbool.h>
#define FUNCTION_MAX_ARGUMENTS (20) // Also the maximum number of return values in a tuple.
#define EXTCALL_NO_RETURN (1)
#define EXTCALL_RETURN_UNMANAGED (2)
#define EXTCALL_RETURN_MANAGED (3)
#define EXTCALL_START_COROUTINE (4)
#define EXTCALL_RETURN_ERR_UNMANAGED (5)
#define EXTCALL_RETURN_ERR_MANAGED (6)
#define EXTCALL_RETURN_ERR_ERROR (7)
#define T_ERROR (0)
#define T_EOF (1)
#define T_IDENTIFIER (2)
#define T_STRING_LITERAL (3)
#define T_NUMERIC_LITERAL (4)
#define T_ADD (20)
#define T_MINUS (21)
#define T_ASTERISK (22)
#define T_SLASH (23)
#define T_NEGATE (24)
#define T_LEFT_ROUND (25)
#define T_RIGHT_ROUND (26)
#define T_LEFT_SQUARE (27)
#define T_RIGHT_SQUARE (28)
#define T_LEFT_FANCY (29)
#define T_RIGHT_FANCY (30)
#define T_COMMA (31)
#define T_EQUALS (32)
#define T_SEMICOLON (33)
#define T_GREATER_THAN (34)
#define T_LESS_THAN (35)
#define T_GT_OR_EQUAL (36)
#define T_LT_OR_EQUAL (37)
#define T_DOUBLE_EQUALS (38)
#define T_NOT_EQUALS (39)
#define T_LOGICAL_AND (40)
#define T_LOGICAL_OR (41)
#define T_ADD_EQUALS (42)
#define T_MINUS_EQUALS (43)
#define T_ASTERISK_EQUALS (44)
#define T_SLASH_EQUALS (45)
#define T_DOT (46)
#define T_COLON (47)
#define T_LOGICAL_NOT (48)
#define T_BIT_SHIFT_LEFT (49)
#define T_BIT_SHIFT_RIGHT (50)
#define T_BITWISE_OR (51)
#define T_BITWISE_AND (52)
#define T_BITWISE_NOT (53)
#define T_BITWISE_XOR (54)
#define T_ROOT (70)
#define T_FUNCBODY (71)
#define T_ARGUMENTS (72)
#define T_ARGUMENT (73)
#define T_FUNCTION (74)
#define T_BLOCK (75)
#define T_VARIABLE (76)
#define T_CALL (77)
#define T_DECLARE (78)
#define T_FUNCPTR (79)
#define T_STR_INTERPOLATE (80)
#define T_INDEX (81)
#define T_LIST (82)
#define T_IMPORT_PATH (83)
#define T_LIST_LITERAL (84)
#define T_REPL_RESULT (85)
#define T_RETURN_TUPLE (86)
#define T_DECLARE_GROUP (87)
#define T_DECL_GROUP_AND_SET (88)
#define T_SET_GROUP (89)
#define T_FOR_EACH (90)
#define T_ERR_CAST (91)
#define T_IF_ERR (92)
#define T_INTTYPE_CONSTANT (93)
#define T_ANYTYPE_CAST (94)
#define T_CAST_TYPE_WRAPPER (95)
#define T_ZERO (96)
#define T_PLACEHOLDER (97)
#define T_EXIT_SCOPE (100)
#define T_END_FUNCTION (101)
#define T_POP (102)
#define T_BRANCH (103)
#define T_CONCAT (104)
#define T_INTERPOLATE_STR (105)
#define T_INTERPOLATE_BOOL (106)
#define T_INTERPOLATE_INT (107)
#define T_INTERPOLATE_FLOAT (108)
#define T_DUP (109)
#define T_SWAP (110)
#define T_INTERPOLATE_ILIST (111)
#define T_ROT3 (112)
#define T_LIBCALL (113)
#define T_END_CALLBACK (114)
#define T_FLOAT_ADD (120)
#define T_FLOAT_MINUS (121)
#define T_FLOAT_ASTERISK (122)
#define T_FLOAT_SLASH (123)
#define T_FLOAT_NEGATE (124)
#define T_FLOAT_GREATER_THAN (125)
#define T_FLOAT_LESS_THAN (126)
#define T_FLOAT_GT_OR_EQUAL (127)
#define T_FLOAT_LT_OR_EQUAL (128)
#define T_FLOAT_DOUBLE_EQUALS (129)
#define T_FLOAT_NOT_EQUALS (130)
#define T_STR_DOUBLE_EQUALS (131)
#define T_STR_NOT_EQUALS (132)
#define T_EQUALS_DOT (133)
#define T_EQUALS_LIST (134)
#define T_INDEX_LIST (135)
#define T_OP_RESIZE (140)
#define T_OP_ADD (141)
#define T_OP_INSERT (142)
#define T_OP_INSERT_MANY (143)
#define T_OP_DELETE (144)
#define T_OP_DELETE_MANY (145)
#define T_OP_DELETE_LAST (146)
#define T_OP_DELETE_ALL (147)
#define T_OP_FIRST (148)
#define T_OP_LAST (149)
#define T_OP_LEN (150)
#define T_OP_DISCARD (151)
#define T_OP_ASSERT (152)
#define T_OP_CURRY (153)
#define T_OP_ASYNC (154)
#define T_OP_FIND_AND_DELETE (155)
#define T_OP_FIND (156)
#define T_OP_FIND_AND_DEL_STR (157)
#define T_OP_FIND_STR (158)
#define T_OP_ASSERT_ERR (159)
#define T_OP_SUCCESS (160)
#define T_OP_ERROR (161)
#define T_OP_DEFAULT (162)
#define T_OP_INT_TO_FLOAT (163)
#define T_OP_FLOAT_TRUNCATE (164)
#define T_OP_CAST (165)
#define T_IF (170)
#define T_WHILE (171)
#define T_FOR (172)
#define T_INT (173)
#define T_FLOAT (174)
#define T_BOOL (175)
#define T_VOID (176)
#define T_RETURN (177)
#define T_ELSE (178)
#define T_EXTCALL (179)
#define T_STR (180)
#define T_FUNCTYPE (181)
#define T_NULL (182)
#define T_FALSE (183)
#define T_TRUE (184)
#define T_ASSERT (185)
#define T_PERSIST (186)
#define T_STRUCT (187)
#define T_NEW (188)
#define T_OPTION (189)
#define T_IMPORT (190)
#define T_INLINE (191)
#define T_AWAIT (192)
#define T_TUPLE (193)
#define T_IN (194)
#define T_ERR (195)
#define T_SUCCESS (196)
#define T_RETERR (197)
#define T_INTTYPE (198)
#define T_HANDLETYPE (199)
#define T_ANYTYPE (200)
#define T_LIBRARY (201)
#define STACK_READ_STRING(textVariable, bytesVariable, stackIndex) \
if (context->c->stackPointer < stackIndex) return -1; \
if (!context->c->stackIsManaged[context->c->stackPointer - stackIndex]) return -1; \
uint64_t _index ## stackIndex = context->c->stack[context->c->stackPointer - stackIndex].i; \
if (context->heapEntriesAllocated <= _index ## stackIndex) return -1; \
HeapEntry *_entry ## stackIndex = &context->heap[_index ## stackIndex]; \
if (_entry ## stackIndex->type != T_EOF && _entry ## stackIndex->type != T_STR && _entry ## stackIndex->type != T_CONCAT) return -1; \
const char *textVariable; \
size_t bytesVariable; \
ScriptHeapEntryToString(context, _entry ## stackIndex, &textVariable, &bytesVariable);
#define STACK_POP_STRING(textVariable, bytesVariable) \
STACK_READ_STRING(textVariable, bytesVariable, 1); \
context->c->stackPointer--;
#define STACK_POP_STRING_2(textVariable1, bytesVariable1, textVariable2, bytesVariable2) \
STACK_READ_STRING(textVariable1, bytesVariable1, 1); \
STACK_READ_STRING(textVariable2, bytesVariable2, 2); \
context->c->stackPointer -= 2;
#define RETURN_STRING_COPY(_text, _bytes) \
returnValue->i = HeapAllocate(context); \
context->heap[returnValue->i].type = T_STR; \
context->heap[returnValue->i].bytes = _bytes; \
context->heap[returnValue->i].text = (char *) AllocateResize(NULL, context->heap[returnValue->i].bytes); \
MemoryCopy(context->heap[returnValue->i].text, _text, context->heap[returnValue->i].bytes);
#define RETURN_STRING_NO_COPY(_text, _bytes) \
returnValue->i = HeapAllocate(context); \
context->heap[returnValue->i].type = T_STR; \
context->heap[returnValue->i].bytes = _bytes; \
context->heap[returnValue->i].text = _text;
typedef struct Token {
struct ImportData *module;
const char *text;
size_t textBytes;
uint32_t line;
uint8_t type;
} Token;
typedef struct Tokenizer {
struct ImportData *module;
const char *input;
size_t inputBytes;
uintptr_t position;
uintptr_t line;
bool error, isBaseModule;
} Tokenizer;
typedef struct Scope {
struct Node **entries;
size_t entryCount;
size_t variableEntryCount;
size_t entriesAllocated;
bool isRoot;
} Scope;
typedef struct Node {
uint8_t type;
bool referencesRootScope, isExternalCall, isPersistentVariable, isOptionVariable, cycleCheck, hasTypeInheritanceParent;
uint8_t operationType;
int32_t inlineImportVariableIndex;
Token token;
struct Node *firstChild;
struct Node *sibling;
struct Node *parent; // Set in ASTSetScopes.
Scope *scope; // Set in ASTSetScopes.
struct Node *expressionType; // Set in ASTSetTypes.
struct ImportData *importData; // The module being imported by this node.
} Node;
typedef struct Value {
union {
int64_t i;
double f;
};
} Value;
typedef struct LineNumber {
struct ImportData *importData;
uint32_t instructionPointer;
uint32_t lineNumber;
Token *function;
} LineNumber;
typedef struct FunctionBuilder {
uint8_t *data;
size_t dataBytes;
size_t dataAllocated;
LineNumber *lineNumbers;
size_t lineNumberCount;
size_t lineNumbersAllocated;
int32_t scopeIndex;
bool isPersistentVariable, isDotAssignment, isListAssignment;
uintptr_t globalVariableOffset;
struct ImportData *importData; // Only valid during script loading.
Node *replResultType;
} FunctionBuilder;
typedef struct BackTraceItem {
uint32_t instructionPointer : 30,
popResult : 1,
assertResult : 1;
int32_t variableBase : 30;
} BackTraceItem;
typedef struct HeapEntry {
uint8_t type;
bool gcMark;
bool internalValuesAreManaged;
uint32_t externalReferenceCount;
union {
struct { // T_STR
// TODO Inlining small strings.
size_t bytes;
char *text;
};
struct { // T_STRUCT
uint16_t fieldCount;
Value *fields; // Managed bools placed before this.
};
struct { // T_LIST
uint32_t length, allocated;
Value *list;
};
struct { // Unused entry.
uintptr_t nextUnusedEntry;
};
struct { // Various function pointers.
int64_t lambdaID;
Value curryValue;
};
struct { // T_CONCAT
uint32_t concat1, concat2;
size_t concatBytes;
};
struct { // T_ERR
bool success;
Value errorValue;
};
struct { // T_ANYTYPE
Node *anyType;
Value anyValue;
};
};
} HeapEntry;
typedef struct CoroutineState {
Value *localVariables;
bool *localVariableIsManaged;
size_t localVariableCount;
size_t localVariablesAllocated;
Value stack[50]; // TODO Merge with variables?
bool stackIsManaged[50];
uintptr_t stackPointer;
size_t stackEntriesAllocated;
BackTraceItem backTrace[300];
uintptr_t backTracePointer;
uint64_t id;
int64_t unblockedBy;
struct CoroutineState *nextCoroutine;
struct CoroutineState **previousCoroutineLink;
struct CoroutineState *nextUnblockedCoroutine;
struct CoroutineState **previousUnblockedCoroutineLink;
struct CoroutineState *nextExternalCoroutine;
struct CoroutineState **waiters;
size_t waiterCount;
size_t waitersAllocated;
struct CoroutineState ***waitingOn;
size_t waitingOnCount;
bool awaiting, startedByAsync, externalCoroutine;
uintptr_t instructionPointer;
uintptr_t variableBase;
Value externalCoroutineData;
void *externalCoroutineData2;
// Data stored for library calls:
uintptr_t parameterCount;
Value returnValue;
int returnValueType;
} CoroutineState;
typedef struct ExecutionContext {
Value *globalVariables;
bool *globalVariableIsManaged;
size_t globalVariableCount;
HeapEntry *heap;
uintptr_t heapFirstUnusedEntry;
size_t heapEntriesAllocated;
FunctionBuilder *functionData; // Cleanup the relations between ExecutionContext, FunctionBuilder, Tokenizer and ImportData.
Node *rootNode; // Only valid during script loading.
char *scriptPersistFile;
struct ImportData *mainModule;
CoroutineState *c; // Active coroutine.
CoroutineState *allCoroutines;
CoroutineState *unblockedCoroutines;
uint64_t lastCoroutineID;
uint32_t externalCoroutineCount;
} ExecutionContext;
typedef struct ExternalFunction {
const char *cName;
int (*callback)(ExecutionContext *context, Value *returnValue);
} ExternalFunction;
typedef struct ImportData {
char *path;
size_t pathBytes;
void *fileData;
size_t fileDataBytes;
uintptr_t globalVariableOffset;
struct ImportData *nextImport;
struct ImportData *parentImport;
Node *rootNode;
void *library;
} ImportData;
Node globalExpressionTypeVoid = { .type = T_VOID };
Node globalExpressionTypeInt = { .type = T_INT };
Node globalExpressionTypeFloat = { .type = T_FLOAT };
Node globalExpressionTypeBool = { .type = T_BOOL };
Node globalExpressionTypeStr = { .type = T_STR };
Node globalExpressionTypeIntList = { .type = T_LIST, .firstChild = &globalExpressionTypeInt };
Node globalExpressionTypeErrVoid = { .type = T_ERR, .firstChild = &globalExpressionTypeVoid };
// Global variables:
const char *startFunction = "Start";
size_t startFunctionBytes = 5;
char **options;
bool *optionsMatched;
size_t optionCount;
int debugBytecodeLevel;
ImportData *importedModules;
ImportData **importedModulesLink = &importedModules;
// Forward declarations:
Node *ParseBlock(Tokenizer *tokenizer, bool replMode);
Node *ParseExpression(Tokenizer *tokenizer, bool allowAssignment, uint8_t precedence);
void ScriptPrintNode(Node *node, int indent);
bool ScriptLoad(Tokenizer tokenizer, ExecutionContext *context, ImportData *importData, bool replMode);
void ScriptFreeCoroutine(CoroutineState *c);
uintptr_t HeapAllocate(ExecutionContext *context);
// --------------------------------- Platform layer definitions.
#if defined(_WIN32) || defined(__linux__) || defined(__APPLE__)
#include <assert.h>
#define Assert assert
#endif
void *AllocateFixed(size_t bytes);
void *AllocateResize(void *old, size_t bytes);
int MemoryCompare(const void *a, const void *b, size_t bytes);
void MemoryCopy(void *a, const void *b, size_t bytes);
size_t PrintIntegerToBuffer(char *buffer, size_t bufferBytes, int64_t i); // TODO This shouldn't be in the platform layer.
size_t PrintFloatToBuffer(char *buffer, size_t bufferBytes, double f); // TODO This shouldn't be in the platform layer.
void PrintDebug(const char *format, ...);
void PrintError(Tokenizer *tokenizer, const char *format, ...);
void PrintError2(Tokenizer *tokenizer, Node *node, const char *format, ...);
void PrintError3(const char *format, ...);
void PrintError4(ExecutionContext *context, uint32_t instructionPointer, const char *format, ...);
void PrintBackTrace(ExecutionContext *context, uint32_t instructionPointer, CoroutineState *c, const char *prefix);
void *FileLoad(const char *path, size_t *length);
CoroutineState *ExternalCoroutineWaitAny(ExecutionContext *context);
void ExternalPassREPLResult(ExecutionContext *context, Value value);
void *LibraryLoad(const char *name);
void *LibraryGetAddress(void *library, const char *name);
// --------------------------------- Base module.
char baseModuleSource[] = {
// TODO Temporary.
"struct DirectoryChild { str name; bool isDirectory; int size; };"
"DirectoryChild[] Dir() { str[] names = DirectoryEnumerate(\"0:\"):assert(); DirectoryChild[] result = new DirectoryChild[]; result:resize(names:len()); for int i = 0; i < names:len(); i += 1 { result[i] = new DirectoryChild; result[i].name = names[i]; result[i].isDirectory = PathIsDirectory(\"0:/\"+names[i]); result[i].size = FileGetSize(\"0:/\"+names[i]):default(-1); } return result;}"
"str[] OpenDocumentEnumerate() #extcall;"
// Logging:
"void Log(str x) #extcall;"
"void LogInfo(str x) { Log(TextColorHighlight() + x); }"
"void LogError(str x) { Log(TextColorError() + \"Error: \" + x); }"
"void LogOpenGroup(str title) #extcall;"
// TODO LogOpenList, LogOpenTable, etc.
"void LogClose() #extcall;"
"str TextColorError() #extcall;"
"str TextColorHighlight() #extcall;"
"str TextWeight(int i) #extcall;"
"str TextMonospaced() #extcall;"
"str TextPlain() #extcall;"
"str TextBold() { return TextWeight(700); }"
// String operations:
"str StringSlice(str x, int start, int end) #extcall;"
"int CharacterToByte(str x) #extcall;"
"bool StringContains(str haystack, str needle) {"
" for int i = 0; i <= haystack:len() - needle:len(); i += 1 {"
" bool match = true;"
" for int j = 0; j < needle:len(); j += 1 { if haystack[i + j] != needle[j] match = false; }"
" if match { return true; }"
" }"
" return false;"
"}"
"str StringTrim(str string) {"
" int start = 0;"
" int end = string:len();"
" while start != end && (string[start] == \" \" || string[start] == \"\\t\" || string[start] == \"\\r\" || string[start] == \"\\n\") { start += 1; }"
" while start != end && (string[end - 1] == \" \" || string[end - 1] == \"\\t\" || string[end - 1] == \"\\r\" || string[end - 1] == \"\\n\") { end -= 1; }"
" return StringSlice(string, start, end);"
"}"
"str[] StringSplitByCharacter(str string, str character, bool includeEmptyString) {"
" assert character:len() == 1;"
" str[] list = new str[];"
" int x = 0;"
" for int i = 0; i < string:len(); i += 1 {"
" if string[i] == character {"
" if (includeEmptyString || x != i) { list:add(StringSlice(string, x, i)); }"
" x = i + 1;"
" }"
" }"
" if (includeEmptyString || x != string:len()) { list:add(StringSlice(string, x, string:len())); }"
" return list;"
"}"
"str StringJoin(str[] strings, str k, bool trailing) {"
" str c = \"\";"
" for int i = 0; i < strings:len(); i += 1 {"
" if i < strings:len() - 1 || trailing { c = c + strings[i] + k; }"
" else { c = c + strings[i]; }"
" }"
" return c;"
"}"
"bool StringEndsWith(str s, str x) { return s:len() >= x:len() && StringSlice(s, s:len() - x:len(), s:len()) == x; }"
"bool StringStartsWith(str s, str x) { return s:len() >= x:len() && StringSlice(s, 0, x:len()) == x; }"
"bool CharacterIsAlnum(str c) {"
" int b = CharacterToByte(c);"
" return (b >= CharacterToByte(\"A\") && b <= CharacterToByte(\"Z\")) || (b >= CharacterToByte(\"a\") && b <= CharacterToByte(\"z\"))"
" || (b >= CharacterToByte(\"0\") && b <= CharacterToByte(\"9\"));"
"}"
// Miscellaneous:
"int SystemGetProcessorCount() #extcall;"
"bool SystemRunningAsAdministrator() #extcall;"
"str SystemGetHostName() #extcall;"
"void SystemSleepMs(int ms) #extcall;"
"int RandomInt(int min, int max) #extcall;"
"str UUIDGenerate() {"
" str hexChars = \"0123456789abcdef\";"
" str result;"
" for int i = 0; i < 8; i += 1 { result += hexChars[RandomInt(0, 15)]; }"
" result += \"-\";"
" for int i = 0; i < 4; i += 1 { result += hexChars[RandomInt(0, 15)]; }"
" result += \"-4\";"
" for int i = 0; i < 3; i += 1 { result += hexChars[RandomInt(0, 15)]; }"
" result += \"-\" + hexChars[RandomInt(8, 11)];"
" for int i = 0; i < 3; i += 1 { result += hexChars[RandomInt(0, 15)]; }"
" result += \"-\";"
" for int i = 0; i < 12; i += 1 { result += hexChars[RandomInt(0, 15)]; }"
" return result;"
"}"
// File system access:
"bool PathExists(str x) #extcall;"
"bool PathIsFile(str source) #extcall;"
"bool PathIsDirectory(str source) #extcall;"
"bool PathIsLink(str source) #extcall;"
"err[void] PathCreateDirectory(str x) #extcall;"
"err[void] PathDelete(str x) #extcall;"
"err[void] PathMove(str source, str destination) #extcall;"
"str PathGetDefaultPrefix() #extcall;"
"err[void] PathSetDefaultPrefixToScriptSourceDirectory() #extcall;"
"err[str] FileReadAll(str path) #extcall;"
"err[void] FileWriteAll(str path, str x) #extcall;"
"err[void] FileAppend(str path, str x) #extcall;"
"err[void] FileCopy(str source, str destination) #extcall;"
"err[int] FileGetSize(str path) #extcall;"
"err[void] _DirectoryInternalStartIteration(str path) #extcall;"
"str _DirectoryInternalNextIteration() #extcall;"
"void _DirectoryInternalEndIteration() #extcall;"
"err[void] _DirectoryInternalEnumerateChildren(str path, str prefix, str[] result, bool recurse) {"
" reterr _DirectoryInternalStartIteration(path);"
" str child = _DirectoryInternalNextIteration();"
" int start = result:len();"
" while child != \"\" { result:add(child); child = _DirectoryInternalNextIteration(); }"
" _DirectoryInternalEndIteration();"
" int end = result:len();"
" if recurse {"
" for int i = start; i < end; i += 1 {"
" str actual = path + \"/\" + result[i];"
" if PathIsDirectory(actual) {"
" _DirectoryInternalEnumerateChildren(actual, prefix + result[i] + \"/\", result, true);"
" }"
" }"
" }"
" for int i = start; i < end; i += 1 {"
" result[i] = prefix + result[i];"
" }"
" return #success;"
"}"
"err[str[]] DirectoryEnumerate(str path) {"
" str[] result = new str[];"
" err[void] e = _DirectoryInternalEnumerateChildren(path, \"\", result, false);"
" reterr e; return result;"
"}"
"err[str[]] DirectoryEnumerateRecursively(str path) {"
" str[] result = new str[];"
" err[void] e = _DirectoryInternalEnumerateChildren(PathTrimTrailingSlash(path), \"\", result, true);"
" reterr e; return result;"
"}"
"str PathTrimTrailingSlash(str x) { if x:len() > 0 && x[x:len() - 1] == \"/\" { return StringSlice(x, 0, x:len() - 1); } return x; }"
"err[void] PathDeleteRecursively(str path) {"
" err[str[]] e = DirectoryEnumerateRecursively(path);"
" if str[] all in e {"
" for int i = 0; i < all:len(); i += 1 {"
" str p = path + \"/\" + all[i];"
" if PathIsFile(p) || PathIsLink(p) {"
" PathDelete(p);"
" }"
" }"
" for int i = all:len(); i > 0; i -= 1 {"
" str p = path + \"/\" + all[i - 1];"
" if PathIsDirectory(p) {"
" PathDelete(p);"
" }"
" }"
" return PathDelete(path);"
" } else {"
" return new err[void] e:error();"
" }"
"}"
"err[void] PathCopyRecursively(str source, str destination) {"
" err[str[]] e = DirectoryEnumerateRecursively(source);"
" if str[] all in e {"
" reterr PathCreateDirectory(destination);"
" for int i = 0; i < all:len(); i += 1 {"
" str sourceItem = source + \"/\" + all[i];"
" str destinationItem = destination + \"/\" + all[i];"
" if PathIsDirectory(sourceItem) {"
" PathCreateDirectory(destinationItem);"
" } else {"
" reterr FileCopy(sourceItem, destinationItem);"
" }"
" }"
" return #success;"
" } else {"
" return new err[void] e:error();"
" }"
"}"
"err[void] PathCopyInto(str sourceDirectory, str item, str destinationDirectory) {"
" str sourceItem = sourceDirectory + \"/\"+ item;"
" str destinationItem = destinationDirectory + \"/\"+ item;"
" PathCreateLeadingDirectories(PathGetLeadingDirectories(destinationItem));"
" if PathIsDirectory(sourceItem) {"
" return PathCreateDirectory(destinationItem);"
" } else {"
" return FileCopy(sourceItem, destinationItem);"
" }"
"}"
"err[void] PathCopyAllInto(str sourceDirectory, str[] items, str destinationDirectory) {"
" for int i = 0; i < items:len(); i += 1 {"
" reterr PathCopyInto(sourceDirectory, items[i], destinationDirectory);"
" }"
" return #success;"
"}"
"err[void] PathCopyFilteredInto(str sourceDirectory, str[] filter, int filterWildcard, str destinationDirectory) {"
" assert filter:len() > 0;"
" err[str[]] e;"
" if filterWildcard != -1 || filter:len() > 1 { e = DirectoryEnumerateRecursively(sourceDirectory); }"
" else { e = DirectoryEnumerate(sourceDirectory); }"
" if str[] items in e {"
" for int i = 0; i < items:len(); i += 1 {"
" if PathMatchesFilter(items[i], filter, filterWildcard) {"
" reterr PathCopyInto(sourceDirectory, items[i], destinationDirectory);"
" }"
" }"
" return #success;"
" } else {"
" return new err[void] e:error();"
" }"
"}"
"bool PathMatchesFilter(str path, str[] filterComponents, int _filterWildcard) {"
" str[] pathComponents = StringSplitByCharacter(path, \"/\", false);"
" int filterWildcard = _filterWildcard;"
" if filterWildcard == -1 { "
" filterWildcard = pathComponents:len(); "
" }"
" if filterComponents:len() > pathComponents:len() { "
" return false; "
" }"
" for int i = 0; i < filterComponents:len(); i += 1 {"
" str filterComponent = filterComponents[i];"
" str pathComponent;"
" int wildcard = filterComponent:len();"
" if i < filterWildcard { "
" pathComponent = pathComponents[i]; "
" } else { "
" pathComponent = pathComponents[pathComponents:len() - filterComponents:len() + i]; "
" }"
" for int j = 0; j < filterComponent:len(); j += 1 { "
" if filterComponent[j] == \"*\" { "
" wildcard = j; "
" if pathComponent:len() < filterComponent:len() - 1 {"
" return false;"
" }"
" } "
" }"
" for int j = 0; j < filterComponent:len(); j += 1 {"
" if j < wildcard {"
" if filterComponent[j] != pathComponent[j] { return false; }"
" } else if j > wildcard {"
" if filterComponent[j] != pathComponent[pathComponent:len() - filterComponent:len() + j] { return false; }"
" }"
" }"
" }"
" return true;"
"}"
"str PathGetLeadingDirectories(str path) {"
" for int i = path:len() - 1; i >= 0; i -= 1 {"
" if path[i] == \"/\" {"
" return StringSlice(path, 0, i);"
" }"
" }"
" return \"\";"
"}"
"err[void] PathCreateLeadingDirectories(str path) {"
" for int i = 0; i < path:len(); i += 1 {"
" if path[i] == \"/\" {"
" PathCreateDirectory(StringSlice(path, 0, i));"
" }"
" }"
" return PathCreateDirectory(path);"
"}"
// Persistent variables:
"bool PersistRead(str path) #extcall;"
// Command line:
"str ConsoleGetLine() #extcall;"
"void ConsoleWriteStdout(str x) #extcall;"
"void ConsoleWriteStderr(str x) #extcall;"
"err[str] SystemGetEnvironmentVariable(str name) #extcall;"
"err[void] SystemSetEnvironmentVariable(str name, str value) #extcall;"
"bool SystemShellExecute(str x) #extcall;" // Returns true on success.
"bool SystemShellExecuteWithWorkingDirectory(str wd, str x) #extcall;" // Returns true on success.
"str SystemShellEvaluate(str x) #extcall;" // Captures stdout.
"void SystemShellEnableLogging(bool x) #extcall;"
};
// --------------------------------- External function calls.
int ExternalLog(ExecutionContext *context, Value *returnValue);
int ExternalLogOpenGroup(ExecutionContext *context, Value *returnValue);
int ExternalLogClose(ExecutionContext *context, Value *returnValue);
int ExternalTextColorError(ExecutionContext *context, Value *returnValue);
int ExternalTextColorHighlight(ExecutionContext *context, Value *returnValue);
int ExternalTextWeight(ExecutionContext *context, Value *returnValue);
int ExternalTextMonospaced(ExecutionContext *context, Value *returnValue);
int ExternalTextPlain(ExecutionContext *context, Value *returnValue);
int ExternalConsoleGetLine(ExecutionContext *context, Value *returnValue);
int ExternalConsoleWriteStdout(ExecutionContext *context, Value *returnValue);
int ExternalConsoleWriteStderr(ExecutionContext *context, Value *returnValue);
int ExternalStringSlice(ExecutionContext *context, Value *returnValue);
int ExternalCharacterToByte(ExecutionContext *context, Value *returnValue);
int ExternalSystemShellExecute(ExecutionContext *context, Value *returnValue);
int ExternalSystemShellExecuteWithWorkingDirectory(ExecutionContext *context, Value *returnValue);
int ExternalSystemShellEvaluate(ExecutionContext *context, Value *returnValue);
int ExternalSystemShellEnableLogging(ExecutionContext *context, Value *returnValue);
int ExternalSystemGetProcessorCount(ExecutionContext *context, Value *returnValue);
int ExternalSystemGetEnvironmentVariable(ExecutionContext *context, Value *returnValue);
int ExternalSystemSetEnvironmentVariable(ExecutionContext *context, Value *returnValue);
int ExternalSystemRunningAsAdministrator(ExecutionContext *context, Value *returnValue);
int ExternalSystemGetHostName(ExecutionContext *context, Value *returnValue);
int ExternalSystemSleepMs(ExecutionContext *context, Value *returnValue);
int ExternalPathCreateDirectory(ExecutionContext *context, Value *returnValue);
int ExternalPathDelete(ExecutionContext *context, Value *returnValue);
int ExternalPathExists(ExecutionContext *context, Value *returnValue);
int ExternalPathIsFile(ExecutionContext *context, Value *returnValue);
int ExternalPathIsDirectory(ExecutionContext *context, Value *returnValue);
int ExternalPathIsLink(ExecutionContext *context, Value *returnValue);
int ExternalPathMove(ExecutionContext *context, Value *returnValue);
int ExternalPathGetDefaultPrefix(ExecutionContext *context, Value *returnValue);
int ExternalPathSetDefaultPrefixToScriptSourceDirectory(ExecutionContext *context, Value *returnValue);
int ExternalFileReadAll(ExecutionContext *context, Value *returnValue);
int ExternalFileWriteAll(ExecutionContext *context, Value *returnValue);
int ExternalFileAppend(ExecutionContext *context, Value *returnValue);
int ExternalFileCopy(ExecutionContext *context, Value *returnValue);
int ExternalFileGetSize(ExecutionContext *context, Value *returnValue);
int ExternalPersistRead(ExecutionContext *context, Value *returnValue);
int ExternalPersistWrite(ExecutionContext *context, Value *returnValue);
int ExternalRandomInt(ExecutionContext *context, Value *returnValue); // TODO This shouldn't be in the platform layer.
int External_DirectoryInternalStartIteration(ExecutionContext *context, Value *returnValue);
int External_DirectoryInternalNextIteration(ExecutionContext *context, Value *returnValue);
int External_DirectoryInternalEndIteration(ExecutionContext *context, Value *returnValue);
int ExternalOpenDocumentEnumerate(ExecutionContext *context, Value *returnValue);
ExternalFunction externalFunctions[] = {
{ .cName = "Log", .callback = ExternalLog },
{ .cName = "LogOpenGroup", .callback = ExternalLogOpenGroup },
{ .cName = "LogClose", .callback = ExternalLogClose },
{ .cName = "TextColorError", .callback = ExternalTextColorError },
{ .cName = "TextColorHighlight", .callback = ExternalTextColorHighlight },
{ .cName = "TextWeight", .callback = ExternalTextWeight },
{ .cName = "TextMonospaced", .callback = ExternalTextMonospaced },
{ .cName = "TextPlain", .callback = ExternalTextPlain },
{ .cName = "ConsoleGetLine", .callback = ExternalConsoleGetLine },
{ .cName = "ConsoleWriteStdout", .callback = ExternalConsoleWriteStdout },
{ .cName = "ConsoleWriteStderr", .callback = ExternalConsoleWriteStderr },
{ .cName = "StringSlice", .callback = ExternalStringSlice },
{ .cName = "CharacterToByte", .callback = ExternalCharacterToByte },
{ .cName = "SystemShellExecute", .callback = ExternalSystemShellExecute },
{ .cName = "SystemShellExecuteWithWorkingDirectory", .callback = ExternalSystemShellExecuteWithWorkingDirectory },
{ .cName = "SystemShellEvaluate", .callback = ExternalSystemShellEvaluate },
{ .cName = "SystemShellEnableLogging", .callback = ExternalSystemShellEnableLogging },
{ .cName = "SystemGetProcessorCount", .callback = ExternalSystemGetProcessorCount },
{ .cName = "SystemGetEnvironmentVariable", .callback = ExternalSystemGetEnvironmentVariable },
{ .cName = "SystemSetEnvironmentVariable", .callback = ExternalSystemSetEnvironmentVariable },
{ .cName = "SystemRunningAsAdministrator", .callback = ExternalSystemRunningAsAdministrator },
{ .cName = "SystemGetHostName", .callback = ExternalSystemGetHostName },
{ .cName = "SystemSleepMs", .callback = ExternalSystemSleepMs },
{ .cName = "PathExists", .callback = ExternalPathExists },
{ .cName = "PathIsFile", .callback = ExternalPathIsFile },
{ .cName = "PathIsDirectory", .callback = ExternalPathIsDirectory },
{ .cName = "PathIsLink", .callback = ExternalPathIsLink },
{ .cName = "PathCreateDirectory", .callback = ExternalPathCreateDirectory },
{ .cName = "PathDelete", .callback = ExternalPathDelete },
{ .cName = "PathMove", .callback = ExternalPathMove },
{ .cName = "PathGetDefaultPrefix", .callback = ExternalPathGetDefaultPrefix },
{ .cName = "PathSetDefaultPrefixToScriptSourceDirectory", .callback = ExternalPathSetDefaultPrefixToScriptSourceDirectory },
{ .cName = "FileReadAll", .callback = ExternalFileReadAll },
{ .cName = "FileWriteAll", .callback = ExternalFileWriteAll },
{ .cName = "FileAppend", .callback = ExternalFileAppend },
{ .cName = "FileCopy", .callback = ExternalFileCopy },
{ .cName = "FileGetSize", .callback = ExternalFileGetSize },
{ .cName = "PersistRead", .callback = ExternalPersistRead },
{ .cName = "PersistWrite", .callback = ExternalPersistWrite },
{ .cName = "RandomInt", .callback = ExternalRandomInt },
{ .cName = "_DirectoryInternalStartIteration", .callback = External_DirectoryInternalStartIteration },
{ .cName = "_DirectoryInternalNextIteration", .callback = External_DirectoryInternalNextIteration },
{ .cName = "_DirectoryInternalEndIteration", .callback = External_DirectoryInternalEndIteration },
{ .cName = "OpenDocumentEnumerate", .callback = ExternalOpenDocumentEnumerate },
};
// --------------------------------- Tokenization and parsing.
uint8_t TokenLookupPrecedence(uint8_t t) {
if (t == T_EQUALS) return 10;
if (t == T_ADD_EQUALS) return 10;
if (t == T_MINUS_EQUALS) return 10;
if (t == T_ASTERISK_EQUALS) return 10;
if (t == T_SLASH_EQUALS) return 10;
if (t == T_COMMA) return 12;
if (t == T_LOGICAL_OR) return 14;
if (t == T_LOGICAL_AND) return 15;
if (t == T_BITWISE_OR) return 16;
if (t == T_BITWISE_XOR) return 17;
if (t == T_BITWISE_AND) return 18;
if (t == T_DOUBLE_EQUALS) return 20;
if (t == T_NOT_EQUALS) return 20;
if (t == T_GREATER_THAN) return 25;
if (t == T_LESS_THAN) return 25;
if (t == T_GT_OR_EQUAL) return 25;
if (t == T_LT_OR_EQUAL) return 25;
if (t == T_BIT_SHIFT_LEFT) return 30;
if (t == T_BIT_SHIFT_RIGHT) return 30;
if (t == T_ADD) return 50;
if (t == T_MINUS) return 50;
if (t == T_ASTERISK) return 60;
if (t == T_SLASH) return 60;
if (t == T_LOGICAL_NOT) return 70;
if (t == T_BITWISE_NOT) return 70;
if (t == T_NEGATE) return 70;
if (t == T_NEW) return 75;
if (t == T_DOT) return 80;
if (t == T_COLON) return 80;
if (t == T_AWAIT) return 90;
if (t == T_LEFT_ROUND) return 100;
Assert(false);
return 0;
}
Token TokenNext(Tokenizer *tokenizer) {
// TODO Block comments.
Token token = { 0 };
token.type = T_ERROR;
token.module = tokenizer->module;
while (true) {
if (tokenizer->position == tokenizer->inputBytes) {
token.type = T_EOF;
break;
}
uint8_t c = tokenizer->input[tokenizer->position];
uint8_t c1 = tokenizer->position + 1 == tokenizer->inputBytes ? 0 : tokenizer->input[tokenizer->position + 1];
token.text = &tokenizer->input[tokenizer->position];
token.textBytes = 1;
token.line = tokenizer->line;
if (c == ' ' || c == '\t' || c == '\r') {
tokenizer->position++;
continue;
} else if (c == '\n') {
tokenizer->position++;
tokenizer->line++;
continue;
} else if (c == '/' && c1 == '/') {
while (tokenizer->position != tokenizer->inputBytes && tokenizer->input[tokenizer->position] != '\n') {
tokenizer->position++;
}
continue;
}
else if (c == '<' && c1 == '=' && (tokenizer->position += 2)) token.type = T_LT_OR_EQUAL;
else if (c == '>' && c1 == '=' && (tokenizer->position += 2)) token.type = T_GT_OR_EQUAL;
else if (c == '=' && c1 == '=' && (tokenizer->position += 2)) token.type = T_DOUBLE_EQUALS;
else if (c == '!' && c1 == '=' && (tokenizer->position += 2)) token.type = T_NOT_EQUALS;
else if (c == '&' && c1 == '&' && (tokenizer->position += 2)) token.type = T_LOGICAL_AND;
else if (c == '|' && c1 == '|' && (tokenizer->position += 2)) token.type = T_LOGICAL_OR;
else if (c == '+' && c1 == '=' && (tokenizer->position += 2)) token.type = T_ADD_EQUALS;
else if (c == '-' && c1 == '=' && (tokenizer->position += 2)) token.type = T_MINUS_EQUALS;
else if (c == '*' && c1 == '=' && (tokenizer->position += 2)) token.type = T_ASTERISK_EQUALS;
else if (c == '/' && c1 == '=' && (tokenizer->position += 2)) token.type = T_SLASH_EQUALS;
else if (c == '<' && c1 == '<' && (tokenizer->position += 2)) token.type = T_BIT_SHIFT_LEFT;
else if (c == '>' && c1 == '>' && (tokenizer->position += 2)) token.type = T_BIT_SHIFT_RIGHT;
else if (c == '~' && c1 == '|' && (tokenizer->position += 2)) token.type = T_BITWISE_XOR;
else if (c == '+' && ++tokenizer->position) token.type = T_ADD;
else if (c == '-' && ++tokenizer->position) token.type = T_MINUS;
else if (c == '*' && ++tokenizer->position) token.type = T_ASTERISK;
else if (c == '/' && ++tokenizer->position) token.type = T_SLASH;
else if (c == '(' && ++tokenizer->position) token.type = T_LEFT_ROUND;
else if (c == ')' && ++tokenizer->position) token.type = T_RIGHT_ROUND;
else if (c == '[' && ++tokenizer->position) token.type = T_LEFT_SQUARE;
else if (c == ']' && ++tokenizer->position) token.type = T_RIGHT_SQUARE;
else if (c == '{' && ++tokenizer->position) token.type = T_LEFT_FANCY;
else if (c == '}' && ++tokenizer->position) token.type = T_RIGHT_FANCY;
else if (c == ',' && ++tokenizer->position) token.type = T_COMMA;
else if (c == ';' && ++tokenizer->position) token.type = T_SEMICOLON;
else if (c == '=' && ++tokenizer->position) token.type = T_EQUALS;
else if (c == '<' && ++tokenizer->position) token.type = T_LESS_THAN;
else if (c == '>' && ++tokenizer->position) token.type = T_GREATER_THAN;
else if (c == '%' && ++tokenizer->position) token.type = T_STR_INTERPOLATE;
else if (c == '.' && ++tokenizer->position) token.type = T_DOT;
else if (c == ':' && ++tokenizer->position) token.type = T_COLON;
else if (c == '!' && ++tokenizer->position) token.type = T_LOGICAL_NOT;
else if (c == '|' && ++tokenizer->position) token.type = T_BITWISE_OR;
else if (c == '&' && ++tokenizer->position) token.type = T_BITWISE_AND;
else if (c == '~' && ++tokenizer->position) token.type = T_BITWISE_NOT;
else if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c == '_') || (c >= 0x80) || c == '#') {
token.textBytes = 0;
token.type = T_IDENTIFIER;
token.text = tokenizer->input + tokenizer->position;
while ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9')
|| (c == '_') || (c >= 0x80) || (c == '#' && !token.textBytes)) {
tokenizer->position++;
token.textBytes++;
if (tokenizer->position == tokenizer->inputBytes) break;
c = tokenizer->input[tokenizer->position];
}
#define KEYWORD(x) (token.textBytes == sizeof(x) - 1 && 0 == MemoryCompare(x, token.text, token.textBytes))
if (false) {}
else if KEYWORD("#extcall") token.type = T_EXTCALL;
else if KEYWORD("#import") token.type = T_IMPORT;
else if KEYWORD("#inline") token.type = T_INLINE;
else if KEYWORD("#library") token.type = T_LIBRARY;
else if KEYWORD("#option") token.type = T_OPTION;
else if KEYWORD("#persist") token.type = T_PERSIST;
else if KEYWORD("#success") token.type = T_SUCCESS;
else if KEYWORD("anytype") token.type = T_ANYTYPE;
else if KEYWORD("assert") token.type = T_ASSERT;
else if KEYWORD("await") token.type = T_AWAIT;
else if KEYWORD("bool") token.type = T_BOOL;
else if KEYWORD("else") token.type = T_ELSE;
else if KEYWORD("err") token.type = T_ERR;
else if KEYWORD("false") token.type = T_FALSE;
else if KEYWORD("float") token.type = T_FLOAT;
else if KEYWORD("for") token.type = T_FOR;
else if KEYWORD("functype") token.type = T_FUNCTYPE;
else if KEYWORD("handletype") token.type = T_HANDLETYPE;
else if KEYWORD("if") token.type = T_IF;
else if KEYWORD("in") token.type = T_IN;
else if KEYWORD("int") token.type = T_INT;
else if KEYWORD("inttype") token.type = T_INTTYPE;
else if KEYWORD("new") token.type = T_NEW;
else if KEYWORD("null") token.type = T_NULL;
else if KEYWORD("reterr") token.type = T_RETERR;
else if KEYWORD("return") token.type = T_RETURN;
else if KEYWORD("str") token.type = T_STR;
else if KEYWORD("struct") token.type = T_STRUCT;
else if KEYWORD("true") token.type = T_TRUE;
else if KEYWORD("tuple") token.type = T_TUPLE;
else if KEYWORD("void") token.type = T_VOID;
else if KEYWORD("while") token.type = T_WHILE;
else if (token.text[0] == '#') {
PrintError(tokenizer, "Unrecognised #-token '%.*s'.\n", token.textBytes, token.text);
tokenizer->error = true;
token.type = T_ERROR;
break;
}
} else if (c >= '0' && c <= '9') {
// TODO Exponent notation.
token.textBytes = 0;
token.type = T_NUMERIC_LITERAL;
token.text = tokenizer->input + tokenizer->position;
while ((c >= '0' && c <= '9') || (c == '.')) {
tokenizer->position++;
token.textBytes++;
if (tokenizer->position == tokenizer->inputBytes) break;
c = tokenizer->input[tokenizer->position];
}
if (token.textBytes == 1 && token.text[0] == '0') {
token.type = T_ZERO;
}
} else if (c == '"') {
// TODO Escape sequence to insert an arbitrary codepoint.
bool inInterpolation = false;
intptr_t startPosition = ++tokenizer->position;
intptr_t endPosition = -1;
for (uintptr_t i = tokenizer->position; true; i++) {
if (inInterpolation) {
if (tokenizer->input[i] == '%') {
inInterpolation = false;
} else if (tokenizer->input[i] == '"') {
PrintError(tokenizer, "Strings are not allowed within a string interpolation expression.\n");
tokenizer->error = true;
break;
} else if (tokenizer->input[i] == '\n') {
PrintError(tokenizer, "String interpolation expressions must stay on a single line.\n");
tokenizer->error = true;
break;
} else {
token.textBytes++;
}
} else if (i == tokenizer->inputBytes || tokenizer->input[i] == '\n') {
PrintError(tokenizer, "String does not end before the end of the line.\n");
tokenizer->error = true;
break;
} else if (tokenizer->input[i] == '"') {
endPosition = i;
break;
} else if (tokenizer->input[i] == '%') {
inInterpolation = true;
} else if (tokenizer->input[i] == '\\') {
if (i + 1 == tokenizer->inputBytes
|| (tokenizer->input[i + 1] != 'n' && tokenizer->input[i + 1] != 't'
&& tokenizer->input[i + 1] != 'r'
&& tokenizer->input[i + 1] != '%'
&& tokenizer->input[i + 1] != '"' && tokenizer->input[i + 1] != '\\')) {
PrintError(tokenizer, "String contains unrecognized escape sequence '\\%c'. "
"Possibilities are: '\\\\', '\\%%', '\\n', '\\r', '\\t' and '\\\"'\n", tokenizer->input[i + 1]);
tokenizer->error = true;
break;
} else {
i++;
token.textBytes++;
}
} else {
token.textBytes++;
}
}
if (endPosition != -1) {
token.text = tokenizer->input + startPosition;
token.textBytes = endPosition - startPosition;
token.type = T_STRING_LITERAL;
tokenizer->position = endPosition + 1;
}
} else {
PrintError(tokenizer, "Unexpected character '%c'.\n", c);
tokenizer->error = true;
}
break;
}
return token;
}
Token TokenPeek(Tokenizer *tokenizer) {
Tokenizer copy = *tokenizer;
return TokenNext(&copy);
}
Node *ParseType(Tokenizer *tokenizer, bool maybe, bool allowVoid, bool allowTuple) {
Node *node = (Node *) AllocateFixed(sizeof(Node));
node->token = TokenNext(tokenizer);
if (node->token.type == T_INT
|| node->token.type == T_FLOAT
|| node->token.type == T_STR
|| node->token.type == T_BOOL
|| node->token.type == T_VOID
|| node->token.type == T_TUPLE
|| node->token.type == T_ERR
|| node->token.type == T_ANYTYPE
|| node->token.type == T_IDENTIFIER) {
node->type = node->token.type;
if (!allowVoid && node->type == T_VOID) {
if (!maybe) {
PrintError2(tokenizer, node, "The 'void' type is not allowed here.\n");
}
return NULL;
}
if (!allowTuple && node->type == T_TUPLE) {
if (!maybe) {
PrintError2(tokenizer, node, "The 'tuple' type is not allowed here.\n");
}
return NULL;
}
if (node->type == T_TUPLE) {
Token token = TokenNext(tokenizer);
if (token.type != T_LEFT_SQUARE) {
if (!maybe) PrintError2(tokenizer, node, "Expected a '[' after 'tuple'.\n");
return NULL;
}
Node **link = &node->firstChild;
bool needComma = false;
int count = 0;
while (true) {
token = TokenPeek(tokenizer);
if (token.type == T_RIGHT_SQUARE) {
TokenNext(tokenizer);
break;
} else if (needComma) {
if (token.type == T_COMMA) {
TokenNext(tokenizer);
} else {
if (!maybe) PrintError2(tokenizer, node, "Expected a ',' or ']' in the type list for 'tuple'.\n");
return NULL;
}
}
if (count == FUNCTION_MAX_ARGUMENTS) {
if (!maybe) PrintError2(tokenizer, node, "Too many values in the tuple (maximum is %d).\n", FUNCTION_MAX_ARGUMENTS);
return NULL;
}
Node *n = ParseType(tokenizer, maybe, false, false);
if (!n) return NULL;
*link = n;
link = &n->sibling;
needComma = true;
count++;
}
if (!node->firstChild || !node->firstChild->sibling) {
if (!maybe) PrintError2(tokenizer, node, "A tuple must have at least two types in its list.\n");
return NULL;
}
} else if (node->type == T_ERR) {
Token token = TokenNext(tokenizer);
if (token.type != T_LEFT_SQUARE) {
if (!maybe) PrintError2(tokenizer, node, "Expected a '[' after 'err'.\n");
return NULL;
}
Node *n = ParseType(tokenizer, maybe, true /* allow void */, false);
if (!n) return NULL;
node->firstChild = n;
token = TokenNext(tokenizer);
if (token.type != T_RIGHT_SQUARE) {
if (!maybe) PrintError2(tokenizer, node, "Expected a ']' after the type of 'err'.\n");
return NULL;
}
if (n->type == T_ERR) {
if (!maybe) PrintError2(tokenizer, node, "Error types cannot be nested.\n");
return NULL;
}
}
bool first = true;
while (true) {
Token token = TokenPeek(tokenizer);
if (token.type == T_ERROR) {
return NULL;
} else if (token.type == T_LEFT_SQUARE) {
Node *list = (Node *) AllocateFixed(sizeof(Node));
list->type = T_LIST;
list->token = TokenNext(tokenizer);
if (first) {
list->firstChild = node;
first = false;
node = list;
} else {
Node *end = node;
while (end->firstChild->firstChild) end = end->firstChild;
list->firstChild = end->firstChild;
end->firstChild = list;
}
token = TokenNext(tokenizer);
if (token.type == T_ERROR) {
return NULL;
} else if (token.type != T_RIGHT_SQUARE) {
if (!maybe) {
PrintError2(tokenizer, node, "Expected a ']' after the '[' in an list type.\n");
}
return NULL;
}
} else {
break;
}
}
return node;
} else if (!maybe) {
PrintError2(tokenizer, node, "Expected a type. This can be a builtin type or an identifier.\n");
return NULL;
} else {
return NULL;
}
}
Node *ParseCall(Tokenizer *tokenizer, Node *function) {
Node *call = (Node *) AllocateFixed(sizeof(Node));
call->token = TokenNext(tokenizer);
call->type = T_CALL;
call->firstChild = function;
Node *arguments = (Node *) AllocateFixed(sizeof(Node));
arguments->type = T_ARGUMENTS;
function->sibling = arguments;
Node **link = &arguments->firstChild;
if (call->token.type != T_LEFT_ROUND) {
PrintError2(tokenizer, call, "Expected a '(' to start the list of arguments.\n");
return NULL;
}
while (true) {
Token token = TokenPeek(tokenizer);
if (token.type == T_RIGHT_ROUND) {
TokenNext(tokenizer);
break;
} else if (token.type == T_ERROR) {
return NULL;
}
if (arguments->firstChild) {
Token comma = TokenNext(tokenizer);
if (comma.type != T_COMMA) {
Node n = { .token = comma };
PrintError2(tokenizer, &n, "Expected a comma to separate function arguments.\n");
return NULL;
}
}
Node *argument = ParseExpression(tokenizer, false, 0);
if (!argument) return NULL;
*link = argument;
link = &argument->sibling;
}
return call;
}
Node *ParseExpression(Tokenizer *tokenizer, bool allowAssignment, uint8_t precedence) {
Node *node = (Node *) AllocateFixed(sizeof(Node));
node->token = TokenNext(tokenizer);
if (node->token.type == T_ERROR) return NULL;
if (node->token.type == T_IDENTIFIER) {
node->type = T_VARIABLE;
} else if (node->token.type == T_STRING_LITERAL) {
Node *string = node;
string->type = string->token.type;
const char *raw = string->token.text;
size_t rawBytes = string->token.textBytes;
// It's impossible for size of the string to increase.
char *output = (char *) AllocateFixed(rawBytes);
size_t outputPosition = 0;
string->token.text = output;
string->token.textBytes = 0;
for (uintptr_t i = 0; i < rawBytes; i++) {
char c = raw[i];
if (c == '\\') {
Assert(i != rawBytes - 1);
c = raw[++i];
Assert(outputPosition != rawBytes);
if (c == '\\') c = '\\';
else if (c == 'n') c = '\n';
else if (c == 'r') c = '\r';
else if (c == 't') c = '\t';
else if (c == '%') c = '%';
else if (c == '"') c = '"';
else Assert(false);
output[outputPosition++] = c;
string->token.textBytes++;
} else if (c == '%') {
Node *stringInterpolate = (Node *) AllocateFixed(sizeof(Node));
stringInterpolate->type = T_STR_INTERPOLATE;
stringInterpolate->firstChild = node;
Tokenizer t = *tokenizer;
t.position = raw - t.input + i + 1;
stringInterpolate->firstChild->sibling = ParseExpression(&t, false, 0);
if (!stringInterpolate->firstChild->sibling) return NULL;
i = t.position - (raw - t.input);
string = (Node *) AllocateFixed(sizeof(Node));
string->type = T_STRING_LITERAL;
string->token.text = output + outputPosition;
string->token.textBytes = 0;
stringInterpolate->firstChild->sibling->sibling = string;
node = stringInterpolate;
} else {
Assert(outputPosition != rawBytes);
output[outputPosition++] = c;
string->token.textBytes++;
}
}
} else if (node->token.type == T_NUMERIC_LITERAL || node->token.type == T_SUCCESS || node->token.type == T_ZERO
|| node->token.type == T_TRUE || node->token.type == T_FALSE || node->token.type == T_NULL) {
node->type = node->token.type;
} else if (node->token.type == T_LOGICAL_NOT || node->token.type == T_MINUS || node->token.type == T_BITWISE_NOT) {
node->type = node->token.type == T_MINUS ? T_NEGATE : node->token.type;
node->firstChild = ParseExpression(tokenizer, false, TokenLookupPrecedence(node->type));
} else if (node->token.type == T_LEFT_ROUND) {
node = ParseExpression(tokenizer, false, 0);
if (!node) return NULL;
Token token = TokenNext(tokenizer);
if (token.type != T_RIGHT_ROUND) {
Node n = { .token = token };
PrintError2(tokenizer, &n, "Expected a matching closing bracket.\n");
return NULL;
}
} else if (node->token.type == T_NEW) {
node->type = T_NEW;
node->firstChild = ParseType(tokenizer, false, false /* allow void */, false /* allow tuple */);
node->expressionType = node->firstChild;
if (!node->firstChild) return NULL;
if (node->firstChild->type == T_ERR) {
node->firstChild->sibling = ParseExpression(tokenizer, false, TokenLookupPrecedence(node->type));
if (!node->firstChild->sibling) return NULL;
}
} else if (node->token.type == T_LEFT_SQUARE) {
node->type = T_LIST_LITERAL;
Node **link = &node->firstChild;
bool needComma = false;
while (true) {
Token peek = TokenPeek(tokenizer);
if (peek.type == T_ERROR) {
return NULL;
} else if (peek.type == T_RIGHT_SQUARE) {
TokenNext(tokenizer);
break;
}
if (needComma) {
if (peek.type != T_COMMA) {
PrintError(tokenizer, "Expected a comma between list literal items.\n");
return NULL;
} else {
TokenNext(tokenizer);
}
}
Node *item = ParseExpression(tokenizer, false, 0);
if (!item) return NULL;
*link = item;
link = &item->sibling;
needComma = true;
}
} else if (node->token.type == T_AWAIT) {
node->type = T_AWAIT;
node->firstChild = ParseExpression(tokenizer, false, TokenLookupPrecedence(node->token.type));
} else {
PrintError2(tokenizer, node, "Expected an expression. "
"Expressions can start with a variable identifier, a string literal, a number, 'await', 'new', '-', '!', '[' or '('.\n");
return NULL;
}
while (true) {
Token token = TokenPeek(tokenizer);
if (token.type == T_ERROR) {
return NULL;
} else if ((token.type == T_EQUALS || token.type == T_ADD_EQUALS || token.type == T_MINUS_EQUALS
|| token.type == T_ASTERISK_EQUALS || token.type == T_SLASH_EQUALS) && !allowAssignment) {
PrintError2(tokenizer, node, "Variable assignment is not allowed within an expression.\n");
return NULL;
} else if (token.type == T_DOT && TokenLookupPrecedence(token.type) > precedence) {
TokenNext(tokenizer);
Node *operation = (Node *) AllocateFixed(sizeof(Node));
operation->token = TokenNext(tokenizer);
operation->type = T_DOT;
operation->firstChild = node;
node = operation;
if (operation->token.type != T_IDENTIFIER) {
PrintError2(tokenizer, node, "Expected an identifier for the struct field after '.'.\n");
return NULL;
}
} else if (token.type == T_COLON && TokenLookupPrecedence(token.type) > precedence) {
TokenNext(tokenizer);
Token operationName = TokenNext(tokenizer);
if (operationName.type != T_IDENTIFIER && operationName.type != T_ASSERT && operationName.type != T_FLOAT) {
PrintError2(tokenizer, node, "Expected an identifier for the operation name after ':'.\n");
return NULL;
}
if (operationName.textBytes == 4 && 0 == MemoryCompare(operationName.text, "cast", 4)) {
Node *n = node;
node = (Node *) AllocateFixed(sizeof(Node));
node->token = TokenNext(tokenizer);
if (node->token.type == T_ERROR) {
return NULL;
} else if (node->token.type != T_LEFT_ROUND) {
PrintError2(tokenizer, node, "Expected a '(' before the type to cast to.\n");
return NULL;
}
node->firstChild = n;
Node *type = ParseType(tokenizer, false, false, false);
if (!type) return NULL;
node->firstChild->sibling = (Node *) AllocateFixed(sizeof(Node));
node->firstChild->sibling->type = T_CAST_TYPE_WRAPPER;
node->firstChild->sibling->firstChild = type;
Token token = TokenNext(tokenizer);
if (token.type == T_ERROR) {
return NULL;
} else if (token.type != T_RIGHT_ROUND) {
PrintError2(tokenizer, node, "Expected a ')' after the type to cast to.\n");
return NULL;
}
} else {
node = ParseCall(tokenizer, node);
if (!node) return NULL;
}
node->type = T_COLON;
node->token = operationName;
} else if ((token.type == T_EQUALS || token.type == T_ADD || token.type == T_MINUS || token.type == T_BITWISE_XOR
|| token.type == T_ASTERISK || token.type == T_SLASH
|| token.type == T_GREATER_THAN || token.type == T_LESS_THAN
|| token.type == T_BIT_SHIFT_LEFT || token.type == T_BIT_SHIFT_RIGHT
|| token.type == T_BITWISE_OR || token.type == T_BITWISE_AND
|| token.type == T_LT_OR_EQUAL || token.type == T_GT_OR_EQUAL
|| token.type == T_DOUBLE_EQUALS || token.type == T_NOT_EQUALS
|| token.type == T_LOGICAL_AND || token.type == T_LOGICAL_OR)
&& TokenLookupPrecedence(token.type) > precedence) {
Node *operation = (Node *) AllocateFixed(sizeof(Node));
operation->token = TokenNext(tokenizer);
operation->type = operation->token.type;
operation->firstChild = node;
node->sibling = ParseExpression(tokenizer, false, TokenLookupPrecedence(token.type));
if (!node->sibling) return NULL;
node = operation;
} else if (token.type == T_ADD_EQUALS || token.type == T_MINUS_EQUALS
|| token.type == T_ASTERISK_EQUALS || token.type == T_SLASH_EQUALS) {
Node *operation = (Node *) AllocateFixed(sizeof(Node));
operation->token = TokenNext(tokenizer);
operation->type = operation->token.type - T_ADD_EQUALS + T_ADD;
operation->firstChild = node;
node->sibling = ParseExpression(tokenizer, false, TokenLookupPrecedence(token.type));
if (!node->sibling) return NULL;
Node *nodeCopy = (Node *) AllocateFixed(sizeof(Node));
*nodeCopy = *node;
node = operation;
operation = (Node *) AllocateFixed(sizeof(Node));
operation->token = token;
operation->type = T_EQUALS;
operation->firstChild = nodeCopy;
operation->firstChild->sibling = node;
node = operation;
} else if (token.type == T_LEFT_ROUND && TokenLookupPrecedence(token.type) > precedence) {
node = ParseCall(tokenizer, node);
if (!node) return NULL;
} else if (token.type == T_LEFT_SQUARE) {
TokenNext(tokenizer);
Node *index = (Node *) AllocateFixed(sizeof(Node));
index->type = T_INDEX;
index->token = token;
index->firstChild = node;
index->firstChild->sibling = ParseExpression(tokenizer, false, 0);
if (!index->firstChild->sibling) return NULL;
node = index;
Token token = TokenNext(tokenizer);
if (token.type != T_RIGHT_SQUARE) {
Node n = { .token = token };
PrintError2(tokenizer, &n, "Expected a matching closing bracket.\n");
return NULL;
}
} else if (token.type == T_COMMA && TokenLookupPrecedence(token.type) >= precedence && allowAssignment) {
Node *operation = (Node *) AllocateFixed(sizeof(Node));
operation->token = TokenNext(tokenizer);
operation->type = T_SET_GROUP;
operation->firstChild = node;
node->sibling = ParseExpression(tokenizer, true, TokenLookupPrecedence(token.type));
if (!node->sibling) return NULL;
node = operation;
} else {
break;
}
}
return node;
}
Node *ParseIf(Tokenizer *tokenizer) {
Node *node = (Node *) AllocateFixed(sizeof(Node));
node->type = T_IF;
node->token = TokenNext(tokenizer);
Node **link = &node->firstChild;
{
Tokenizer copy = *tokenizer;
Node *type = ParseType(tokenizer, true /* maybe */, false, false);
if (tokenizer->error) {
return NULL;
} else if (type) {
Token name = TokenNext(tokenizer);
if (tokenizer->error) {
return NULL;
} else if (name.type == T_IDENTIFIER) {
Token in = TokenNext(tokenizer);
if (tokenizer->error) {
return NULL;
} else if (in.type == T_IN) {
node->type = T_IF_ERR;
Node *declaration = (Node *) AllocateFixed(sizeof(Node));
declaration->type = T_DECLARE;
declaration->token = name;
declaration->firstChild = type;
node->firstChild = declaration;
link = &declaration->sibling;
}
}
}
if (node->type != T_IF_ERR) {
*tokenizer = copy;
}
}
*link = ParseExpression(tokenizer, false, 0);
if (!(*link)) return NULL;
Token token = TokenPeek(tokenizer);
if (token.type == T_LEFT_FANCY) {
TokenNext(tokenizer);
(*link)->sibling = ParseBlock(tokenizer, false);
if (!(*link)->sibling) return NULL;
} else {
Node *wrapper = (Node *) AllocateFixed(sizeof(Node));
wrapper->type = T_BLOCK;
wrapper->firstChild = ParseExpression(tokenizer, true, 0);
if (!wrapper->firstChild) return NULL;
(*link)->sibling = wrapper;
Token semicolon = TokenNext(tokenizer);
if (semicolon.type != T_SEMICOLON) {
PrintError2(tokenizer, wrapper->firstChild, "Expected a semicolon at the end of the expression.\n");
return NULL;
}
}
token = TokenPeek(tokenizer);
if (token.type == T_ELSE) {
TokenNext(tokenizer);
token = TokenPeek(tokenizer);
if (token.type == T_IF) {
(*link)->sibling->sibling = ParseIf(tokenizer);
if (!(*link)->sibling->sibling) return NULL;
} else if (token.type == T_LEFT_FANCY) {
TokenNext(tokenizer);
(*link)->sibling->sibling = ParseBlock(tokenizer, false);
if (!(*link)->sibling->sibling) return NULL;
} else {
(*link)->sibling->sibling = ParseExpression(tokenizer, true, 0);
if (!(*link)->sibling->sibling) return NULL;
Token semicolon = TokenNext(tokenizer);
if (semicolon.type != T_SEMICOLON) {
PrintError2(tokenizer, (*link)->sibling, "Expected a semicolon at the end of the expression.\n");
return NULL;
}
}
}
// Make sure that the if-err variable has its own scope.
Node *wrapper = (Node *) AllocateFixed(sizeof(Node));
wrapper->type = T_BLOCK;
wrapper->token = node->token;
wrapper->firstChild = node;
return wrapper;
}
Node *ParseVariableDeclarationOrExpression(Tokenizer *tokenizer, bool replMode, bool allowIn) {
Tokenizer copy = *tokenizer;
bool isVariableDeclaration = false;
if (ParseType(tokenizer, true, false /* allow void */, false /* allow tuple */) && TokenNext(tokenizer).type == T_IDENTIFIER) {
Token token = TokenNext(tokenizer);
isVariableDeclaration = token.type == T_EQUALS || token.type == T_SEMICOLON || token.type == T_COMMA || token.type == T_IN;
}
if (tokenizer->error) {
return NULL;
}
*tokenizer = copy;
if (isVariableDeclaration) {
// TODO Variable support in replMode.
if (replMode) {
PrintError(tokenizer, "Variables are not yet supported in the console.\n");
return NULL;
}
Node *declaration = (Node *) AllocateFixed(sizeof(Node));
declaration->type = T_DECLARE;
declaration->firstChild = ParseType(tokenizer, false, false /* allow void */, false /* allow tuple */);
Assert(declaration->firstChild);
declaration->token = TokenNext(tokenizer);
Assert(declaration->token.type == T_IDENTIFIER);
Tokenizer copy = *tokenizer;
Token token = TokenNext(tokenizer);
Assert(token.type == T_EQUALS || token.type == T_SEMICOLON || token.type == T_COMMA || token.type == T_IN);
if (token.type == T_IN && allowIn) {
*tokenizer = copy;
} else if (token.type == T_EQUALS) {
declaration->firstChild->sibling = ParseExpression(tokenizer, false, 0);
if (!declaration->firstChild->sibling) return NULL;
Token semicolon = TokenNext(tokenizer);
if (semicolon.type != T_SEMICOLON) {
PrintError2(tokenizer, declaration, "Expected a semicolon at the end of the variable declaration.\n");
return NULL;
}
} else if (token.type == T_COMMA) {
Node *group = (Node *) AllocateFixed(sizeof(Node));
group->type = T_DECLARE_GROUP;
group->firstChild = declaration;
group->token = declaration->token;
Node **link = &declaration->sibling;
declaration = group;
while (true) {
Node *declaration = (Node *) AllocateFixed(sizeof(Node));
*link = declaration;
link = &declaration->sibling;
declaration->type = T_DECLARE;
declaration->firstChild = ParseType(tokenizer, false, false /* allow void */, false /* allow tuple */);
if (!declaration->firstChild) return NULL;
declaration->token = TokenNext(tokenizer);
if (declaration->token.type != T_IDENTIFIER) {
PrintError2(tokenizer, declaration, "Expected an identifier for the variable name.\n");
return NULL;
}
Token token = TokenNext(tokenizer);
if (token.type == T_ERROR) {
return NULL;
} else if (token.type == T_COMMA) {
// Keep going...
} else if (token.type == T_SEMICOLON) {
break;
} else if (token.type == T_EQUALS) {
group->type = T_DECL_GROUP_AND_SET;
*link = ParseExpression(tokenizer, false, 0);
if (!(*link)) return NULL;
Token semicolon = TokenNext(tokenizer);
if (semicolon.type != T_SEMICOLON) {
PrintError2(tokenizer, declaration, "Expected a semicolon at the end of the variable declaration group.\n");
return NULL;
}
break;
} else {
PrintError2(tokenizer, declaration, "Expected one of ',', '=' or ';' in the variable declaration group.\n");
return NULL;
}
}
}
return declaration;
} else {
Node *expression = ParseExpression(tokenizer, true, 0);
if (!expression) return NULL;
if (replMode) {
Token end = TokenPeek(tokenizer);
if (end.type == T_ERROR) {
return NULL;
} else if (end.type == T_EOF) {
Node *replResult = (Node *) AllocateFixed(sizeof(Node));
replResult->type = T_REPL_RESULT;
replResult->firstChild = expression;
return replResult;
}
}
Token semicolon = TokenNext(tokenizer);
if (semicolon.type != T_SEMICOLON) {
PrintError2(tokenizer, expression, "Expected a semicolon at the end of the expression.\n");
return NULL;
}
return expression;
}
}
Node *ParseBlock(Tokenizer *tokenizer, bool replMode) {
Node *node = (Node *) AllocateFixed(sizeof(Node));
Node **link = &node->firstChild;
node->type = T_BLOCK;
node->token.line = tokenizer->line;
node->token.module = tokenizer->module;
while (true) {
Token token = TokenPeek(tokenizer);
if (token.type == T_ERROR) {
return NULL;
} else if (token.type == (replMode ? T_EOF : T_RIGHT_FANCY)) {
TokenNext(tokenizer);
return node;
} else if (token.type == T_IF) {
Node *node = ParseIf(tokenizer);
if (!node) return NULL;
*link = node;
link = &node->sibling;
} else if (token.type == T_WHILE) {
Node *node = (Node *) AllocateFixed(sizeof(Node));
node->type = T_WHILE;
node->token = TokenNext(tokenizer);
node->firstChild = ParseExpression(tokenizer, false, 0);
if (!node->firstChild) return NULL;
Token token = TokenNext(tokenizer);
if (token.type != T_LEFT_FANCY && token.type != T_SEMICOLON) {
PrintError2(tokenizer, node, "Expected a block or semicolon after the while condition.\n");
return NULL;
}
if (token.type == T_LEFT_FANCY) {
node->firstChild->sibling = ParseBlock(tokenizer, false);
if (!node->firstChild->sibling) return NULL;
} else {
node->firstChild->sibling = (Node *) AllocateFixed(sizeof(Node));
node->firstChild->sibling->type = T_BLOCK;
}
*link = node;
link = &node->sibling;
} else if (token.type == T_FOR) {
// TODO Optional components.
Node *node = (Node *) AllocateFixed(sizeof(Node));
node->type = T_FOR;
node->token = TokenNext(tokenizer);
node->firstChild = ParseVariableDeclarationOrExpression(tokenizer, false /* replMode */, true /* allowIn */);
if (!node->firstChild) return NULL;
Node **siblingLink = NULL;
Token peek = TokenPeek(tokenizer);
if (tokenizer->error) {
return NULL;
} else if (peek.type == T_IN) {
node->type = T_FOR_EACH;
TokenNext(tokenizer);
node->firstChild->sibling = ParseExpression(tokenizer, false, 0);
if (!node->firstChild->sibling) return NULL;
siblingLink = &node->firstChild->sibling->sibling;
} else {
node->firstChild->sibling = ParseExpression(tokenizer, false, 0);
if (!node->firstChild->sibling) return NULL;
Token token = TokenNext(tokenizer);
if (token.type != T_SEMICOLON) {
PrintError2(tokenizer, node, "Expected a semicolon.\n");
return NULL;
}
node->firstChild->sibling->sibling = ParseExpression(tokenizer, true, 0);
if (!node->firstChild->sibling->sibling) return NULL;
siblingLink = &node->firstChild->sibling->sibling->sibling;
}
token = TokenNext(tokenizer);
if (token.type != T_LEFT_FANCY && token.type != T_SEMICOLON) {
PrintError2(tokenizer, node, "Expected a block or semicolon to complete the for statement.\n");
return NULL;
}
if (token.type == T_LEFT_FANCY) {
*siblingLink = ParseBlock(tokenizer, false);
if (!(*siblingLink)) return NULL;
} else {
*siblingLink = (Node *) AllocateFixed(sizeof(Node));
(*siblingLink)->type = T_BLOCK;
}
// Make sure that the for variable has its own scope.
Node *wrapper = (Node *) AllocateFixed(sizeof(Node));
wrapper->type = T_BLOCK;
wrapper->token = node->token;
wrapper->firstChild = node;
*link = wrapper;
link = &wrapper->sibling;
} else if (token.type == T_RETURN || token.type == T_ASSERT || token.type == T_RETERR) {
if (replMode) {
PrintError2(tokenizer, node, "%s statements cannot be used in the console.\n",
token.type == T_RETURN || token.type == T_RETERR ? "Return" : "Assert");
return NULL;
}
Node *node = (Node *) AllocateFixed(sizeof(Node));
node->type = token.type;
node->token = TokenNext(tokenizer);
if (token.type == T_ASSERT || token.type == T_RETERR || TokenPeek(tokenizer).type != T_SEMICOLON) {
node->firstChild = ParseExpression(tokenizer, false, 0);
if (!node->firstChild) return NULL;
if (token.type == T_RETURN && TokenPeek(tokenizer).type == T_COMMA) {
Node *n = node;
node = (Node *) AllocateFixed(sizeof(Node));
node->type = T_RETURN_TUPLE;
node->firstChild = n->firstChild;
Node **argumentLink = &n->firstChild->sibling;
while (TokenPeek(tokenizer).type == T_COMMA) {
TokenNext(tokenizer);
n = ParseExpression(tokenizer, false, 0);
if (!n) return NULL;
*argumentLink = n;
argumentLink = &n->sibling;
}
}
}
*link = node;
link = &node->sibling;
Token semicolon = TokenNext(tokenizer);
if (semicolon.type != T_SEMICOLON) {
PrintError2(tokenizer, node, "Expected a semicolon at the end of the statement.\n");
return NULL;
}
} else if (token.type == T_LEFT_FANCY) {
TokenNext(tokenizer);
Node *block = ParseBlock(tokenizer, false);
if (!block) return NULL;
*link = block;
link = &block->sibling;
} else {
Node *node = ParseVariableDeclarationOrExpression(tokenizer, replMode, false /* allowIn */);
if (!node) return NULL;
*link = node;
link = &node->sibling;
}
}
}
Node *ParseGlobalVariableOrFunctionDefinition(Tokenizer *tokenizer, bool allowGlobalVariables, bool parseFunctionBody) {
Node *type = ParseType(tokenizer, false, true /* allow void */, true /* allow tuple */);
if (!type) {
return NULL;
}
Node *node = (Node *) AllocateFixed(sizeof(Node));
node->token = TokenNext(tokenizer);
if (node->token.type != T_IDENTIFIER) {
if (allowGlobalVariables) {
PrintError2(tokenizer, node, "Expected an identifier for the name of the function or global variable.\n");
} else {
PrintError2(tokenizer, node, "Expected an identifier for the name of the function pointer type.\n");
}
return NULL;
}
Token bracket = TokenPeek(tokenizer);
if (bracket.type == T_ERROR) {
return NULL;
} else if (bracket.type == T_LEFT_ROUND) {
TokenNext(tokenizer);
node->type = T_FUNCTION;
Node *functionPointerType = (Node *) AllocateFixed(sizeof(Node));
functionPointerType->type = T_FUNCPTR;
node->firstChild = functionPointerType;
Node *arguments = (Node *) AllocateFixed(sizeof(Node));
arguments->type = T_ARGUMENTS;
functionPointerType->firstChild = arguments;
arguments->sibling = type;
Node **link = &arguments->firstChild;
int argumentCount = 0;
while (true) {
Token token = TokenPeek(tokenizer);
if (token.type == T_RIGHT_ROUND) {
TokenNext(tokenizer);
break;
}
if (arguments->firstChild) {
Token comma = TokenNext(tokenizer);
if (comma.type != T_COMMA) {
Node n = { .token = comma };
PrintError2(tokenizer, &n, "Expected a comma to separate function arguments.\n");
return NULL;
}
}
Node *argument = (Node *) AllocateFixed(sizeof(Node));
argument->type = T_ARGUMENT;
argument->firstChild = ParseType(tokenizer, false, false /* allow void */, false /* allow tuple */);
if (!argument->firstChild) return NULL;
argument->token = TokenNext(tokenizer);
*link = argument;
link = &argument->sibling;
argumentCount++;
if (argumentCount > FUNCTION_MAX_ARGUMENTS) {
PrintError2(tokenizer, argument, "Functions cannot have more than %d arguments.\n", FUNCTION_MAX_ARGUMENTS);
return NULL;
}
if (argument->token.type != T_IDENTIFIER) {
PrintError2(tokenizer, argument, "Expected an identifier for the name of the function argument.\n");
return NULL;
}
}
if (parseFunctionBody) {
Token token = TokenNext(tokenizer);
if (token.type == T_LEFT_FANCY) {
Node *body = (Node *) AllocateFixed(sizeof(Node));
body->type = T_FUNCBODY;
functionPointerType->sibling = body;
body->firstChild = ParseBlock(tokenizer, false);
if (!body->firstChild) {
return NULL;
}
} else if (token.type == T_EXTCALL) {
Token semicolon = TokenNext(tokenizer);
if (semicolon.type != T_SEMICOLON) {
PrintError(tokenizer, "Expected a semicolon after 'extcall'.\n");
return NULL;
}
node->isExternalCall = true;
} else {
Node n = { .token = token };
PrintError2(tokenizer, &n, "Expected a '{' to start the function body.\n");
return NULL;
}
}
} else if (allowGlobalVariables) {
Token semicolon = TokenNext(tokenizer);
if (semicolon.type == T_PERSIST) {
node->isPersistentVariable = true;
semicolon = TokenNext(tokenizer);
}
if (semicolon.type == T_OPTION) {
node->isOptionVariable = true;
semicolon = TokenNext(tokenizer);
}
if (semicolon.type != T_SEMICOLON) {
PrintError(tokenizer, "Expected a semicolon after the global variable definition.\n");
return NULL;
}
node->type = T_DECLARE;
node->firstChild = type;
} else {
PrintError(tokenizer, "Expected a '(' to start the argument list.\n");
return NULL;
}
return node;
}
Node *ParseRootREPL(Tokenizer *tokenizer) {
// TODO Importing modules.
Node *root = (Node *) AllocateFixed(sizeof(Node));
root->type = T_ROOT;
Node **link = &root->firstChild;
Node *node = (Node *) AllocateFixed(sizeof(Node));
node->type = T_IMPORT;
node->token.type = T_INLINE;
node->token.text = "#inline";
node->token.textBytes = 7;
node->firstChild = (Node *) AllocateFixed(sizeof(Node));
node->firstChild->type = T_IMPORT_PATH;
node->firstChild->token.type = T_STRING_LITERAL;
node->firstChild->token.text = "__base_module__";
node->firstChild->token.textBytes = 15;
*link = node;
link = &node->sibling;
Node *function = (Node *) AllocateFixed(sizeof(Node));
*link = function;
link = &function->sibling;
function->type = T_FUNCTION;
function->token.text = startFunction;
function->token.textBytes = startFunctionBytes;
Node *functionPointerType = (Node *) AllocateFixed(sizeof(Node));
function->firstChild = functionPointerType;
functionPointerType->type = T_FUNCPTR;
Node *functionArguments = (Node *) AllocateFixed(sizeof(Node));
functionPointerType->firstChild = functionArguments;
functionArguments->type = T_ARGUMENTS;
Node *functionReturnType = (Node *) AllocateFixed(sizeof(Node));
functionArguments->sibling = functionReturnType;
functionReturnType->type = T_VOID;
Node *functionBody = (Node *) AllocateFixed(sizeof(Node));
functionPointerType->sibling = functionBody;
functionBody->type = T_FUNCBODY;
functionBody->firstChild = ParseBlock(tokenizer, true);
if (!functionBody->firstChild) {
return NULL;
}
return root;
}
Node *ParseRoot(Tokenizer *tokenizer) {
Node *root = (Node *) AllocateFixed(sizeof(Node));
root->type = T_ROOT;
Node **link = &root->firstChild;
if (!tokenizer->isBaseModule) {
Node *node = (Node *) AllocateFixed(sizeof(Node));
node->type = T_IMPORT;
node->token.type = T_INLINE;
node->token.text = "#inline";
node->token.textBytes = 7;
node->firstChild = (Node *) AllocateFixed(sizeof(Node));
node->firstChild->type = T_IMPORT_PATH;
node->firstChild->token.type = T_STRING_LITERAL;
node->firstChild->token.text = "__base_module__";
node->firstChild->token.textBytes = 15;
*link = node;
link = &node->sibling;
}
while (true) {
Token token = TokenPeek(tokenizer);
if (token.type == T_ERROR) {
return NULL;
} else if (token.type == T_EOF) {
// ScriptPrintNode(root, 0);
return root;
} else if (token.type == T_FUNCTYPE) {
TokenNext(tokenizer);
Node *node = ParseGlobalVariableOrFunctionDefinition(tokenizer, false, false);
if (!node) return NULL;
node->type = T_FUNCTYPE;
*link = node;
link = &node->sibling;
Token semicolon = TokenNext(tokenizer);
if (semicolon.type != T_SEMICOLON) {
PrintError2(tokenizer, node->firstChild->sibling, "Expected a semicolon after the argument list.\n");
return NULL;
}
} else if (token.type == T_HANDLETYPE) {
TokenNext(tokenizer);
Node *node = (Node *) AllocateFixed(sizeof(Node));
node->type = T_HANDLETYPE;
node->token = TokenNext(tokenizer);
*link = node;
link = &node->sibling;
if (node->token.type != T_IDENTIFIER) {
PrintError2(tokenizer, node, "Expected the name of the handletype.\n");
return NULL;
}
Token semicolon = TokenNext(tokenizer);
if (semicolon.type == T_COLON) {
node->firstChild = ParseType(tokenizer, false, false, false);
if (!node->firstChild) return NULL;
semicolon = TokenNext(tokenizer);
node->hasTypeInheritanceParent = true;
}
if (semicolon.type != T_SEMICOLON) {
PrintError2(tokenizer, node, "Expected a semicolon after the handletype identifier.\n");
return NULL;
}
} else if (token.type == T_INTTYPE) {
TokenNext(tokenizer);
Node *node = (Node *) AllocateFixed(sizeof(Node));
node->type = T_INTTYPE;
node->token = TokenNext(tokenizer);
*link = node;
link = &node->sibling;
Node **contentLink = &node->firstChild;
if (node->token.type != T_IDENTIFIER) {
PrintError2(tokenizer, node, "Expected the name of the inttype.\n");
return NULL;
}
Token token = TokenNext(tokenizer);
if (token.type == T_ERROR) {
return NULL;
} else if (token.type == T_COLON) {
Node *parent = ParseType(tokenizer, false, false, false);
if (!parent) return NULL;
*contentLink = parent;
contentLink = &parent->sibling;
token = TokenNext(tokenizer);
node->hasTypeInheritanceParent = true;
}
if (token.type == T_ERROR) {
return NULL;
} else if (token.type != T_LEFT_FANCY) {
PrintError2(tokenizer, node, "Expected a '{' for the inttype contents after the name.\n");
return NULL;
}
while (true) {
Token peek = TokenPeek(tokenizer);
if (peek.type == T_ERROR) return NULL;
if (peek.type == T_RIGHT_FANCY) break;
Node *constant = (Node *) AllocateFixed(sizeof(Node));
constant->token = TokenNext(tokenizer);
constant->type = T_INTTYPE_CONSTANT;
*contentLink = constant;
contentLink = &constant->sibling;
if (constant->token.type != T_IDENTIFIER) {
PrintError2(tokenizer, constant, "Expected an identifier for the constant.\n");
return NULL;
}
if (TokenNext(tokenizer).type != T_EQUALS) {
PrintError2(tokenizer, constant, "Expected '=' between the constant name and the value.\n");
return NULL;
}
constant->firstChild = ParseExpression(tokenizer, false, 0);
if (TokenNext(tokenizer).type != T_SEMICOLON) {
PrintError2(tokenizer, constant, "Expected a semicolon after the constant value.\n");
return NULL;
}
}
TokenNext(tokenizer);
if (TokenNext(tokenizer).type != T_SEMICOLON) {
PrintError2(tokenizer, node, "Expected a semicolon after the inttype body.\n");
return NULL;
}
} else if (token.type == T_STRUCT) {
TokenNext(tokenizer);
Node *node = (Node *) AllocateFixed(sizeof(Node));
node->type = T_STRUCT;
node->token = TokenNext(tokenizer);
*link = node;
link = &node->sibling;
if (node->token.type != T_IDENTIFIER) {
PrintError2(tokenizer, node, "Expected the name of the struct.\n");
return NULL;
}
if (TokenNext(tokenizer).type != T_LEFT_FANCY) {
PrintError2(tokenizer, node, "Expected a '{' for the struct contents after the name.\n");
return NULL;
}
Node **fieldLink = &node->firstChild;
while (true) {
Token peek = TokenPeek(tokenizer);
if (peek.type == T_ERROR) return NULL;
if (peek.type == T_RIGHT_FANCY) break;
Node *type = ParseType(tokenizer, false, false /* allow void */, false /* allow tuple */);
if (!type) return NULL;
Node *field = (Node *) AllocateFixed(sizeof(Node));
field->token = TokenNext(tokenizer);
field->type = T_DECLARE;
field->firstChild = type;
*fieldLink = field;
fieldLink = &field->sibling;
if (field->token.type != T_IDENTIFIER) {
PrintError2(tokenizer, field, "Expected an identifier for the field name.\n");
return NULL;
}
if (TokenNext(tokenizer).type != T_SEMICOLON) {
PrintError2(tokenizer, field, "Expected a semicolon after the field name.\n");
return NULL;
}
}
TokenNext(tokenizer);
if (TokenNext(tokenizer).type != T_SEMICOLON) {
PrintError2(tokenizer, node, "Expected a semicolon after the struct body.\n");
return NULL;
}
} else if (token.type == T_IMPORT) {
Node *node = (Node *) AllocateFixed(sizeof(Node));
node->type = T_IMPORT;
TokenNext(tokenizer);
node->firstChild = ParseExpression(tokenizer, false, 0);
if (!node->firstChild) return NULL;
node->token = TokenNext(tokenizer);
if (node->firstChild->type != T_STRING_LITERAL) {
PrintError2(tokenizer, node, "The path to the script file to import must be a string literal.\n");
return NULL;
} else if (node->token.type != T_IDENTIFIER && node->token.type != T_INLINE) {
PrintError2(tokenizer, node, "Expected an identifier for the name to import the module as.\n");
return NULL;
}
node->firstChild->type = T_IMPORT_PATH;
*link = node;
link = &node->sibling;
if (TokenNext(tokenizer).type != T_SEMICOLON) {
PrintError2(tokenizer, node, "Expected a semicolon after the #import statement.\n");
return NULL;
}
} else if (token.type == T_LIBRARY) {
if (tokenizer->module->library) {
PrintError(tokenizer, "The library has already been set for this module.\n");
return NULL;
} else {
TokenNext(tokenizer);
Token token = TokenNext(tokenizer);
if (token.type != T_STRING_LITERAL) {
if (token.type != T_ERROR) PrintError(tokenizer, "Expected a string literal for the library name.\n");
return NULL;
}
char name[256];
if (token.textBytes > sizeof(name) - 1) {
PrintError(tokenizer, "The library name is too long.\n");
return NULL;
}
MemoryCopy(name, token.text, token.textBytes);
name[token.textBytes] = 0;
tokenizer->module->library = LibraryLoad(name);
if (!tokenizer->module->library) {
return NULL;
}
}
if (TokenNext(tokenizer).type != T_SEMICOLON) {
PrintError(tokenizer, "Expected a semicolon after the #library statement.\n");
return NULL;
}
} else {
Node *node = ParseGlobalVariableOrFunctionDefinition(tokenizer, true, true);
if (!node) return NULL;
*link = node;
link = &node->sibling;
}
}
}
// --------------------------------- Scope management.
bool ScopeIsVariableType(Node *node) {
return node->type == T_DECLARE || node->type == T_FUNCTION || node->type == T_ARGUMENT || node->type == T_PLACEHOLDER;
}
intptr_t ScopeLookupIndex(Node *node, Scope *scope, bool maybe, bool real /* if false, the variable index is returned */) {
uintptr_t j = 0;
for (uintptr_t i = 0; i < scope->entryCount; i++) {
if (scope->entries[i]->token.textBytes == node->token.textBytes
&& 0 == MemoryCompare(scope->entries[i]->token.text, node->token.text, node->token.textBytes)) {
if (!ScopeIsVariableType(scope->entries[i]) && !real) {
break;
}
return j;
}
if (ScopeIsVariableType(scope->entries[i]) || real) {
j++;
}
}
if (!maybe) {
Assert(false);
}
return -1;
}
Node *ScopeLookup(Tokenizer *tokenizer, Node *node, bool maybe) {
Node *ancestor = node;
Scope *scope = NULL;
while (ancestor) {
if (ancestor->scope != scope) {
scope = ancestor->scope;
for (uintptr_t i = 0; i < scope->entryCount; i++) {
if (scope->entries[i]->token.textBytes == node->token.textBytes
&& 0 == MemoryCompare(scope->entries[i]->token.text, node->token.text, node->token.textBytes)) {
if (node->referencesRootScope && scope->entries[i]->parent->type != T_ROOT) {
PrintError2(tokenizer, node, "The identifier '%.*s' is used before it is declared in this scope.\n",
node->token.textBytes, node->token.text);
return NULL;
}
return scope->entries[i];
}
}
}
ancestor = ancestor->parent;
}
if (!maybe) {
PrintError2(tokenizer, node, "Could not find identifier '%.*s' inside its scope.\n", node->token.textBytes, node->token.text);
}
return NULL;
}
bool ScopeCheckNotAlreadyUsed(Tokenizer *tokenizer, Node *node) {
Node *ancestor = node;
Scope *scope = NULL;
while (ancestor) {
if (ancestor->scope != scope) {
scope = ancestor->scope;
for (uintptr_t i = 0; i < scope->entryCount; i++) {
if (scope->entries[i]->token.textBytes == node->token.textBytes
&& 0 == MemoryCompare(scope->entries[i]->token.text, node->token.text, node->token.textBytes)
&& (!scope->isRoot || node->scope == scope)
&& scope->entries[i]->type != T_PLACEHOLDER) {
PrintError2(tokenizer, node, "The identifier '%.*s' was already used in this scope.\n",
node->token.textBytes, node->token.text);
if (scope->entries[i]->type == T_INLINE) {
if (scope->entries[i]->importData->pathBytes == 15
&& 0 == MemoryCompare(scope->entries[i]->importData->path, "__base_module__", scope->entries[i]->importData->pathBytes)) {
PrintDebug("It was declared in base library module.\n",
scope->entries[i]->importData->path);
} else {
PrintDebug("It was imported inline from the module '%s'.\n",
scope->entries[i]->importData->path);
}
}
return false;
}
}
}
ancestor = ancestor->parent;
}
return true;
}
bool ScopeAddEntry(Tokenizer *tokenizer, Scope *scope, Node *node) {
if (node->type == T_IMPORT && node->token.type == T_INLINE) {
return true;
}
node->scope = scope;
if (scope->entryCount == scope->entriesAllocated) {
scope->entriesAllocated = scope->entriesAllocated ? scope->entriesAllocated * 2 : 4;
scope->entries = (Node **) AllocateResize(scope->entries, sizeof(Node *) * scope->entriesAllocated);
}
if (!ScopeCheckNotAlreadyUsed(tokenizer, node)) {
return false;
}
scope->entries[scope->entryCount++] = node;
if (ScopeIsVariableType(node)) {
scope->variableEntryCount++;
}
// Set this here before type checking occurs,
// so that all the declarations in the scope already have their expression type set.
node->expressionType = node->firstChild;
return true;
}
void ASTFreeScopes(Node *node) {
if (node && node->scope) {
node->scope->entries = (Node **) AllocateResize(node->scope->entries, 0);
Node *child = node->firstChild;
while (child) {
ASTFreeScopes(child);
child = child->sibling;
}
}
}
bool ASTSetScopes(Tokenizer *tokenizer, ExecutionContext *context, Node *node, Scope *scope) {
Node *child = node->firstChild;
while (child) {
child->parent = node;
child = child->sibling;
}
if (node->type == T_ROOT || node->type == T_BLOCK || node->type == T_FUNCBODY) {
scope = node->scope = (Scope *) AllocateFixed(sizeof(Scope));
scope->isRoot = node->type == T_ROOT;
} else {
node->scope = scope;
}
if (node->type == T_FUNCBODY) {
Node *argument = node->parent->firstChild->firstChild->firstChild;
while (argument) {
if (!ScopeAddEntry(tokenizer, scope, argument)) {
return false;
}
argument = argument->sibling;
}
}
if (node->type == T_VARIABLE) {
Node *referenced = ScopeLookup(tokenizer, node, true);
if (!referenced || referenced->parent->type == T_ROOT) {
// (If the lookup fails, then it must be a forward declaration, which is only allowed at the root scope level.)
node->referencesRootScope = true;
}
}
{
child = node->firstChild;
while (child) {
if (!ASTSetScopes(tokenizer, context, child, scope)) {
return false;
}
child = child->sibling;
}
}
if ((node->type == T_DECLARE || node->type == T_FUNCTION || node->type == T_FUNCTYPE || node->type == T_INTTYPE || node->type == T_INTTYPE_CONSTANT
|| node->type == T_STRUCT || node->type == T_IMPORT || node->type == T_HANDLETYPE) && node->parent->type != T_STRUCT) {
if (!ScopeAddEntry(tokenizer, scope, node)) {
return false;
}
}
if (node->type == T_FOR_EACH) {
Node *placeholder;
placeholder = (Node *) AllocateFixed(sizeof(Node));
placeholder->type = T_PLACEHOLDER;
Assert(ScopeAddEntry(tokenizer, scope, placeholder));
placeholder = (Node *) AllocateFixed(sizeof(Node));
placeholder->type = T_PLACEHOLDER;
Assert(ScopeAddEntry(tokenizer, scope, placeholder));
}
if (node->type == T_IMPORT) {
ImportData *alreadyImportedModule = importedModules;
while (alreadyImportedModule) {
if (alreadyImportedModule->pathBytes == node->firstChild->token.textBytes
&& 0 == MemoryCompare(alreadyImportedModule->path, node->firstChild->token.text, alreadyImportedModule->pathBytes)) {
break;
}
alreadyImportedModule = alreadyImportedModule->nextImport;
}
if (alreadyImportedModule) {
#if 0
PrintError2(tokenizer, node, "The script at path '%.*s' has already been imported as a module.\n",
node->firstChild->token.textBytes, node->firstChild->token.text);
return false;
#else
node->importData = alreadyImportedModule;
#endif
} else {
char *path = (char *) AllocateFixed(node->firstChild->token.textBytes + 1);
MemoryCopy(path, node->firstChild->token.text, node->firstChild->token.textBytes);
path[node->firstChild->token.textBytes] = 0;
Tokenizer t = { 0 };
void *fileData;
if (node->firstChild->token.textBytes == 15
&& 0 == MemoryCompare(node->firstChild->token.text, "__base_module__", node->firstChild->token.textBytes)) {
fileData = baseModuleSource;
t.inputBytes = sizeof(baseModuleSource) - 1;
t.isBaseModule = true;
} else {
fileData = FileLoad(path, &t.inputBytes);
}
if (!fileData) {
PrintError2(tokenizer, node, "The script at path '%.*s' could not be loaded.\n",
node->firstChild->token.textBytes, node->firstChild->token.text);
return false;
}
node->importData = (ImportData *) AllocateFixed(sizeof(ImportData));
node->importData->fileDataBytes = t.inputBytes;
node->importData->fileData = fileData;
node->importData->path = path;
node->importData->pathBytes = node->firstChild->token.textBytes;
node->importData->parentImport = tokenizer->module;
ImportData *parentImport = tokenizer->module;
while (parentImport) {
if (parentImport->pathBytes == node->firstChild->token.textBytes
&& 0 == MemoryCompare(parentImport->path, node->firstChild->token.text, parentImport->pathBytes)) {
PrintError3("There is a cyclic import dependency.\n");
ImportData *data = node->importData;
while (data->parentImport) {
PrintDebug("- '%s' is imported by '%s'\n", data->path, data->parentImport->path);
data = data->parentImport;
}
return false;
}
parentImport = parentImport->parentImport;
}
t.module = node->importData;
t.input = (const char *) fileData;
t.line = 1;
if (!ScriptLoad(t, context, node->importData, false)) {
return false;
}
}
if (node->token.type == T_INLINE) {
uintptr_t j = 0;
for (uintptr_t i = 0; i < node->importData->rootNode->scope->entryCount; i++) {
if (node->importData->rootNode->scope->entries[i]->type == T_INLINE) {
continue;
}
Node *inlineNode = (Node *) AllocateFixed(sizeof(Node));
inlineNode->token = node->importData->rootNode->scope->entries[i]->token;
inlineNode->type = T_INLINE;
inlineNode->parent = node->parent;
inlineNode->firstChild = node->importData->rootNode->scope->entries[i]->expressionType;
inlineNode->importData = node->importData;
if (ScopeIsVariableType(node->importData->rootNode->scope->entries[i])) {
inlineNode->inlineImportVariableIndex = j++;
} else {
inlineNode->inlineImportVariableIndex = -1;
}
if (!ScopeAddEntry(tokenizer, scope, inlineNode)) {
return false;
}
}
}
}
return true;
}
// --------------------------------- Type checking.
bool ASTMatching(Node *left, Node *right) {
if (!left && !right) {
return true;
} else if (!left || !right) {
return false;
} else if (left->type == T_NULL && (right->type == T_STRUCT || right->type == T_LIST || right->type == T_FUNCTYPE)) {
return true;
} else if (right->type == T_NULL && (left->type == T_STRUCT || left->type == T_LIST || left->type == T_FUNCTYPE)) {
return true;
} else if (left->type == T_ZERO && (right->type == T_INT || right->type == T_INTTYPE || right->type == T_HANDLETYPE)) {
return true;
} else if (right->type == T_ZERO && (left->type == T_INT || left->type == T_INTTYPE || left->type == T_HANDLETYPE)) {
return true;
} else if (left->type != right->type) {
return false;
} else if ((left->type == T_IDENTIFIER || left->type == T_STRUCT || left->type == T_HANDLETYPE || left->type == T_INTTYPE)
&& (left->token.module != right->token.module || left->token.textBytes != right->token.textBytes
|| MemoryCompare(left->token.text, right->token.text, right->token.textBytes))) {
return false;
} else {
Node *childLeft = left->firstChild;
Node *childRight = right->firstChild;
while (true) {
if (!childLeft && !childRight) {
return true;
} else if (!childLeft || !childRight) {
return false;
} else if (!ASTMatching(childLeft, childRight)) {
return false;
} else {
childLeft = childLeft->sibling;
childRight = childRight->sibling;
}
}
}
}
bool ASTIsIntType(Node *node) {
return node && node->type == T_INTTYPE;
}
bool ASTIsManagedType(Node *node) {
return node->type == T_STR || node->type == T_LIST || node->type == T_STRUCT
|| node->type == T_FUNCPTR || node->type == T_FUNCPTR || node->type == T_ERR || node->type == T_ANYTYPE;
}
int ASTGetTypePopCount(Node *node) {
if (node->type == T_TUPLE) {
int count = 0;
Node *child = node->firstChild;
while (child) { count++; child = child->sibling; }
return count;
} else {
return 1;
}
}
bool ASTLookupTypeIdentifiers(Tokenizer *tokenizer, Node *node) {
Node *child = node->firstChild;
while (child) {
if (!ASTLookupTypeIdentifiers(tokenizer, child)) return false;
child = child->sibling;
}
if (node->type == T_FUNCPTR) {
Node *type = node->firstChild->sibling;
if (type->type == T_IDENTIFIER) {
Node *lookup = ScopeLookup(tokenizer, type, false);
if (!lookup) return false;
Node *copy = (Node *) AllocateFixed(sizeof(Node));
*copy = *lookup;
copy->sibling = NULL;
node->firstChild->sibling = copy;
}
}
if (node->type == T_DECLARE || node->type == T_ARGUMENT || node->type == T_NEW || node->type == T_LIST
|| node->type == T_CAST_TYPE_WRAPPER || node->hasTypeInheritanceParent) {
Node *type = node->firstChild;
if (node->hasTypeInheritanceParent && type && type->type != T_IDENTIFIER && type->type != node->type) {
PrintError2(tokenizer, node, "Types can only inherit from similar types.\n");
return false;
}
if (type && type->type == T_IDENTIFIER) {
Node *lookup = ScopeLookup(tokenizer, type, false);
if (!lookup) {
return false;
}
if (node->hasTypeInheritanceParent) {
if (lookup->type != node->type) {
PrintError2(tokenizer, node, "Types can only inherit from similar types.\n");
return false;
}
} else if (!node->expressionType) {
node->expressionType = node->firstChild;
}
Node *previousSibling = node->expressionType->sibling;
if (!lookup) {
return false;
} else if (lookup->type == T_FUNCTYPE) {
MemoryCopy(node->expressionType, lookup->firstChild, sizeof(Node));
} else if (lookup->type == T_STRUCT || lookup->type == T_INTTYPE || lookup->type == T_HANDLETYPE) {
if (node->hasTypeInheritanceParent) {
if (lookup->cycleCheck) {
PrintError2(tokenizer, lookup, "Cyclic type inheritance.\n");
return false;
}
Node *copy = (Node *) AllocateFixed(sizeof(Node));
*copy = *lookup;
copy->sibling = node->firstChild->sibling;
node->firstChild = copy;
node->cycleCheck = true;
if (!ASTLookupTypeIdentifiers(tokenizer, copy)) return false;
node->cycleCheck = false;
} else {
MemoryCopy(node->expressionType, lookup, sizeof(Node));
}
} else {
PrintError2(tokenizer, lookup, "The identifier did not resolve to a type.\n");
return false;
}
node->expressionType->sibling = previousSibling;
}
}
return true;
}
bool ASTImplicitCastIsPossible(Node *targetType, Node *expressionType) {
if (!expressionType || !targetType) {
return false;
} else if (targetType->type == T_ERR && ASTMatching(targetType->firstChild, expressionType)) {
return true;
} else if (targetType->type == T_HANDLETYPE && expressionType->type == T_HANDLETYPE) {
// Only allow implicit casts to the inherited type.
Node *inherit = expressionType->firstChild;
return inherit && (ASTMatching(targetType, inherit) || ASTImplicitCastIsPossible(targetType, inherit));
} else if (targetType->type == T_INTTYPE && expressionType->type == T_INTTYPE) {
// Only allow implicit casts to a type that inherits from this.
Node *inherit = targetType->firstChild;
return inherit && inherit->type != T_INTTYPE_CONSTANT && (ASTMatching(inherit, expressionType) || ASTImplicitCastIsPossible(inherit, expressionType));
} else if (targetType->type == T_ANYTYPE && expressionType->type != T_VOID) {
return true;
} else {
return false;
}
}
Node *ASTImplicitCastApply(Tokenizer *tokenizer, Node *parent, Node *target, Node *expression) {
Node *cast = NULL;
if (target->type == T_ERR && ASTMatching(target->firstChild, expression->expressionType)) {
if (!expression->expressionType || ASTMatching(expression->expressionType, &globalExpressionTypeVoid)) {
PrintError2(tokenizer, parent, "You cannot assign a value of 'void' to 'err[void]'.\nInstead, use the constant '#success'.\n");
return NULL;
}
cast = (Node *) AllocateFixed(sizeof(Node));
cast->type = T_ERR_CAST;
} else if ((target->type == T_HANDLETYPE && expression->expressionType->type == T_HANDLETYPE)
|| (target->type == T_INTTYPE && expression->expressionType->type == T_INTTYPE)) {
return expression; // Nothing needs to be done to cast between handletypes or inttypes.
} else if (target->type == T_ANYTYPE) {
cast = (Node *) AllocateFixed(sizeof(Node));
cast->type = T_ANYTYPE_CAST;
} else {
Assert(false);
return NULL;
}
cast->scope = parent->scope;
cast->parent = parent;
cast->firstChild = expression;
cast->expressionType = target;
return cast;
}
Value ASTNumericLiteralToValue(Node *node) {
// TODO Overflow checking.
Value v = { 0 };
if (node->expressionType == &globalExpressionTypeInt) {
v.i = 0;
for (uintptr_t i = 0; i < node->token.textBytes; i++) {
v.i *= 10;
v.i += node->token.text[i] - '0';
}
} else if (node->expressionType == &globalExpressionTypeFloat) {
bool dot = false;
v.f = 0;
double m = 0.1;
for (uintptr_t i = 0; i < node->token.textBytes; i++) {
if (node->token.text[i] == '.') {
dot = true;
} else if (dot) {
v.f += (node->token.text[i] - '0') * m;
m /= 10;
} else {
v.f *= 10;
v.f += node->token.text[i] - '0';
}
}
} else {
Assert(false);
}
return v;
}
int64_t ASTEvaluateIntConstant(Tokenizer *tokenizer, Node *node, bool *error) {
Assert(ASTMatching(node->expressionType, &globalExpressionTypeInt));
if (node->type == T_NUMERIC_LITERAL) {
return ASTNumericLiteralToValue(node).i;
} else if (node->type == T_ZERO) {
return 0;
} else if (node->type == T_ADD) {
return ASTEvaluateIntConstant(tokenizer, node->firstChild, error) + ASTEvaluateIntConstant(tokenizer, node->firstChild->sibling, error);
} else if (node->type == T_MINUS) {
return ASTEvaluateIntConstant(tokenizer, node->firstChild, error) - ASTEvaluateIntConstant(tokenizer, node->firstChild->sibling, error);
} else if (node->type == T_ASTERISK) {
return ASTEvaluateIntConstant(tokenizer, node->firstChild, error) * ASTEvaluateIntConstant(tokenizer, node->firstChild->sibling, error);
} else if (node->type == T_BITWISE_OR) {
return ASTEvaluateIntConstant(tokenizer, node->firstChild, error) | ASTEvaluateIntConstant(tokenizer, node->firstChild->sibling, error);
} else if (node->type == T_BITWISE_AND) {
return ASTEvaluateIntConstant(tokenizer, node->firstChild, error) & ASTEvaluateIntConstant(tokenizer, node->firstChild->sibling, error);
} else if (node->type == T_BITWISE_XOR) {
return ASTEvaluateIntConstant(tokenizer, node->firstChild, error) ^ ASTEvaluateIntConstant(tokenizer, node->firstChild->sibling, error);
} else if (node->type == T_SLASH) {
int64_t divisor = ASTEvaluateIntConstant(tokenizer, node->firstChild->sibling, error);
if (*error) {
return 0;
} else if (divisor == 0) {
*error = true;
PrintError2(tokenizer, node, "Integer division by zero.\n");
return 0;
} else {
return ASTEvaluateIntConstant(tokenizer, node->firstChild, error) / divisor;
}
} else if (node->type == T_BIT_SHIFT_LEFT || node->type == T_BIT_SHIFT_RIGHT) {
int64_t shift = ASTEvaluateIntConstant(tokenizer, node->firstChild->sibling, error);
if (*error) {
return 0;
} else if (shift < 0 || shift > 63) {
*error = true;
PrintError2(tokenizer, node, "Shift %d is out of range (0..63).\n", shift);
return 0;
} else if (node->type == T_BIT_SHIFT_LEFT) {
return ASTEvaluateIntConstant(tokenizer, node->firstChild, error) << shift;
} else {
return ASTEvaluateIntConstant(tokenizer, node->firstChild, error) >> shift;
}
} else if (node->type == T_NEGATE) {
return -ASTEvaluateIntConstant(tokenizer, node->firstChild, error);
} else if (node->type == T_BITWISE_NOT) {
return ~ASTEvaluateIntConstant(tokenizer, node->firstChild, error);
} else {
Assert(false);
return 0;
}
}
bool ASTIsIntegerConstant(Node *node) {
if (node->type != T_NUMERIC_LITERAL
&& node->type != T_ZERO
&& node->type != T_ADD
&& node->type != T_MINUS
&& node->type != T_ASTERISK
&& node->type != T_SLASH
&& node->type != T_NEGATE
&& node->type != T_BIT_SHIFT_LEFT
&& node->type != T_BIT_SHIFT_RIGHT
&& node->type != T_BITWISE_OR
&& node->type != T_BITWISE_AND
&& node->type != T_BITWISE_XOR
&& node->type != T_BITWISE_NOT) {
return false;
}
if (!ASTMatching(node->expressionType, &globalExpressionTypeInt)) {
return false;
}
Node *child = node->firstChild;
while (child) {
if (!ASTIsIntegerConstant(child)) return false;
child = child->sibling;
}
return true;
}
bool ASTSetTypes(Tokenizer *tokenizer, Node *node) {
Node *child = node->firstChild;
while (child) {
if (child == node) Assert(false);
if (!ASTSetTypes(tokenizer, child)) return false;
child->parent = node;
child = child->sibling;
}
if (node->type == T_ROOT || node->type == T_BLOCK
|| node->type == T_INT || node->type == T_FLOAT || node->type == T_STR
|| node->type == T_LIST || node->type == T_TUPLE || node->type == T_ERR || node->type == T_ANYTYPE
|| node->type == T_BOOL || node->type == T_VOID || node->type == T_IDENTIFIER
|| node->type == T_ARGUMENTS || node->type == T_ARGUMENT
|| node->type == T_STRUCT || node->type == T_FUNCTYPE || node->type == T_IMPORT
|| node->type == T_IMPORT_PATH || node->type == T_INTTYPE || node->type == T_HANDLETYPE
|| node->type == T_FUNCPTR || node->type == T_FUNCBODY || node->type == T_FUNCTION
|| node->type == T_REPL_RESULT || node->type == T_DECLARE_GROUP || node->type == T_CAST_TYPE_WRAPPER) {
} else if (node->type == T_NUMERIC_LITERAL) {
size_t dotCount = 0;
for (uintptr_t i = 0; i < node->token.textBytes; i++) {
if (node->token.text[i] == '.') {
dotCount++;
}
}
if (dotCount == 0) {
node->expressionType = &globalExpressionTypeInt;
} else if (dotCount == 1) {
node->expressionType = &globalExpressionTypeFloat;
} else {
PrintError2(tokenizer, node, "Invalid number. There should either be one decimal place (for a float), or none (for an integer).\n");
return false;
}
} else if (node->type == T_TRUE || node->type == T_FALSE) {
node->expressionType = &globalExpressionTypeBool;
} else if (node->type == T_SUCCESS) {
node->expressionType = &globalExpressionTypeErrVoid;
} else if (node->type == T_NULL || node->type == T_ZERO) {
node->expressionType = node;
} else if (node->type == T_STRING_LITERAL) {
node->expressionType = &globalExpressionTypeStr;
} else if (node->type == T_VARIABLE) {
Node *lookup = ScopeLookup(tokenizer, node, false);
if (!lookup) return false;
node->expressionType = lookup->expressionType;
} else if (node->type == T_STR_INTERPOLATE) {
Node *left = node->firstChild;
Node *expression = node->firstChild->sibling;
Node *right = node->firstChild->sibling->sibling;
Assert(left->type == T_STRING_LITERAL || left->type == T_STR_INTERPOLATE);
Assert(right->type == T_STRING_LITERAL);
Assert(left->expressionType->type == T_STR);
Assert(right->expressionType->type == T_STR);
node->expressionType = &globalExpressionTypeStr;
// TODO Converting more types to strings.
if (!ASTMatching(expression->expressionType, &globalExpressionTypeInt)
&& !ASTMatching(expression->expressionType, &globalExpressionTypeIntList)
&& !ASTMatching(expression->expressionType, &globalExpressionTypeStr)
&& !ASTMatching(expression->expressionType, &globalExpressionTypeFloat)
&& !ASTMatching(expression->expressionType, &globalExpressionTypeBool)
&& !ASTIsIntType(expression->expressionType)) {
PrintError2(tokenizer, expression, "The expression cannot be converted to a string.\n");
return false;
}
} else if (node->type == T_ADD || node->type == T_MINUS || node->type == T_ASTERISK || node->type == T_SLASH
|| node->type == T_GREATER_THAN || node->type == T_LESS_THAN || node->type == T_LT_OR_EQUAL || node->type == T_GT_OR_EQUAL
|| node->type == T_DOUBLE_EQUALS || node->type == T_NOT_EQUALS || node->type == T_LOGICAL_AND || node->type == T_LOGICAL_OR
|| node->type == T_BIT_SHIFT_LEFT || node->type == T_BIT_SHIFT_RIGHT
|| node->type == T_BITWISE_OR || node->type == T_BITWISE_AND || node->type == T_BITWISE_XOR) {
Node *leftType = node->firstChild->expressionType;
Node *rightType = node->firstChild->sibling->expressionType;
bool useRightType = false;
if (!ASTMatching(leftType, rightType)) {
if (leftType && rightType && leftType->type == T_INTTYPE && rightType->type == T_INTTYPE
&& (ASTImplicitCastIsPossible(leftType, rightType) || ASTImplicitCastIsPossible(rightType, leftType))) {
// If both expressions are inttypes with one inheriting from the other, allow an implicit cast.
// Nothing needs to be done to cast between inttypes.
useRightType = ASTImplicitCastIsPossible(rightType, leftType);
} else {
PrintError2(tokenizer, node, "The expression on the left and right side of a binary operator must have the same type.\n");
return false;
}
}
if (node->type == T_ADD) {
if (!ASTMatching(leftType, &globalExpressionTypeInt)
&& !ASTIsIntType(leftType)
&& !ASTMatching(leftType, &globalExpressionTypeFloat)
&& !ASTMatching(leftType, &globalExpressionTypeStr)) {
PrintError2(tokenizer, node, "The add operator expects integers, floats or strings.\n");
return false;
}
} else if (node->type == T_LOGICAL_AND || node->type == T_LOGICAL_OR) {
if (!ASTMatching(leftType, &globalExpressionTypeBool)) {
PrintError2(tokenizer, node, "This operator expects boolean expressions.\n");
return false;
}
} else if (node->type == T_DOUBLE_EQUALS || node->type == T_NOT_EQUALS) {
if (!ASTMatching(leftType, &globalExpressionTypeInt)
&& !ASTMatching(leftType, &globalExpressionTypeFloat)
&& !ASTMatching(leftType, &globalExpressionTypeStr)
&& !ASTMatching(leftType, &globalExpressionTypeBool)
&& !ASTIsIntType(leftType)
&& (!leftType || leftType->type != T_LIST)
&& (!leftType || leftType->type != T_STRUCT)) {
PrintError2(tokenizer, node, "These types cannot be compared.\n");
return false;
}
} else {
if (!ASTMatching(leftType, &globalExpressionTypeInt)
&& !ASTIsIntType(leftType)
&& !ASTMatching(leftType, &globalExpressionTypeFloat)) {
PrintError2(tokenizer, node, "This operator expects either integers or floats.\n");
return false;
}
}
if (node->type == T_GREATER_THAN || node->type == T_LESS_THAN || node->type == T_LT_OR_EQUAL || node->type == T_GT_OR_EQUAL
|| node->type == T_DOUBLE_EQUALS || node->type == T_NOT_EQUALS) {
node->expressionType = &globalExpressionTypeBool;
} else {
node->expressionType = useRightType ? rightType : leftType;
}
} else if (node->type == T_DECLARE) {
if (node->firstChild->sibling && ASTImplicitCastIsPossible(node->firstChild, node->firstChild->sibling->expressionType)) {
Node *cast = ASTImplicitCastApply(tokenizer, node, node->firstChild, node->firstChild->sibling);
if (!cast) return false;
node->firstChild->sibling = cast;
} else if (node->firstChild->sibling && !ASTMatching(node->firstChild, node->firstChild->sibling->expressionType)) {
PrintError2(tokenizer, node, "The type of the variable being assigned does not match the expression.\n");
return false;
}
} else if (node->type == T_DECL_GROUP_AND_SET) {
Node *lastChild = node->firstChild;
while (lastChild->sibling) lastChild = lastChild->sibling;
Node *tuple = lastChild->expressionType;
if (tuple->type != T_TUPLE) {
PrintError2(tokenizer, node, "You can only use '=' in the declaration group with a function that returns a tuple.\n");
return false;
}
Node *child = node->firstChild;
Node *item = tuple->firstChild;
int index = 1;
while (child->sibling && item) {
if (!ASTMatching(child->expressionType, item)) {
PrintError2(tokenizer, node, "The type of value %d in the tuple does not match the declaration type.\n", index);
return false;
}
child = child->sibling;
item = item->sibling;
index++;
}
if ((!item && child->sibling) || (item && !child->sibling)) {
PrintError2(tokenizer, node, "The number of declarations in the group does not match the number of values in the tuple.\n");
return false;
}
} else if (node->type == T_SET_GROUP) {
if (node->parent->type == T_SET_GROUP) {
// Reattach our children at the end of the parent's children.
Assert(!node->sibling);
Node *child = node->parent->firstChild;
while (child->sibling != node) child = child->sibling;
child->sibling = node->firstChild;
} else if (node->parent->type == T_EQUALS) {
Node *expressionType = (Node *) AllocateFixed(sizeof(Node));
expressionType->type = T_TUPLE;
node->expressionType = expressionType;
Node *child = node->firstChild;
Node **link = &expressionType->firstChild;
while (child) {
Node *copy = (Node *) AllocateFixed(sizeof(Node));
*copy = *child->expressionType;
*link = copy;
link = &(*link)->sibling;
child = child->sibling;
}
*link = NULL;
} else {
PrintError2(tokenizer, node, "A comma separated list of expressions can only be used to assign a tuple return value to variables.\n");
return false;
}
} else if (node->type == T_EQUALS) {
if (ASTImplicitCastIsPossible(node->firstChild->expressionType, node->firstChild->sibling->expressionType)) {
Node *cast = ASTImplicitCastApply(tokenizer, node, node->firstChild->expressionType, node->firstChild->sibling);
if (!cast) return false;
node->firstChild->sibling = cast;
} else if (!ASTMatching(node->firstChild->expressionType, node->firstChild->sibling->expressionType)) {
PrintError2(tokenizer, node, "The type of the variable being assigned does not match the expression.\n");
return false;
}
} else if (node->type == T_CALL) {
Node *functionPointer = node->firstChild;
Node *expressionType = functionPointer->expressionType;
if (!expressionType || expressionType->type != T_FUNCPTR) {
PrintError2(tokenizer, functionPointer, "The expression being called is not a function.\n");
return false;
}
node->expressionType = expressionType->firstChild->sibling;
Node *match = expressionType->firstChild->firstChild;
Node **argumentLink = &node->firstChild->sibling->firstChild;
Node *argument = *argumentLink;
size_t index = 1;
while (true) {
if (!argument && !match) {
break;
} else if (!argument || !match) {
PrintError2(tokenizer, node, "The function has a different number of arguments to this.\n");
return false;
} else {
if (ASTImplicitCastIsPossible(match->firstChild, argument->expressionType)) {
Node *cast = ASTImplicitCastApply(tokenizer, node, match->firstChild, argument);
if (!cast) return false;
*argumentLink = cast;
} else if (!ASTMatching(argument->expressionType, match->firstChild)) {
PrintError2(tokenizer, node, "The types for argument %d do not match.\n", index);
return false;
}
match = match->sibling;
argumentLink = &argument->sibling;
argument = *argumentLink;
index++;
}
}
} else if (node->type == T_ASSERT) {
if (!ASTMatching(node->firstChild->expressionType, &globalExpressionTypeBool)
&& !(node->firstChild->expressionType && node->firstChild->expressionType->type == T_ERR)) {
PrintError2(tokenizer, node, "The asserted expression must evaluate to a boolean or error value.\n");
return false;
}
} else if (node->type == T_RETURN || node->type == T_RETERR) {
Node *expressionType = node->firstChild ? node->firstChild->expressionType : &globalExpressionTypeVoid;
Node *function = node->parent;
while (function->type != T_FUNCTION) {
function = function->parent;
}
Node *returnType = function->firstChild->firstChild->sibling;
if (node->firstChild && ASTMatching(returnType, &globalExpressionTypeVoid)) {
PrintError2(tokenizer, node, "The function does not return a value ('void'), but the return statement has a return value.\n");
return false;
}
if (node->type == T_RETURN) {
if (!ASTMatching(expressionType, returnType)) {
if (ASTImplicitCastIsPossible(returnType, node->firstChild->expressionType)) {
Node *cast = ASTImplicitCastApply(tokenizer, node, returnType, node->firstChild);
if (!cast) return false;
node->firstChild = cast;
} else {
PrintError2(tokenizer, node, "The type of the expression does not match the return type of the function.\n");
return false;
}
}
} else {
if (!returnType || returnType->type != T_ERR) {
PrintError2(tokenizer, node, "'reterr' can only be used in functions that return an error value.\n");
return false;
}
if (!expressionType || expressionType->type != T_ERR) {
PrintError2(tokenizer, node, "The expression must be an error value.\n");
return false;
}
}
} else if (node->type == T_RETURN_TUPLE) {
Node *expressionType = (Node *) AllocateFixed(sizeof(Node));
expressionType->type = T_TUPLE;
Node *child = node->firstChild;
Node **link = &expressionType->firstChild;
while (child) {
Node *copy = (Node *) AllocateFixed(sizeof(Node));
*copy = *child->expressionType;
*link = copy;
link = &(*link)->sibling;
child = child->sibling;
}
*link = NULL;
Node *function = node->parent;
while (function->type != T_FUNCTION) {
function = function->parent;
}
Node *returnType = function->firstChild->firstChild->sibling;
if (ASTMatching(returnType, &globalExpressionTypeVoid)) {
PrintError2(tokenizer, node, "The function does not return a value ('void'), but the return statement has a return value.\n");
return false;
}
if (!ASTMatching(expressionType, returnType)) {
PrintError2(tokenizer, node, "The type of the expression does not match the declared return type of the function.\n");
return false;
}
} else if (node->type == T_IF) {
if (!ASTMatching(node->firstChild->expressionType, &globalExpressionTypeBool)
&& !(node->firstChild->expressionType && node->firstChild->expressionType->type == T_ERR)) {
PrintError2(tokenizer, node, "The expression used for the condition must evaluate to a boolean or error value.\n");
return false;
}
} else if (node->type == T_WHILE) {
if (!ASTMatching(node->firstChild->expressionType, &globalExpressionTypeBool)) {
PrintError2(tokenizer, node, "The expression used for the condition must evaluate to a boolean.\n");
return false;
}
} else if (node->type == T_IF_ERR) {
if (!node->firstChild->sibling->expressionType || node->firstChild->sibling->expressionType->type != T_ERR) {
PrintError2(tokenizer, node, "The expression used for the condition must evaluate to a error type.\n");
return false;
}
if (!ASTMatching(node->firstChild->firstChild, node->firstChild->sibling->expressionType->firstChild)) {
PrintError2(tokenizer, node, "The variable declaration type must match the error value.\n");
return false;
}
} else if (node->type == T_FOR) {
if (!ASTMatching(node->firstChild->sibling->expressionType, &globalExpressionTypeBool)) {
PrintError2(tokenizer, node, "The expression used for the condition must evaluate to a boolean.\n");
return false;
}
} else if (node->type == T_FOR_EACH) {
Node *listType = node->firstChild->sibling->expressionType;
bool isStr = listType && ASTMatching(listType, &globalExpressionTypeStr);
if (!listType || (listType->type != T_LIST && !isStr)) {
PrintError2(tokenizer, node, "The expression on the right of 'in' must be a list or string.\n");
return false;
}
if (isStr) {
if (!ASTMatching(node->firstChild->expressionType, &globalExpressionTypeStr)) {
PrintError2(tokenizer, node, "The variable on the left of 'in' must be a 'str' when iterating over a string.\n");
return false;
}
} else {
if (!ASTMatching(node->firstChild->expressionType, listType->firstChild)) {
PrintError2(tokenizer, node, "The variable on the left of 'in' must match the type of the items in the list on the right.\n");
return false;
}
}
Assert(node->scope->entryCount == 3 && node->scope->variableEntryCount == 3
&& node->scope->entries[1]->type == T_PLACEHOLDER && node->scope->entries[2]->type == T_PLACEHOLDER);
node->scope->entries[1]->expressionType = listType;
node->scope->entries[2]->expressionType = &globalExpressionTypeInt;
} else if (node->type == T_INDEX) {
if (!ASTMatching(node->firstChild->expressionType, &globalExpressionTypeStr)
&& node->firstChild->expressionType->type != T_LIST) {
PrintError2(tokenizer, node, "The expression being indexed must be a string or list.\n");
return false;
}
if (!ASTMatching(node->firstChild->sibling->expressionType, &globalExpressionTypeInt)) {
PrintError2(tokenizer, node, "The index must be a integer.\n");
return false;
}
if (ASTMatching(node->firstChild->expressionType, &globalExpressionTypeStr)) {
node->expressionType = &globalExpressionTypeStr;
} else {
node->expressionType = node->firstChild->expressionType->firstChild;
}
} else if (node->type == T_NEW) {
if (node->firstChild->type != T_STRUCT && node->firstChild->type != T_LIST && node->firstChild->type != T_ERR) {
PrintError2(tokenizer, node, "This type is not a struct, list or error. 'new' is used to create new instances of structs, lists and errors.\n");
return false;
}
if (node->firstChild->type == T_ERR && !ASTMatching(node->firstChild->sibling->expressionType, &globalExpressionTypeStr)) {
PrintError2(tokenizer, node, "The error message should be a string.\n");
return false;
}
} else if (node->type == T_DOT) {
bool isStruct = node->firstChild->expressionType->type == T_STRUCT;
if (!isStruct && node->firstChild->expressionType->type != T_IMPORT_PATH) {
PrintError2(tokenizer, node, "This expression is not a struct or an imported module. "
"You cannot use the '.' operator on it.\n");
return false;
}
if (isStruct) {
Node *structure = node->firstChild->expressionType;
Node *field = structure->firstChild;
while (field) {
if (field->token.textBytes == node->token.textBytes &&
0 == MemoryCompare(field->token.text, node->token.text, node->token.textBytes)) {
break;
}
field = field->sibling;
}
if (!field) {
PrintError2(tokenizer, node, "The field '%.*s' is not in the struct '%.*s'.\n",
node->token.textBytes, node->token.text, structure->token.textBytes, structure->token.text);
return false;
}
node->expressionType = field->firstChild;
} else {
ImportData *importData = node->firstChild->expressionType->parent->importData;
intptr_t index = ScopeLookupIndex(node, importData->rootNode->scope, true, true);
if (index == -1) {
PrintError2(tokenizer, node, "The variable or function '%.*s' is not in the imported module '%s'.\n",
node->token.textBytes, node->token.text, importData->path);
return false;
}
node->expressionType = importData->rootNode->scope->entries[index]->expressionType;
}
} else if (node->type == T_COLON) {
Node *expressionType = node->firstChild->expressionType;
if (!expressionType) {
PrintError2(tokenizer, node, "This is not an expression.\n");
return false;
}
bool isList = expressionType->type == T_LIST;
bool isStr = expressionType->type == T_STR;
bool isFuncPtr = expressionType->type == T_FUNCPTR;
bool isErr = expressionType->type == T_ERR;
bool isInt = expressionType->type == T_INT;
bool isFloat = expressionType->type == T_FLOAT;
bool isAnyType = expressionType->type == T_ANYTYPE;
if (!isList && !isStr & !isFuncPtr && !isErr && !isInt && !isFloat && !isAnyType) {
PrintError2(tokenizer, node, "This type does not have any ':' operations.\n");
return false;
}
Token token = node->token;
Node *arguments[2] = { 0 };
bool returnsItem = false, returnsInt = false, returnsBool = false, returnsStr = false, returnsFloat = false, simple = true;
uint8_t op;
if (isList && KEYWORD("resize")) arguments[0] = &globalExpressionTypeInt, op = T_OP_RESIZE;
else if (isList && KEYWORD("add")) arguments[0] = expressionType->firstChild, op = T_OP_ADD;
else if (isList && KEYWORD("insert")) arguments[0] = expressionType->firstChild, arguments[1] = &globalExpressionTypeInt, op = T_OP_INSERT;
else if (isList && KEYWORD("insert_many")) arguments[0] = &globalExpressionTypeInt, arguments[1] = &globalExpressionTypeInt, op = T_OP_INSERT_MANY;
else if (isList && KEYWORD("delete")) arguments[0] = &globalExpressionTypeInt, op = T_OP_DELETE;
else if (isList && KEYWORD("find_and_delete")) arguments[0] = expressionType->firstChild, op = T_OP_FIND_AND_DELETE, returnsBool = true;
else if (isList && KEYWORD("find")) arguments[0] = expressionType->firstChild, op = T_OP_FIND, returnsInt = true;
else if (isList && KEYWORD("delete_many")) arguments[0] = &globalExpressionTypeInt, arguments[1] = &globalExpressionTypeInt, op = T_OP_DELETE_MANY;
else if (isList && KEYWORD("delete_last")) op = T_OP_DELETE_LAST;
else if (isList && KEYWORD("delete_all")) op = T_OP_DELETE_ALL;
else if (isList && KEYWORD("first")) returnsItem = true, op = T_OP_FIRST;
else if (isList && KEYWORD("last")) returnsItem = true, op = T_OP_LAST;
else if ((isList || isStr) && KEYWORD("len")) returnsInt = true, op = T_OP_LEN;
else if (isInt && KEYWORD("float")) returnsFloat = true, op = T_OP_INT_TO_FLOAT;
else if (isFloat && KEYWORD("truncate")) returnsInt = true, op = T_OP_FLOAT_TRUNCATE;
else if (isErr && KEYWORD("success")) returnsBool = true, op = T_OP_SUCCESS;
else if (isErr && KEYWORD("assert")) returnsItem = true, op = T_OP_ASSERT_ERR;
else if (isErr && KEYWORD("error")) returnsStr = true, op = T_OP_ERROR;
else if (isErr && KEYWORD("default")) arguments[0] = expressionType->firstChild, returnsItem = true, op = T_OP_DEFAULT; // TODO Warn if the expression has side effects.
else if (isFuncPtr && KEYWORD("async")) {
if (expressionType->firstChild->firstChild) {
PrintError2(tokenizer, node, "The function pointer should take no arguments. Use ':curry(...)' to set them before ':async()'.\n");
return false;
} else if (!ASTMatching(expressionType->firstChild->sibling, &globalExpressionTypeVoid)) {
PrintError2(tokenizer, node, "The function pointer should not return anything. Use ':discard()' or ':assert()' before ':async()'.\n");
return false;
}
// TODO Allow currying here, for convenience.
op = T_OP_ASYNC;
returnsInt = true;
}
else if (isFuncPtr && (KEYWORD("assert") || KEYWORD("discard"))) {
if (KEYWORD("assert")) {
op = T_OP_ASSERT;
if (!ASTMatching(expressionType->firstChild->sibling, &globalExpressionTypeBool)) {
PrintError2(tokenizer, node, "The return value of the function must be a bool to assert it.\n");
return false;
}
} else {
op = T_OP_DISCARD;
if (ASTMatching(expressionType->firstChild->sibling, &globalExpressionTypeVoid)) {
PrintError2(tokenizer, node, "The return value cannot be discarded from a function that already returns void.\n");
return false;
}
if (expressionType->firstChild->sibling && expressionType->firstChild->sibling->type == T_TUPLE) {
// TODO Remove this restriction?
PrintError2(tokenizer, node, "The discard operation cannot be used on a function returning a tuple.\n");
return false;
}
}
node->expressionType = (Node *) AllocateFixed(sizeof(Node));
node->expressionType->type = T_FUNCPTR;
node->expressionType->firstChild = (Node *) AllocateFixed(sizeof(Node));
MemoryCopy(node->expressionType->firstChild, expressionType->firstChild, sizeof(Node));
node->expressionType->firstChild->sibling = &globalExpressionTypeVoid;
simple = false;
}
else if (isFuncPtr && KEYWORD("curry")) {
if (!expressionType->firstChild->firstChild) {
PrintError2(tokenizer, node, "The function pointer doesn't take any arguments.\n");
return false;
} else if (!ASTMatching(expressionType->firstChild->firstChild->firstChild, node->firstChild->sibling->firstChild->expressionType)) {
PrintError2(tokenizer, node, "The curried argument does not match the type of the first argument.\n");
return false;
} else if (node->firstChild->sibling->firstChild->sibling) {
// TODO Allow currying multiple arguments together.
PrintError2(tokenizer, node, "You can only curry one argument at a time.\n");
return false;
}
node->expressionType = (Node *) AllocateFixed(sizeof(Node));
node->expressionType->type = T_FUNCPTR;
node->expressionType->firstChild = (Node *) AllocateFixed(sizeof(Node));
MemoryCopy(node->expressionType->firstChild, expressionType->firstChild, sizeof(Node));
node->expressionType->firstChild->firstChild = node->expressionType->firstChild->firstChild->sibling;
node->expressionType->firstChild->sibling = expressionType->firstChild->sibling;
op = T_OP_CURRY;
simple = false;
}
else if (isAnyType && KEYWORD("cast")) {
Assert(node->firstChild->sibling->type == T_CAST_TYPE_WRAPPER);
node->expressionType = node->firstChild->sibling->firstChild;
op = T_OP_CAST;
simple = false;
}
else {
PrintError2(tokenizer, node, "This type does not have an operation called '%.*s'.\n", token.textBytes, token.text);
return false;
}
if (op == T_OP_FIND_AND_DELETE && ASTMatching(arguments[0], &globalExpressionTypeFloat)) {
PrintError2(tokenizer, node, "The 'find_and_delete' operation cannot be used with floats.\n");
return false;
} else if (op == T_OP_FIND && ASTMatching(arguments[0], &globalExpressionTypeFloat)) {
PrintError2(tokenizer, node, "The 'find' operation cannot be used with floats.\n");
return false;
}
if (op == T_OP_DEFAULT && ASTMatching(arguments[0], &globalExpressionTypeVoid)) {
PrintError2(tokenizer, node, "The 'default' operation cannot be used with error values of type void.\n");
return false;
} else if (op == T_OP_ASSERT_ERR && ASTMatching(expressionType->firstChild, &globalExpressionTypeVoid)) {
PrintError2(tokenizer, node, "The 'assert' operation cannot be used with error values of type void.\n");
return false;
}
if (op == T_OP_FIND_AND_DELETE && ASTMatching(arguments[0], &globalExpressionTypeStr)) {
op = T_OP_FIND_AND_DEL_STR;
} else if (op == T_OP_FIND && ASTMatching(arguments[0], &globalExpressionTypeStr)) {
op = T_OP_FIND_STR;
}
if (simple) {
Node *argument1 = node->firstChild->sibling->firstChild;
Node *argument2 = argument1 ? argument1->sibling : NULL;
Node *argument3 = argument2 ? argument2->sibling : NULL;
if (argument3 || (argument2 && !arguments[1]) || (argument1 && !arguments[0])
|| (!argument2 && arguments[1]) || (!argument1 && arguments[0])) {
PrintError2(tokenizer, node, "Incorrect number of arguments for the operation '%.*s'.\n", token.textBytes, token.text);
return false;
}
if (argument1 && !ASTMatching(argument1->expressionType, arguments[0])) {
PrintError2(tokenizer, node, "Incorrect first argument type for the operation '%.*s'.\n", token.textBytes, token.text);
return false;
}
if (argument2 && !ASTMatching(argument2->expressionType, arguments[1])) {
PrintError2(tokenizer, node, "Incorrect second argument type for the operation '%.*s'.\n", token.textBytes, token.text);
return false;
}
node->expressionType = returnsItem ? expressionType->firstChild
: returnsInt ? &globalExpressionTypeInt
: returnsStr ? &globalExpressionTypeStr
: returnsFloat ? &globalExpressionTypeFloat
: returnsBool ? &globalExpressionTypeBool : NULL;
}
node->operationType = op;
} else if (node->type == T_LOGICAL_NOT) {
if (!ASTMatching(node->firstChild->expressionType, &globalExpressionTypeBool)) {
PrintError2(tokenizer, node, "Expected a bool for the logical not '!' operator.\n");
return false;
}
node->expressionType = &globalExpressionTypeBool;
} else if (node->type == T_NEGATE || node->type == T_BITWISE_NOT) {
if (!ASTMatching(node->firstChild->expressionType, &globalExpressionTypeInt)
&& !ASTMatching(node->firstChild->expressionType, &globalExpressionTypeFloat)) {
PrintError2(tokenizer, node, "Expected a int or float for the %s operator.\n", node->type == T_NEGATE ? "unary negate '-'" : "bitwise not '~'");
return false;
}
node->expressionType = node->firstChild->expressionType;
} else if (node->type == T_LIST_LITERAL) {
if (!node->firstChild) {
// TODO Support empty list literals?
PrintError2(tokenizer, node, "Empty list literals are not allowed. Instead, put 'new T[]' where 'T' is the item type.\n");
return false;
}
Node *item = node->firstChild;
node->expressionType = (Node *) AllocateFixed(sizeof(Node));
node->expressionType->type = T_LIST;
Node *copy = (Node *) AllocateFixed(sizeof(Node));
*copy = *item->expressionType;
copy->sibling = NULL;
node->expressionType->firstChild = copy;
while (item) {
if (!ASTMatching(node->expressionType->firstChild, item->expressionType)) {
PrintError2(tokenizer, item, "The type of this item is different to the ones before it in the list.\n");
return false;
}
item = item->sibling;
}
} else if (node->type == T_AWAIT) {
if (!ASTMatching(node->firstChild->expressionType, &globalExpressionTypeIntList)) {
PrintError2(tokenizer, node, "Expected a list of task IDs to wait on.\n");
return false;
}
node->expressionType = &globalExpressionTypeInt;
} else if (node->type == T_INTTYPE_CONSTANT) {
if (!ASTIsIntegerConstant(node->firstChild)) {
PrintError2(tokenizer, node, "The expression is not a constant integer.\n");
return false;
}
node->expressionType = node->parent;
} else {
PrintDebug("ASTSetTypes %d\n", node->type);
Assert(false);
}
return true;
}
bool ASTCheckForReturnStatements(Tokenizer *tokenizer, Node *node) {
if (node->type == T_ROOT) {
Node *child = node->firstChild;
while (child) {
if (!ASTCheckForReturnStatements(tokenizer, child)) return false;
child->parent = node;
child = child->sibling;
}
} else if (node->type == T_FUNCTION) {
if (node->firstChild->sibling && node->firstChild->firstChild->sibling
&& node->firstChild->firstChild->sibling->type != T_VOID) {
Assert(node->firstChild->sibling->type == T_FUNCBODY);
return ASTCheckForReturnStatements(tokenizer, node->firstChild->sibling);
}
} else if (node->type == T_BLOCK || node->type == T_FUNCBODY) {
Node *lastStatement = node->firstChild;
while (lastStatement && lastStatement->sibling) {
lastStatement = lastStatement->sibling;
}
if (lastStatement && (lastStatement->type == T_RETURN || lastStatement->type == T_RETURN_TUPLE)) {
return true;
} else if (lastStatement && (lastStatement->type == T_IF || lastStatement->type == T_IF_ERR || lastStatement->type == T_BLOCK)) {
return ASTCheckForReturnStatements(tokenizer, lastStatement);
} else {
PrintError2(tokenizer, node, "This block needs to end with a return statement.\n");
return false;
}
} else if (node->type == T_IF) {
if (!node->firstChild->sibling->sibling) {
PrintError2(tokenizer, node, "This function returns a value, so this if statement needs an else block which ends with a return statement.\n");
return false;
}
return ASTCheckForReturnStatements(tokenizer, node->firstChild->sibling)
&& ASTCheckForReturnStatements(tokenizer, node->firstChild->sibling->sibling);
} else if (node->type == T_IF_ERR) {
if (!node->firstChild->sibling->sibling->sibling) {
PrintError2(tokenizer, node, "This function returns a value, so this if statement needs an else block which ends with a return statement.\n");
return false;
}
return ASTCheckForReturnStatements(tokenizer, node->firstChild->sibling->sibling)
&& ASTCheckForReturnStatements(tokenizer, node->firstChild->sibling->sibling->sibling);
}
return true;
}
// --------------------------------- Code generation.
void FunctionBuilderAppend(FunctionBuilder *builder, const void *buffer, size_t bytes) {
if (builder->dataBytes + bytes > builder->dataAllocated) {
builder->dataAllocated = 2 * builder->dataAllocated + bytes;
builder->data = (uint8_t *) AllocateResize(builder->data, builder->dataAllocated);
}
for (uintptr_t i = 0; i < bytes; i++) {
builder->data[builder->dataBytes + i] = ((const uint8_t *) buffer)[i];
}
builder->dataBytes += bytes;
}
void FunctionBuilderAddLineNumber(FunctionBuilder *builder, Node *node) {
if (builder->lineNumberCount == builder->lineNumbersAllocated) {
builder->lineNumbersAllocated = 2 * builder->lineNumbersAllocated + 4;
builder->lineNumbers = (LineNumber *) AllocateResize(builder->lineNumbers, builder->lineNumbersAllocated * sizeof(LineNumber));
}
Node *ancestor = node;
while (ancestor) {
if (ancestor->type == T_FUNCTION) {
builder->lineNumbers[builder->lineNumberCount].function = &ancestor->token;
}
ancestor = ancestor->parent;
}
builder->lineNumbers[builder->lineNumberCount].importData = builder->importData;
builder->lineNumbers[builder->lineNumberCount].instructionPointer = builder->dataBytes;
builder->lineNumbers[builder->lineNumberCount].lineNumber = node->token.line;
builder->lineNumberCount++;
}
bool FunctionBuilderVariable(Tokenizer *tokenizer, FunctionBuilder *builder, Node *node, bool forAssignment) {
Node *ancestor = node;
Scope *scope = NULL;
int32_t index = -1;
Scope *rootScope = NULL;
uintptr_t globalVariableOffset = builder->globalVariableOffset;
bool inlineImport = false;
bool isIntConstant = false;
Value intConstantValue;
while (ancestor) {
if (ancestor->scope != scope) {
scope = ancestor->scope;
if (scope->isRoot) {
rootScope = scope;
}
if (index != -1) {
index += scope->variableEntryCount;
}
uintptr_t j = 0;
for (uintptr_t i = 0; i < scope->entryCount; i++) {
if (scope->entries[i]->token.textBytes == node->token.textBytes
&& 0 == MemoryCompare(scope->entries[i]->token.text, node->token.text, node->token.textBytes)
&& index == -1) {
index = j;
builder->isPersistentVariable = scope->entries[i]->isPersistentVariable;
if (scope->entries[i]->type == T_INLINE) {
index = scope->entries[i]->inlineImportVariableIndex;
Assert(index != -1);
globalVariableOffset = scope->entries[i]->importData->globalVariableOffset;
inlineImport = true;
} else if (scope->entries[i]->type == T_INTTYPE_CONSTANT) {
isIntConstant = true;
bool error = false;
intConstantValue.i = ASTEvaluateIntConstant(tokenizer, scope->entries[i]->firstChild, &error);
if (error) return false;
}
if (scope->entries[i]->type != T_DECLARE && forAssignment) {
PrintError2(tokenizer, node, "A value cannot be assigned to this. "
"Try putting a variable name here.\n");
return false;
}
}
if (ScopeIsVariableType(scope->entries[i])) {
j++;
}
}
}
ancestor = ancestor->parent;
}
FunctionBuilderAddLineNumber(builder, node);
if (isIntConstant) {
uint8_t b = T_NUMERIC_LITERAL;
FunctionBuilderAppend(builder, &b, sizeof(b));
FunctionBuilderAppend(builder, &intConstantValue, sizeof(intConstantValue));
} else {
if (index >= (int32_t) rootScope->variableEntryCount && !inlineImport) {
index = rootScope->variableEntryCount - index - 1;
} else {
index += globalVariableOffset;
}
if (forAssignment) {
builder->scopeIndex = index;
builder->isDotAssignment = false;
builder->isListAssignment = false;
} else {
FunctionBuilderAppend(builder, &node->type, sizeof(node->type));
FunctionBuilderAppend(builder, &index, sizeof(index));
}
}
return true;
}
bool FunctionBuilderRecurse(Tokenizer *tokenizer, Node *node, FunctionBuilder *builder, bool forAssignment) {
if (forAssignment) {
if (node->type == T_VARIABLE || node->type == T_DOT || node->type == T_INDEX) {
// Supported.
} else {
PrintError2(tokenizer, node, "A value cannot be assigned to this expression. Try putting a variable name here.\n");
return false;
}
}
if (node->type == T_FUNCBODY || node->type == T_BLOCK) {
if (node->scope->variableEntryCount > 10000) {
PrintError2(tokenizer, node, "There are too many variables in this scope (the maximum is 10000).\n");
return false;
}
uint16_t entryCount = node->scope->variableEntryCount;
FunctionBuilderAddLineNumber(builder, node);
FunctionBuilderAppend(builder, &node->type, sizeof(node->type));
FunctionBuilderAppend(builder, &entryCount, sizeof(entryCount));
for (uintptr_t i = 0; i < node->scope->entryCount; i++) {
Node *entry = node->scope->entries[i];
if (ScopeIsVariableType(entry)) {
bool isManaged = ASTIsManagedType(entry->expressionType);
FunctionBuilderAppend(builder, &isManaged, sizeof(isManaged));
}
}
} else if (node->type == T_EQUALS || node->type == T_DECLARE || node->type == T_DECL_GROUP_AND_SET) {
if (node->firstChild->sibling) {
Node *variables[FUNCTION_MAX_ARGUMENTS];
uintptr_t variableCount = 0;
bool setGroup = node->type == T_EQUALS && node->firstChild->type == T_SET_GROUP;
Node *lastChild = setGroup ? node->firstChild->firstChild : node->firstChild;
while (setGroup ? lastChild : lastChild->sibling) {
Assert(variableCount != FUNCTION_MAX_ARGUMENTS);
variables[variableCount++] = lastChild;
lastChild = lastChild->sibling;
}
if (!FunctionBuilderRecurse(tokenizer, setGroup ? node->firstChild->sibling : lastChild, builder, false)) {
return false;
}
while (variableCount) {
Node *child = variables[--variableCount];
builder->isPersistentVariable = false;
if (node->type == T_DECLARE || node->type == T_DECL_GROUP_AND_SET) {
if (!FunctionBuilderVariable(tokenizer, builder, node->type == T_DECL_GROUP_AND_SET ? child : node, true)) {
return false;
}
} else if (!FunctionBuilderRecurse(tokenizer, child, builder, true)) {
return false;
}
FunctionBuilderAddLineNumber(builder, node);
uint8_t b = builder->isListAssignment ? T_EQUALS_LIST : builder->isDotAssignment ? T_EQUALS_DOT : T_EQUALS;
FunctionBuilderAppend(builder, &b, sizeof(b));
if (!builder->isListAssignment) {
FunctionBuilderAppend(builder, &builder->scopeIndex, sizeof(builder->scopeIndex));
}
if (builder->isPersistentVariable) {
b = T_PERSIST;
FunctionBuilderAppend(builder, &b, sizeof(b));
}
child = child->sibling;
}
}
return true;
} else if (node->type == T_CALL) {
Node *argument = node->firstChild->sibling->firstChild;
Node *arguments[FUNCTION_MAX_ARGUMENTS];
size_t argumentCount = 0;
while (argument) {
arguments[argumentCount++] = argument;
argument = argument->sibling;
}
for (uintptr_t i = 0; i < argumentCount; i++) {
if (!FunctionBuilderRecurse(tokenizer, arguments[argumentCount - i - 1], builder, false)) {
return false;
}
}
if (!FunctionBuilderRecurse(tokenizer, node->firstChild, builder, false)) return false;
FunctionBuilderAddLineNumber(builder, node);
FunctionBuilderAppend(builder, &node->type, sizeof(node->type));
return true;
} else if (node->type == T_WHILE) {
int32_t start = builder->dataBytes;
if (!FunctionBuilderRecurse(tokenizer, node->firstChild, builder, false)) return false;
FunctionBuilderAddLineNumber(builder, node);
uint8_t b = T_IF;
FunctionBuilderAppend(builder, &b, sizeof(b));
uintptr_t writeOffset = builder->dataBytes;
uint32_t zero = 0;
FunctionBuilderAppend(builder, &zero, sizeof(zero));
if (!FunctionBuilderRecurse(tokenizer, node->firstChild->sibling, builder, false)) return false;
b = T_BRANCH;
FunctionBuilderAppend(builder, &b, sizeof(b));
int32_t delta = start - builder->dataBytes;
FunctionBuilderAppend(builder, &delta, sizeof(delta));
delta = builder->dataBytes - writeOffset;
MemoryCopy(builder->data + writeOffset, &delta, sizeof(delta));
return true;
} else if (node->type == T_FOR) {
Node *declare = node->firstChild;
Node *condition = node->firstChild->sibling;
Node *increment = node->firstChild->sibling->sibling;
Node *body = node->firstChild->sibling->sibling->sibling;
if (declare->type != T_DECLARE && declare->type != T_EQUALS) {
PrintError2(tokenizer, node, "The first section of a for statement must be a variable declaration or an assignment.\n");
return false;
}
if (!FunctionBuilderRecurse(tokenizer, declare, builder, false)) return false;
int32_t start = builder->dataBytes;
if (!FunctionBuilderRecurse(tokenizer, condition, builder, false)) return false;
FunctionBuilderAddLineNumber(builder, node);
uint8_t b = T_IF;
FunctionBuilderAppend(builder, &b, sizeof(b));
uintptr_t writeOffset = builder->dataBytes;
uint32_t zero = 0;
FunctionBuilderAppend(builder, &zero, sizeof(zero));
if (!FunctionBuilderRecurse(tokenizer, body, builder, false)) return false;
if (!FunctionBuilderRecurse(tokenizer, increment, builder, false)) return false;
if (increment->expressionType && increment->expressionType->type != T_VOID) {
if (increment->type == T_CALL) {
uint8_t b = T_POP;
for (int i = 0; i < ASTGetTypePopCount(increment->expressionType); i++) {
FunctionBuilderAppend(builder, &b, sizeof(b));
}
} else {
PrintError2(tokenizer, increment, "The result of the expression is unused.\n");
return false;
}
}
b = T_BRANCH;
FunctionBuilderAppend(builder, &b, sizeof(b));
int32_t delta = start - builder->dataBytes;
FunctionBuilderAppend(builder, &delta, sizeof(delta));
delta = builder->dataBytes - writeOffset;
MemoryCopy(builder->data + writeOffset, &delta, sizeof(delta));
return true;
} else if (node->type == T_FOR_EACH) {
Node *declare = node->firstChild;
Node *list = node->firstChild->sibling;
Node *body = node->firstChild->sibling->sibling;
bool isStr = ASTMatching(list->expressionType, &globalExpressionTypeStr);
if (declare->type != T_DECLARE) {
PrintError2(tokenizer, node, "The left of a for-in statement must be a variable declaration.\n");
return false;
}
// Get the scope index base.
Node *variableNode = (Node *) AllocateFixed(sizeof(Node));
variableNode->type = T_IDENTIFIER;
variableNode->token = declare->token;
variableNode->scope = node->scope;
variableNode->parent = node;
size_t oldDataBytes = builder->dataBytes;
FunctionBuilderVariable(tokenizer, builder, variableNode, true);
Assert(oldDataBytes == builder->dataBytes);
int32_t scopeIndexBase = builder->scopeIndex;
// Declare the iteration variable.
if (!FunctionBuilderRecurse(tokenizer, declare, builder, false)) return false;
// Push the starting index of 0.
uint8_t b = T_ZERO;
FunctionBuilderAppend(builder, &b, sizeof(b));
// Push the list.
if (!FunctionBuilderRecurse(tokenizer, list, builder, false)) return false;
int32_t start = builder->dataBytes;
// Check whether the index is less than the list length.
// Stack: list, index, ...
b = T_SWAP;
FunctionBuilderAppend(builder, &b, sizeof(b));
// Stack: index, list, ...
b = T_DUP;
FunctionBuilderAppend(builder, &b, sizeof(b));
// Stack: index, index, list, ...
b = T_ROT3;
FunctionBuilderAppend(builder, &b, sizeof(b));
// Stack: list, index, index, ...
b = T_DUP;
FunctionBuilderAppend(builder, &b, sizeof(b));
// Stack: list, list, index, index, ...
b = T_OP_LEN;
FunctionBuilderAppend(builder, &b, sizeof(b));
// Stack: length, list, index, index, ...
b = T_ROT3;
FunctionBuilderAppend(builder, &b, sizeof(b));
// Stack: index, length, list, index, ...
b = T_GREATER_THAN;
FunctionBuilderAppend(builder, &b, sizeof(b));
// Stack: comparison, list, index, ...
FunctionBuilderAddLineNumber(builder, node);
b = T_IF;
FunctionBuilderAppend(builder, &b, sizeof(b));
uintptr_t writeOffset = builder->dataBytes;
uint32_t zero = 0;
FunctionBuilderAppend(builder, &zero, sizeof(zero));
// Get the value out of the list.
// Stack: list, index, ...
b = T_SWAP;
FunctionBuilderAppend(builder, &b, sizeof(b));
// Stack: index, list, ...
b = T_DUP;
FunctionBuilderAppend(builder, &b, sizeof(b));
// Stack: index, index, list, ...
b = T_ROT3;
FunctionBuilderAppend(builder, &b, sizeof(b));
// Stack: list, index, index, ...
b = T_DUP;
FunctionBuilderAppend(builder, &b, sizeof(b));
// Stack: list, list, index, index, ...
b = T_ROT3;
FunctionBuilderAppend(builder, &b, sizeof(b));
// Stack: index, list, list, index, ...
b = isStr ? T_INDEX : T_INDEX_LIST;
FunctionBuilderAppend(builder, &b, sizeof(b));
// Stack: list, index, ...
// Set the iteration variable.
b = T_EQUALS;
FunctionBuilderAppend(builder, &b, sizeof(b));
FunctionBuilderAppend(builder, &scopeIndexBase, sizeof(scopeIndexBase));
// Save the list and index.
int32_t scopeIndexList = scopeIndexBase - 1;
int32_t scopeIndexIndex = scopeIndexBase - 2;
b = T_EQUALS;
FunctionBuilderAppend(builder, &b, sizeof(b));
FunctionBuilderAppend(builder, &scopeIndexList, sizeof(scopeIndexList));
FunctionBuilderAppend(builder, &b, sizeof(b));
FunctionBuilderAppend(builder, &scopeIndexIndex, sizeof(scopeIndexIndex));
// Output the body.
if (!FunctionBuilderRecurse(tokenizer, body, builder, false)) return false;
// Load the list and index.
b = T_VARIABLE;
FunctionBuilderAppend(builder, &b, sizeof(b));
FunctionBuilderAppend(builder, &scopeIndexIndex, sizeof(scopeIndexIndex));
FunctionBuilderAppend(builder, &b, sizeof(b));
FunctionBuilderAppend(builder, &scopeIndexList, sizeof(scopeIndexList));
// Increment the index.
// Stack: list, index, ...
b = T_SWAP;
FunctionBuilderAppend(builder, &b, sizeof(b));
// Stack: index, list, ...
b = T_NUMERIC_LITERAL;
FunctionBuilderAppend(builder, &b, sizeof(b));
Value v;
v.i = 1;
FunctionBuilderAppend(builder, &v, sizeof(v));
// Stack: 1, index, list, ...
b = T_ADD;
FunctionBuilderAppend(builder, &b, sizeof(b));
// Stack: new index, list, ...
b = T_SWAP;
FunctionBuilderAppend(builder, &b, sizeof(b));
// Stack: list, new index, ...
b = T_BRANCH;
FunctionBuilderAppend(builder, &b, sizeof(b));
int32_t delta = start - builder->dataBytes;
FunctionBuilderAppend(builder, &delta, sizeof(delta));
delta = builder->dataBytes - writeOffset;
MemoryCopy(builder->data + writeOffset, &delta, sizeof(delta));
// Pop the list and index.
b = T_POP;
FunctionBuilderAppend(builder, &b, sizeof(b));
FunctionBuilderAppend(builder, &b, sizeof(b));
return true;
} else if (node->type == T_IF) {
if (!FunctionBuilderRecurse(tokenizer, node->firstChild, builder, false)) return false;
if (node->firstChild->expressionType->type == T_ERR) {
uint8_t b = T_OP_SUCCESS;
FunctionBuilderAppend(builder, &b, sizeof(b));
}
FunctionBuilderAddLineNumber(builder, node);
FunctionBuilderAppend(builder, &node->type, sizeof(node->type));
uintptr_t writeOffset = builder->dataBytes, writeOffsetElse = 0;
uint32_t zero = 0;
FunctionBuilderAppend(builder, &zero, sizeof(zero));
if (!FunctionBuilderRecurse(tokenizer, node->firstChild->sibling, builder, false)) return false;
if (node->firstChild->sibling->sibling) {
uint8_t b = T_BRANCH;
FunctionBuilderAppend(builder, &b, sizeof(b));
writeOffsetElse = builder->dataBytes;
FunctionBuilderAppend(builder, &zero, sizeof(zero));
}
int32_t delta = builder->dataBytes - writeOffset;
MemoryCopy(builder->data + writeOffset, &delta, sizeof(delta));
if (node->firstChild->sibling->sibling) {
if (!FunctionBuilderRecurse(tokenizer, node->firstChild->sibling->sibling, builder, false)) return false;
delta = builder->dataBytes - writeOffsetElse;
MemoryCopy(builder->data + writeOffsetElse, &delta, sizeof(delta));
}
return true;
} else if (node->type == T_IF_ERR) {
uint8_t b;
if (!FunctionBuilderRecurse(tokenizer, node->firstChild->sibling, builder, false)) return false;
FunctionBuilderAddLineNumber(builder, node);
b = T_DUP;
FunctionBuilderAppend(builder, &b, sizeof(b));
b = T_OP_SUCCESS;
FunctionBuilderAppend(builder, &b, sizeof(b));
b = T_IF;
FunctionBuilderAppend(builder, &b, sizeof(b));
uintptr_t writeOffset = builder->dataBytes, writeOffsetElse = 0;
uint32_t zero = 0;
FunctionBuilderAppend(builder, &zero, sizeof(zero));
b = T_OP_ASSERT_ERR;
FunctionBuilderAppend(builder, &b, sizeof(b));
Node *variableNode = (Node *) AllocateFixed(sizeof(Node));
variableNode->type = T_IDENTIFIER;
variableNode->token = node->firstChild->token;
variableNode->scope = node->scope;
variableNode->parent = node;
FunctionBuilderVariable(tokenizer, builder, variableNode, true);
b = T_EQUALS;
FunctionBuilderAppend(builder, &b, sizeof(b));
FunctionBuilderAppend(builder, &builder->scopeIndex, sizeof(builder->scopeIndex));
if (!FunctionBuilderRecurse(tokenizer, node->firstChild->sibling->sibling, builder, false)) return false;
b = T_BRANCH;
FunctionBuilderAppend(builder, &b, sizeof(b));
writeOffsetElse = builder->dataBytes;
FunctionBuilderAppend(builder, &zero, sizeof(zero));
int32_t delta = builder->dataBytes - writeOffset;
MemoryCopy(builder->data + writeOffset, &delta, sizeof(delta));
b = T_POP;
FunctionBuilderAppend(builder, &b, sizeof(b));
if (node->firstChild->sibling->sibling->sibling) {
if (!FunctionBuilderRecurse(tokenizer, node->firstChild->sibling->sibling->sibling, builder, false)) return false;
}
delta = builder->dataBytes - writeOffsetElse;
MemoryCopy(builder->data + writeOffsetElse, &delta, sizeof(delta));
return true;
} else if (node->type == T_LOGICAL_OR || node->type == T_LOGICAL_AND) {
if (!FunctionBuilderRecurse(tokenizer, node->firstChild, builder, false)) return false;
FunctionBuilderAppend(builder, &node->type, sizeof(node->type));
uintptr_t writeOffset = builder->dataBytes;
uint32_t zero = 0;
FunctionBuilderAppend(builder, &zero, sizeof(zero));
if (!FunctionBuilderRecurse(tokenizer, node->firstChild->sibling, builder, false)) return false;
int32_t delta = builder->dataBytes - writeOffset;
MemoryCopy(builder->data + writeOffset, &delta, sizeof(delta));
return true;
} else if (node->type == T_NEW) {
if (node->firstChild->type == T_ERR) {
FunctionBuilderRecurse(tokenizer, node->firstChild->sibling, builder, false);
}
FunctionBuilderAddLineNumber(builder, node);
FunctionBuilderAppend(builder, &node->type, sizeof(node->type));
int16_t fieldCount = 0;
if (node->firstChild->type == T_LIST) {
fieldCount = ASTIsManagedType(node->firstChild->firstChild) ? -2 : -1;
} else if (node->firstChild->type == T_ERR) {
fieldCount = ASTIsManagedType(node->firstChild->firstChild) ? -4 : -3;
} else {
Node *child = node->firstChild->firstChild;
while (child) {
if (fieldCount == 1000) {
PrintError2(tokenizer, child, "The struct exceeds the maximum number of fields (1000).\n");
return false;
}
fieldCount++;
child = child->sibling;
}
}
FunctionBuilderAppend(builder, &fieldCount, sizeof(fieldCount));
return true;
} else if (node->type == T_COLON) {
FunctionBuilderRecurse(tokenizer, node->firstChild, builder, false);
if (node->operationType != T_OP_CAST) {
Node *argument = node->firstChild->sibling->firstChild;
while (argument) {
FunctionBuilderRecurse(tokenizer, argument, builder, false);
argument = argument->sibling;
}
}
FunctionBuilderAddLineNumber(builder, node);
FunctionBuilderAppend(builder, &node->operationType, sizeof(node->operationType));
if (node->operationType == T_OP_CAST) {
FunctionBuilderAppend(builder, &node->expressionType, sizeof(node->expressionType));
}
return true;
} else if (node->type == T_LIST_LITERAL) {
// Step 1: Create the list.
uint8_t b = T_NEW;
int16_t isManaged = ASTIsManagedType(node->expressionType->firstChild) ? -2 : -1;
FunctionBuilderAddLineNumber(builder, node);
FunctionBuilderAppend(builder, &b, sizeof(b));
FunctionBuilderAppend(builder, &isManaged, sizeof(isManaged));
// Step 2: Resize the list.
uint32_t size = 0;
Node *item = node->firstChild;
while (item) { size++; item = item->sibling; }
b = T_DUP;
FunctionBuilderAppend(builder, &b, sizeof(b));
b = T_NUMERIC_LITERAL;
FunctionBuilderAppend(builder, &b, sizeof(b));
Value v;
v.i = size;
FunctionBuilderAppend(builder, &v, sizeof(v));
b = T_OP_RESIZE;
FunctionBuilderAppend(builder, &b, sizeof(b));
// Step 3: Populate the list.
item = node->firstChild;
uint32_t i = 0;
while (item) {
b = T_DUP;
FunctionBuilderAppend(builder, &b, sizeof(b));
FunctionBuilderRecurse(tokenizer, item, builder, false);
b = T_SWAP;
FunctionBuilderAppend(builder, &b, sizeof(b));
b = T_NUMERIC_LITERAL;
FunctionBuilderAppend(builder, &b, sizeof(b));
Value v;
v.i = i++;
FunctionBuilderAppend(builder, &v, sizeof(v));
b = T_EQUALS_LIST;
FunctionBuilderAppend(builder, &b, sizeof(b));
item = item->sibling;
}
return true;
}
Node *child = node->firstChild;
while (child) {
if (!FunctionBuilderRecurse(tokenizer, child, builder, false)) {
return false;
}
if (node->type == T_BLOCK && child->expressionType && child->expressionType->type != T_VOID) {
if (child->type == T_CALL || child->type == T_AWAIT
|| (child->type == T_COLON && child->operationType == T_OP_FIND_AND_DELETE)
|| (child->type == T_COLON && child->operationType == T_OP_FIND_AND_DEL_STR)) {
uint8_t b = T_POP;
for (int i = 0; i < ASTGetTypePopCount(child->expressionType); i++) {
FunctionBuilderAppend(builder, &b, sizeof(b));
}
} else if (child->type == T_DECLARE || child->type == T_EQUALS) {
} else {
PrintError2(tokenizer, child, "The result of the expression is unused.\n");
return false;
}
}
child = child->sibling;
}
if (node->type == T_FUNCBODY || node->type == T_BLOCK) {
uint8_t b = T_EXIT_SCOPE;
uint16_t entryCount = node->scope->variableEntryCount;
FunctionBuilderAddLineNumber(builder, node);
FunctionBuilderAppend(builder, &b, sizeof(b));
FunctionBuilderAppend(builder, &entryCount, sizeof(entryCount));
b = T_END_FUNCTION;
if (node->type == T_FUNCBODY) FunctionBuilderAppend(builder, &b, sizeof(b));
} else if (node->type == T_DECLARE_GROUP) {
} else if (node->type == T_RETURN || node->type == T_RETURN_TUPLE) {
uint8_t b = T_END_FUNCTION;
FunctionBuilderAddLineNumber(builder, node);
FunctionBuilderAppend(builder, &b, sizeof(b));
} else if (node->type == T_RETERR) {
uint8_t b;
FunctionBuilderAddLineNumber(builder, node);
b = T_DUP;
FunctionBuilderAppend(builder, &b, sizeof(b));
b = T_OP_SUCCESS;
FunctionBuilderAppend(builder, &b, sizeof(b));
b = T_LOGICAL_NOT;
FunctionBuilderAppend(builder, &b, sizeof(b));
b = T_IF;
FunctionBuilderAppend(builder, &b, sizeof(b));
int32_t delta = 9;
FunctionBuilderAppend(builder, &delta, sizeof(delta));
b = T_OP_ERROR;
FunctionBuilderAppend(builder, &b, sizeof(b));
b = T_NEW;
FunctionBuilderAppend(builder, &b, sizeof(b));
int16_t newType = -3;
FunctionBuilderAppend(builder, &newType, sizeof(newType));
b = T_END_FUNCTION;
FunctionBuilderAppend(builder, &b, sizeof(b));
b = T_POP;
FunctionBuilderAppend(builder, &b, sizeof(b));
} else if (node->type == T_NULL || node->type == T_LOGICAL_NOT || node->type == T_AWAIT || node->type == T_ERR_CAST || node->type == T_ZERO) {
FunctionBuilderAddLineNumber(builder, node);
FunctionBuilderAppend(builder, &node->type, sizeof(node->type));
} else if (node->type == T_ANYTYPE_CAST) {
FunctionBuilderAddLineNumber(builder, node);
FunctionBuilderAppend(builder, &node->type, sizeof(node->type));
FunctionBuilderAppend(builder, &node->firstChild->expressionType, sizeof(node->firstChild->expressionType));
} else if (node->type == T_ASSERT) {
FunctionBuilderAddLineNumber(builder, node);
if (node->firstChild->expressionType->type == T_ERR) {
uint8_t b = T_OP_ASSERT_ERR;
FunctionBuilderAppend(builder, &b, sizeof(b));
b = T_POP;
FunctionBuilderAppend(builder, &b, sizeof(b));
} else {
FunctionBuilderAppend(builder, &node->type, sizeof(node->type));
}
} else if (node->type == T_ADD || node->type == T_MINUS || node->type == T_ASTERISK || node->type == T_SLASH || node->type == T_NEGATE || node->type == T_BITWISE_NOT
|| node->type == T_BIT_SHIFT_LEFT || node->type == T_BIT_SHIFT_RIGHT
|| node->type == T_BITWISE_OR || node->type == T_BITWISE_AND || node->type == T_BITWISE_XOR) {
uint8_t b = node->expressionType->type == T_FLOAT ? node->type - T_ADD + T_FLOAT_ADD
: node->expressionType->type == T_STR ? T_CONCAT : node->type;
FunctionBuilderAddLineNumber(builder, node);
FunctionBuilderAppend(builder, &b, sizeof(b));
} else if (node->type == T_STR_INTERPOLATE) {
Node *type = node->firstChild->sibling->expressionType;
uint8_t b = type->type == T_STR ? T_INTERPOLATE_STR
: type->type == T_FLOAT ? T_INTERPOLATE_FLOAT
: (type->type == T_INT || ASTIsIntType(type)) ? T_INTERPOLATE_INT
: (type->type == T_LIST && type->firstChild->type == T_INT) ? T_INTERPOLATE_ILIST
: type->type == T_BOOL ? T_INTERPOLATE_BOOL : T_ERROR;
Assert(b != T_ERROR);
FunctionBuilderAddLineNumber(builder, node);
FunctionBuilderAppend(builder, &b, sizeof(b));
} else if (node->type == T_LESS_THAN || node->type == T_GREATER_THAN || node->type == T_LT_OR_EQUAL || node->type == T_GT_OR_EQUAL
|| node->type == T_DOUBLE_EQUALS || node->type == T_NOT_EQUALS) {
uint8_t b = node->firstChild->expressionType->type == T_STR ? node->type - T_DOUBLE_EQUALS + T_STR_DOUBLE_EQUALS
: node->firstChild->expressionType->type == T_FLOAT ? node->type - T_GREATER_THAN + T_FLOAT_GREATER_THAN : node->type;
FunctionBuilderAddLineNumber(builder, node);
FunctionBuilderAppend(builder, &b, sizeof(b));
} else if (node->type == T_VARIABLE) {
if (!FunctionBuilderVariable(tokenizer, builder, node, forAssignment)) {
return false;
}
} else if (node->type == T_INDEX) {
if (forAssignment) {
if (node->firstChild->expressionType->type == T_STR) {
PrintError2(tokenizer, node->firstChild, "Strings cannot be modified.\n");
return false;
} else {
builder->isListAssignment = true;
builder->isDotAssignment = false;
}
} else {
uint8_t b = node->firstChild->expressionType->type == T_STR ? T_INDEX : T_INDEX_LIST;
FunctionBuilderAddLineNumber(builder, node);
FunctionBuilderAppend(builder, &b, sizeof(b));
}
} else if (node->type == T_DOT) {
bool isStruct = node->firstChild->expressionType->type == T_STRUCT;
if (isStruct) {
Node *field = node->firstChild->expressionType->firstChild;
int16_t fieldIndex = 0;
while (field) {
if (field->token.textBytes == node->token.textBytes &&
0 == MemoryCompare(field->token.text, node->token.text, node->token.textBytes)) {
break;
}
field = field->sibling;
fieldIndex++;
}
if (ASTIsManagedType(field->firstChild)) {
fieldIndex = -1 - fieldIndex;
}
if (forAssignment) {
builder->scopeIndex = fieldIndex;
builder->isDotAssignment = true;
builder->isListAssignment = false;
} else {
FunctionBuilderAddLineNumber(builder, node);
FunctionBuilderAppend(builder, &node->type, sizeof(node->type));
FunctionBuilderAppend(builder, &fieldIndex, sizeof(fieldIndex));
}
} else {
if (forAssignment) {
PrintError2(tokenizer, node, "You cannot directly modify a variable from an imported module.\n");
return false;
} else {
Node *importStatement = node->firstChild->expressionType->parent;
Assert(importStatement->type == T_IMPORT);
uint32_t realIndex = ScopeLookupIndex(node, importStatement->importData->rootNode->scope, false, true);
Node *declarationNode = importStatement->importData->rootNode->scope->entries[realIndex];
FunctionBuilderAddLineNumber(builder, node);
uint8_t b = T_POP;
FunctionBuilderAppend(builder, &b, sizeof(b));
if (declarationNode->type == T_INTTYPE_CONSTANT) {
bool error = false;
Value intConstantValue;
intConstantValue.i = ASTEvaluateIntConstant(tokenizer, declarationNode->firstChild, &error);
if (error) return false;
uint8_t b = T_NUMERIC_LITERAL;
FunctionBuilderAppend(builder, &b, sizeof(b));
FunctionBuilderAppend(builder, &intConstantValue, sizeof(intConstantValue));
} else {
uint32_t index = ScopeLookupIndex(node, importStatement->importData->rootNode->scope, false, false);
index += importStatement->importData->globalVariableOffset;
b = T_VARIABLE;
FunctionBuilderAppend(builder, &b, sizeof(b));
FunctionBuilderAppend(builder, &index, sizeof(index));
}
}
}
} else if (node->type == T_NUMERIC_LITERAL) {
FunctionBuilderAddLineNumber(builder, node);
FunctionBuilderAppend(builder, &node->type, sizeof(node->type));
Value v = ASTNumericLiteralToValue(node);
FunctionBuilderAppend(builder, &v, sizeof(v));
} else if (node->type == T_STRING_LITERAL) {
FunctionBuilderAddLineNumber(builder, node);
FunctionBuilderAppend(builder, &node->type, sizeof(node->type));
uint32_t textBytes = node->token.textBytes;
FunctionBuilderAppend(builder, &textBytes, sizeof(textBytes));
FunctionBuilderAppend(builder, node->token.text, textBytes);
} else if (node->type == T_TRUE || node->type == T_FALSE) {
FunctionBuilderAddLineNumber(builder, node);
uint8_t b = T_NUMERIC_LITERAL;
FunctionBuilderAppend(builder, &b, sizeof(b));
Value v;
v.i = node->type == T_TRUE ? 1 : 0;
FunctionBuilderAppend(builder, &v, sizeof(v));
} else if (node->type == T_SUCCESS) {
uint8_t b = T_NUMERIC_LITERAL;
FunctionBuilderAppend(builder, &b, sizeof(b));
Value v;
v.i = 0;
FunctionBuilderAppend(builder, &v, sizeof(v));
b = T_ERR_CAST;
FunctionBuilderAppend(builder, &b, sizeof(b));
} else if (node->type == T_REPL_RESULT) {
if (!ASTMatching(node->firstChild->expressionType, &globalExpressionTypeVoid)) {
FunctionBuilderAppend(builder, &node->type, sizeof(node->type));
}
if (builder->replResultType) {
PrintError2(tokenizer, node, "Multiple REPL results are not allowed.\n");
return false;
}
builder->replResultType = node->firstChild->expressionType;
} else {
PrintDebug("FunctionBuilderRecurse %d\n", node->type);
Assert(false);
}
return true;
}
bool ASTGenerate(Tokenizer *tokenizer, Node *root, ExecutionContext *context) {
Node *child = root->firstChild;
context->functionData->globalVariableOffset = context->globalVariableCount;
context->globalVariableCount += root->scope->variableEntryCount;
context->globalVariables = (Value *) AllocateResize(context->globalVariables, sizeof(Value) * context->globalVariableCount);
context->globalVariableIsManaged = (bool *) AllocateResize(context->globalVariableIsManaged, sizeof(Value) * context->globalVariableCount);
for (uintptr_t i = 0; i < root->scope->variableEntryCount; i++) {
context->globalVariables[context->functionData->globalVariableOffset + i].i = 0;
context->globalVariableIsManaged[context->functionData->globalVariableOffset + i] = false;
}
while (child) {
if (child->type == T_FUNCTION) {
uintptr_t variableIndex = context->functionData->globalVariableOffset + ScopeLookupIndex(child, root->scope, false, false);
uintptr_t heapIndex = HeapAllocate(context);
context->globalVariableIsManaged[variableIndex] = true;
context->heap[heapIndex].type = T_FUNCPTR;
context->heap[heapIndex].lambdaID = context->functionData->dataBytes;
context->globalVariables[variableIndex].i = heapIndex;
if (child->isExternalCall && child->token.module->library) {
char name[256];
if (child->token.textBytes > sizeof(name) - 1) {
PrintError2(tokenizer, child, "The function name is too long to be loaded from a library.\n");
return NULL;
}
MemoryCopy(name, child->token.text, child->token.textBytes);
name[child->token.textBytes] = 0;
void *address = LibraryGetAddress(child->token.module->library, name);
if (!address) return false;
uint8_t b = T_LIBCALL;
FunctionBuilderAppend(context->functionData, &b, sizeof(b));
FunctionBuilderAppend(context->functionData, &address, sizeof(address));
} else if (child->isExternalCall) {
uint8_t b = T_EXTCALL;
uint16_t index = 0xFFFF;
for (uintptr_t i = 0; i < sizeof(externalFunctions) / sizeof(externalFunctions[0]); i++) {
bool match = true;
for (uintptr_t j = 0; j <= child->token.textBytes; j++) {
if (externalFunctions[i].cName[j] != (j == child->token.textBytes ? 0 : child->token.text[j])) {
match = false;
break;
}
}
if (match) {
index = i;
break;
}
}
if (index == 0xFFFF) {
PrintError2(tokenizer, child, "No such external function '%.*s'.\n", child->token.textBytes, child->token.text);
return false;
}
FunctionBuilderAppend(context->functionData, &b, sizeof(b));
FunctionBuilderAppend(context->functionData, &index, sizeof(index));
} else {
if (!FunctionBuilderRecurse(tokenizer, child->firstChild->sibling, context->functionData, false)) return false;
}
} else if (child->type == T_DECLARE) {
if (child->isPersistentVariable && context->mainModule != tokenizer->module) {
PrintError2(tokenizer, child, "Persistent variables are not allowed in imported modules.\n");
return false;
}
context->globalVariables[context->functionData->globalVariableOffset + ScopeLookupIndex(child, root->scope, false, false)].i = 0;
context->globalVariableIsManaged[context->functionData->globalVariableOffset + ScopeLookupIndex(child, root->scope, false, false)] = ASTIsManagedType(child->expressionType);
}
child = child->sibling;
}
return true;
}
// --------------------------------- Main script execution.
void HeapGarbageCollectMark(ExecutionContext *context, uintptr_t index) {
start:;
Assert(index < context->heapEntriesAllocated);
if (context->heap[index].gcMark) return;
context->heap[index].gcMark = true;
if (context->heap[index].type == T_EOF || context->heap[index].type == T_STR || context->heap[index].type == T_FUNCPTR) {
// Nothing else to mark.
} else if (context->heap[index].type == T_STRUCT) {
for (uintptr_t i = 0; i < context->heap[index].fieldCount; i++) {
if (((uint8_t *) context->heap[index].fields)[-1 - i]) {
HeapGarbageCollectMark(context, context->heap[index].fields[i].i);
}
}
} else if (context->heap[index].type == T_LIST) {
if (context->heap[index].internalValuesAreManaged) {
for (uintptr_t i = 0; i < context->heap[index].length; i++) {
HeapGarbageCollectMark(context, context->heap[index].list[i].i);
}
}
} else if (context->heap[index].type == T_CONCAT) {
uintptr_t index1 = context->heap[index].concat1;
uintptr_t index2 = context->heap[index].concat2;
if (context->heap[index1].type == T_CONCAT) {
HeapGarbageCollectMark(context, index2);
index = index1;
} else {
HeapGarbageCollectMark(context, index1);
index = index2;
}
goto start;
} else if (context->heap[index].type == T_OP_DISCARD || context->heap[index].type == T_OP_ASSERT) {
HeapGarbageCollectMark(context, context->heap[index].lambdaID);
} else if (context->heap[index].type == T_OP_CURRY) {
HeapGarbageCollectMark(context, context->heap[index].lambdaID);
if (context->heap[index].internalValuesAreManaged) {
HeapGarbageCollectMark(context, context->heap[index].curryValue.i);
}
} else if (context->heap[index].type == T_ERR) {
if (context->heap[index].internalValuesAreManaged) {
HeapGarbageCollectMark(context, context->heap[index].errorValue.i);
}
} else if (context->heap[index].type == T_ANYTYPE) {
if (context->heap[index].internalValuesAreManaged) {
HeapGarbageCollectMark(context, context->heap[index].anyValue.i);
}
} else {
Assert(false);
}
}
void HeapFreeEntry(ExecutionContext *context, uintptr_t i) {
if (context->heap[i].type == T_STR) {
AllocateResize(context->heap[i].text, 0);
} else if (context->heap[i].type == T_STRUCT) {
AllocateResize((uint8_t *) context->heap[i].fields - context->heap[i].fieldCount, 0);
} else if (context->heap[i].type == T_LIST) {
AllocateResize(context->heap[i].list, 0);
} else if (context->heap[i].type == T_OP_DISCARD || context->heap[i].type == T_OP_ASSERT
|| context->heap[i].type == T_FUNCPTR || context->heap[i].type == T_OP_CURRY
|| context->heap[i].type == T_CONCAT || context->heap[i].type == T_ERR
|| context->heap[i].type == T_ANYTYPE) {
} else {
Assert(false);
}
context->heap[i].type = T_ERROR;
}
uintptr_t HeapAllocate(ExecutionContext *context) {
if (!context->heapFirstUnusedEntry) {
// All heapEntriesAllocated entries are in use.
for (uintptr_t i = 0; i < context->heapEntriesAllocated; i++) {
context->heap[i].gcMark = false;
}
for (uintptr_t i = 0; i < context->globalVariableCount; i++) {
if (context->globalVariableIsManaged[i]) {
HeapGarbageCollectMark(context, context->globalVariables[i].i);
}
}
CoroutineState *c = context->allCoroutines;
while (c) {
for (uintptr_t i = 0; i < c->localVariableCount; i++) {
if (c->localVariableIsManaged[i]) {
HeapGarbageCollectMark(context, c->localVariables[i].i);
}
}
for (uintptr_t i = 0; i < c->stackPointer; i++) {
if (c->stackIsManaged[i]) {
HeapGarbageCollectMark(context, c->stack[i].i);
}
}
c = c->nextCoroutine;
}
uintptr_t *link = &context->heapFirstUnusedEntry;
uintptr_t reclaimed = 0;
for (uintptr_t i = 1; i < context->heapEntriesAllocated; i++) {
if (!context->heap[i].gcMark && !context->heap[i].externalReferenceCount) {
// PrintDebug("\033[0;32mFreeing index %d...\033[0m\n", i);
HeapFreeEntry(context, i);
*link = i;
link = &context->heap[i].nextUnusedEntry;
reclaimed++;
}
}
if (reclaimed <= context->heapEntriesAllocated / 5) {
// PrintDebug("\033[0;32mFreed only %d/%d entries. Doubling heap size...\033[0m\n", reclaimed, context->heapEntriesAllocated);
intptr_t linkIndex = link == &context->heapFirstUnusedEntry ? -1
: ((intptr_t) link - (intptr_t) context->heap) / (intptr_t) sizeof(HeapEntry);
uintptr_t oldSize = context->heapEntriesAllocated;
context->heapEntriesAllocated *= 2;
context->heap = (HeapEntry *) AllocateResize(context->heap, context->heapEntriesAllocated * sizeof(HeapEntry));
link = linkIndex == -1 ? &context->heapFirstUnusedEntry : &context->heap[linkIndex].nextUnusedEntry;
for (uintptr_t i = oldSize; i < context->heapEntriesAllocated; i++) {
context->heap[i].type = T_ERROR;
*link = i;
link = &context->heap[i].nextUnusedEntry;
}
} else {
// PrintDebug("\033[0;32mFreed %d/%d entries.\033[0m\n", reclaimed, context->heapEntriesAllocated);
}
*link = 0;
}
uintptr_t index = context->heapFirstUnusedEntry;
Assert(index);
context->heapFirstUnusedEntry = context->heap[index].nextUnusedEntry;
return index;
}
void ScriptPrintNode(Node *node, int indent) {
for (int i = 0; i < indent; i++) {
PrintDebug("\t");
}
PrintDebug("%d l%d '%.*s'\n", node->type, node->token.line, node->token.textBytes, node->token.text);
Node *child = node->firstChild;
while (child) {
ScriptPrintNode(child, indent + 1);
child = child->sibling;
}
}
size_t ScriptHeapEntryGetStringBytes(HeapEntry *entry) {
if (entry->type == T_STR) {
return entry->bytes;
} else if (entry->type == T_EOF) {
return 0;
} else if (entry->type == T_CONCAT) {
return entry->concatBytes;
} else {
Assert(false);
return 0;
}
}
void ScriptHeapEntryConcatConvertToStringWrite(ExecutionContext *context, HeapEntry *entry, char *buffer) {
while (true) {
if (entry->type == T_STR) {
MemoryCopy(buffer, entry->text, entry->bytes);
} else if (entry->type == T_EOF) {
} else if (entry->type == T_CONCAT) {
HeapEntry *part1 = &context->heap[entry->concat1], *part2 = &context->heap[entry->concat2];
size_t part1Bytes = ScriptHeapEntryGetStringBytes(part1);
if (part1->type == T_CONCAT) {
ScriptHeapEntryConcatConvertToStringWrite(context, part2, buffer + part1Bytes);
Assert(part2->type != T_CONCAT);
entry = part1;
continue;
} else if (part2->type == T_CONCAT) {
ScriptHeapEntryConcatConvertToStringWrite(context, part1, buffer);
Assert(part1->type != T_CONCAT);
entry = part2;
buffer += part1Bytes;
continue;
} else {
ScriptHeapEntryConcatConvertToStringWrite(context, part1, buffer);
ScriptHeapEntryConcatConvertToStringWrite(context, part2, buffer + part1Bytes);
}
} else {
Assert(false);
}
break;
}
}
void ScriptHeapEntryConcatConvertToString(ExecutionContext *context, HeapEntry *entry) {
// TODO Efficient concatenation of many strings.
// TODO Preventing stack overflow.
Assert(entry->type == T_CONCAT);
HeapEntry *part1 = &context->heap[entry->concat1], *part2 = &context->heap[entry->concat2];
size_t part1Bytes = ScriptHeapEntryGetStringBytes(part1), part2Bytes = ScriptHeapEntryGetStringBytes(part2);
Assert(entry->concatBytes == part1Bytes + part2Bytes);
entry->type = T_STR;
entry->bytes = part1Bytes + part2Bytes;
entry->text = (char *) AllocateResize(NULL, entry->bytes);
ScriptHeapEntryConcatConvertToStringWrite(context, part1, entry->text);
ScriptHeapEntryConcatConvertToStringWrite(context, part2, entry->text + part1Bytes);
}
void ScriptHeapEntryToString(ExecutionContext *context, HeapEntry *entry, const char **text, size_t *bytes) {
if (entry->type == T_STR) {
*text = entry->text;
*bytes = entry->bytes;
} else if (entry->type == T_EOF) {
*text = "";
*bytes = 0;
} else if (entry->type == T_CONCAT) {
ScriptHeapEntryConcatConvertToString(context, entry);
ScriptHeapEntryToString(context, entry, text, bytes);
} else {
Assert(false);
*text = "";
*bytes = 0;
}
}
int ScriptExecuteFunction(uintptr_t instructionPointer, ExecutionContext *context) {
// TODO Things to verify if loading untrusted scripts -- is this a feature we will need?
// Checking we don't go off the end of the function body.
// Checking that this is actually a valid function body pointer.
// Checking various integer overflows.
uintptr_t variableBase = context->c->localVariableCount - 1;
uint8_t *functionData = context->functionData->data;
while (true) {
uint8_t command = functionData[instructionPointer++];
if (debugBytecodeLevel >= 1) {
PrintDebug("--> %d, %ld, %ld, %ld\n", command, instructionPointer - 1, context->c->id, context->c->stackPointer);
if (debugBytecodeLevel >= 2) PrintBackTrace(context, instructionPointer - 1, context->c, "");
}
if (command == T_BLOCK || command == T_FUNCBODY) {
uint16_t newVariableCount = functionData[instructionPointer + 0] + (functionData[instructionPointer + 1] << 8);
instructionPointer += 2;
if (context->c->localVariableCount + newVariableCount > context->c->localVariablesAllocated) {
// TODO Handling memory errors here.
context->c->localVariablesAllocated = context->c->localVariableCount + newVariableCount;
context->c->localVariables = (Value *) AllocateResize(context->c->localVariables, context->c->localVariablesAllocated * sizeof(Value));
context->c->localVariableIsManaged = (bool *) AllocateResize(context->c->localVariableIsManaged, context->c->localVariablesAllocated * sizeof(bool));
}
MemoryCopy(context->c->localVariableIsManaged + context->c->localVariableCount, functionData + instructionPointer, newVariableCount);
instructionPointer += newVariableCount;
for (uintptr_t i = context->c->localVariableCount; i < context->c->localVariableCount + newVariableCount; i++) {
if (command == T_FUNCBODY) {
if (context->c->stackPointer < 1) return -1;
context->c->localVariables[i] = context->c->stack[--context->c->stackPointer];
} else {
Value zero = { 0 };
context->c->localVariables[i] = zero;
}
}
context->c->localVariableCount += newVariableCount;
} else if (command == T_EXIT_SCOPE) {
uint16_t count = functionData[instructionPointer + 0] + (functionData[instructionPointer + 1] << 8);
instructionPointer += 2;
if (context->c->localVariableCount < count) return -1;
context->c->localVariableCount -= count;
} else if (command == T_NUMERIC_LITERAL) {
if (context->c->stackPointer == context->c->stackEntriesAllocated) {
PrintError4(context, instructionPointer - 1, "Stack overflow.\n");
return 0;
}
context->c->stackIsManaged[context->c->stackPointer] = false;
MemoryCopy(&context->c->stack[context->c->stackPointer++], &functionData[instructionPointer], sizeof(Value));
instructionPointer += sizeof(Value);
} else if (command == T_NULL || command == T_ZERO) {
if (context->c->stackPointer == context->c->stackEntriesAllocated) {
PrintError4(context, instructionPointer - 1, "Stack overflow.\n");
return 0;
}
context->c->stackIsManaged[context->c->stackPointer] = command == T_NULL;
context->c->stack[context->c->stackPointer++].i = 0;
} else if (command == T_STRING_LITERAL) {
if (context->c->stackPointer == context->c->stackEntriesAllocated) {
PrintError4(context, instructionPointer - 1, "Stack overflow.\n");
return 0;
}
uint32_t textBytes;
MemoryCopy(&textBytes, &functionData[instructionPointer], sizeof(textBytes));
instructionPointer += sizeof(textBytes);
// TODO Handle memory allocation failures here.
uintptr_t index = HeapAllocate(context);
context->heap[index].type = T_STR;
context->heap[index].text = (char *) AllocateResize(NULL, textBytes);
context->heap[index].bytes = textBytes;
MemoryCopy(context->heap[index].text, &functionData[instructionPointer], textBytes);
instructionPointer += textBytes;
Value v;
v.i = index;
context->c->stackIsManaged[context->c->stackPointer] = true;
context->c->stack[context->c->stackPointer++] = v;
} else if (command == T_CONCAT) {
if (context->c->stackPointer < 2) return -1;
uint64_t index1 = context->c->stack[context->c->stackPointer - 2].i;
uint64_t index2 = context->c->stack[context->c->stackPointer - 1].i;
if (!context->c->stackIsManaged[context->c->stackPointer - 2]) return -1;
if (!context->c->stackIsManaged[context->c->stackPointer - 1]) return -1;
if (context->heapEntriesAllocated <= index1) return -1;
if (context->heapEntriesAllocated <= index2) return -1;
Assert(index1 <= 0xFFFFFFFF && index2 <= 0xFFFFFFFF);
size_t bytes1 = ScriptHeapEntryGetStringBytes(&context->heap[index1]);
size_t bytes2 = ScriptHeapEntryGetStringBytes(&context->heap[index2]);
uintptr_t index = HeapAllocate(context); // TODO Handle memory allocation failures here.
context->heap[index].type = T_CONCAT;
context->heap[index].concat1 = index1;
context->heap[index].concat2 = index2;
context->heap[index].concatBytes = bytes1 + bytes2;
// At most one argument can be a T_CONCAT (ohterwise converting to a string could stack overflow).
if (context->heap[index1].type == T_CONCAT && context->heap[index2].type == T_CONCAT) {
ScriptHeapEntryConcatConvertToString(context, bytes1 < bytes2 ? &context->heap[index1] : &context->heap[index2]);
}
context->c->stack[context->c->stackPointer - 2].i = index;
context->c->stackPointer--;
} else if (command == T_INTERPOLATE_STR || command == T_INTERPOLATE_BOOL
|| command == T_INTERPOLATE_INT || command == T_INTERPOLATE_FLOAT
|| command == T_INTERPOLATE_ILIST) {
STACK_READ_STRING(text1, bytes1, 3);
STACK_READ_STRING(text3, bytes3, 1);
char *freeText = NULL;
const char *text2 = "";
size_t bytes2 = 0;
char temp[30];
if (command == T_INTERPOLATE_STR) {
STACK_READ_STRING(entryText2, entryBytes2, 2);
text2 = entryText2, bytes2 = entryBytes2;
} else if (command == T_INTERPOLATE_BOOL) {
text2 = context->c->stack[context->c->stackPointer - 2].i ? "true" : "false";
bytes2 = context->c->stack[context->c->stackPointer - 2].i ? 4 : 5;
} else if (command == T_INTERPOLATE_INT) {
text2 = temp;
bytes2 = PrintIntegerToBuffer(temp, sizeof(temp), context->c->stack[context->c->stackPointer - 2].i);
} else if (command == T_INTERPOLATE_FLOAT) {
text2 = temp;
bytes2 = PrintFloatToBuffer(temp, sizeof(temp), context->c->stack[context->c->stackPointer - 2].f);
} else if (command == T_INTERPOLATE_ILIST) {
if (!context->c->stackIsManaged[context->c->stackPointer - 2]) return -1;
uint64_t index2 = context->c->stack[context->c->stackPointer - 2].i;
if (context->heapEntriesAllocated <= index2) return -1;
HeapEntry *entry2 = &context->heap[index2];
if (entry2->type != T_EOF && entry2->type != T_LIST) return -1;
if (entry2->type == T_EOF) {
text2 = "null";
bytes2 = 4;
} else if (entry2->length == 0) {
text2 = "[]";
bytes2 = 2;
} else {
if (entry2->internalValuesAreManaged) return -1;
bytes2 = 4;
for (uintptr_t i = 0; i < entry2->length; i++) {
bytes2 += PrintIntegerToBuffer(temp, sizeof(temp), entry2->list[i].i) + 2;
}
freeText = (char *) AllocateResize(freeText, bytes2);
text2 = freeText;
bytes2 = 0;
freeText[bytes2++] = '[';
freeText[bytes2++] = ' ';
for (uintptr_t i = 0; i < entry2->length; i++) {
bytes2 += PrintIntegerToBuffer(freeText + bytes2, sizeof(temp) /* enough space */, entry2->list[i].i);
freeText[bytes2++] = ',';
freeText[bytes2++] = ' ';
}
bytes2 -= 2;
freeText[bytes2++] = ' ';
freeText[bytes2++] = ']';
}
}
// TODO Handle memory allocation failures here.
uintptr_t index = HeapAllocate(context);
context->heap[index].type = T_STR;
context->heap[index].bytes = bytes1 + bytes2 + bytes3;
context->heap[index].text = (char *) AllocateResize(NULL, context->heap[index].bytes);
if (bytes1) MemoryCopy(context->heap[index].text + 0, text1, bytes1);
if (bytes2) MemoryCopy(context->heap[index].text + bytes1, text2, bytes2);
if (bytes3) MemoryCopy(context->heap[index].text + bytes1 + bytes2, text3, bytes3);
context->c->stack[context->c->stackPointer - 3].i = index;
if (freeText) AllocateResize(freeText, 0);
context->c->stackPointer -= 2;
} else if (command == T_VARIABLE) {
if (context->c->stackPointer == context->c->stackEntriesAllocated) {
PrintDebug("Stack overflow.\n");
return -1;
}
int32_t scopeIndex;
MemoryCopy(&scopeIndex, &functionData[instructionPointer], sizeof(scopeIndex));
instructionPointer += sizeof(scopeIndex);
if (scopeIndex >= 0) {
if ((uintptr_t) scopeIndex >= context->globalVariableCount) return -1;
context->c->stackIsManaged[context->c->stackPointer] = context->globalVariableIsManaged[scopeIndex];
context->c->stack[context->c->stackPointer++] = context->globalVariables[scopeIndex];
} else {
scopeIndex = variableBase - scopeIndex;
if ((uintptr_t) scopeIndex >= context->c->localVariableCount) return -1;
context->c->stackIsManaged[context->c->stackPointer] = context->c->localVariableIsManaged[scopeIndex];
context->c->stack[context->c->stackPointer++] = context->c->localVariables[scopeIndex];
}
} else if (command == T_EQUALS) {
if (!context->c->stackPointer) return -1;
int32_t scopeIndex;
MemoryCopy(&scopeIndex, &functionData[instructionPointer], sizeof(scopeIndex));
instructionPointer += sizeof(scopeIndex);
if (scopeIndex >= 0) {
if ((uintptr_t) scopeIndex >= context->globalVariableCount) return -1;
if (context->globalVariableIsManaged[scopeIndex] != context->c->stackIsManaged[context->c->stackPointer - 1]) return -1;
context->globalVariables[scopeIndex] = context->c->stack[--context->c->stackPointer];
} else {
scopeIndex = variableBase - scopeIndex;
if ((uintptr_t) scopeIndex >= context->c->localVariableCount) return -1;
if (context->c->localVariableIsManaged[scopeIndex] != context->c->stackIsManaged[context->c->stackPointer - 1]) return -1;
context->c->localVariables[scopeIndex] = context->c->stack[--context->c->stackPointer];
}
} else if (command == T_EQUALS_DOT) {
if (context->c->stackPointer < 2) return -1;
if (!context->c->stackIsManaged[context->c->stackPointer - 1]) return -1;
uint64_t index = context->c->stack[context->c->stackPointer - 1].i;
if (!index) {
PrintError4(context, instructionPointer - 1, "The struct is null.\n");
return 0;
}
if (context->heapEntriesAllocated <= index) return -1;
HeapEntry *entry = &context->heap[index];
if (entry->type != T_STRUCT) return -1;
int32_t fieldIndex;
MemoryCopy(&fieldIndex, &functionData[instructionPointer], sizeof(fieldIndex));
instructionPointer += sizeof(fieldIndex);
bool isManaged = fieldIndex < 0;
if (isManaged) fieldIndex = -fieldIndex - 1;
if (fieldIndex < 0 || fieldIndex >= entry->fieldCount) return -1;
entry->fields[fieldIndex] = context->c->stack[context->c->stackPointer - 2];
if (isManaged != context->c->stackIsManaged[context->c->stackPointer - 2]) return -1;
((uint8_t *) entry->fields - 1)[-fieldIndex] = isManaged;
context->c->stackPointer -= 2;
} else if (command == T_EQUALS_LIST) {
if (context->c->stackPointer < 3) return -1;
if (context->c->stackIsManaged[context->c->stackPointer - 1]) return -1;
if (!context->c->stackIsManaged[context->c->stackPointer - 2]) return -1;
uint64_t index = context->c->stack[context->c->stackPointer - 2].i;
if (!index) {
PrintError4(context, instructionPointer - 1, "The list is null.\n");
return 0;
}
if (context->heapEntriesAllocated <= index) return -1;
HeapEntry *entry = &context->heap[index];
if (entry->type != T_LIST) return -1;
index = context->c->stack[context->c->stackPointer - 1].i;
if (index >= entry->length) {
PrintError4(context, instructionPointer - 1, "The index %ld is not valid for the list, which has length %d.\n", index, entry->length);
return 0;
}
entry->list[index] = context->c->stack[context->c->stackPointer - 3];
if (entry->internalValuesAreManaged != context->c->stackIsManaged[context->c->stackPointer - 3]) return -1;
context->c->stackPointer -= 3;
} else if (command == T_INDEX_LIST) {
if (context->c->stackPointer < 2) return -1;
if (context->c->stackIsManaged[context->c->stackPointer - 1]) return -1;
if (!context->c->stackIsManaged[context->c->stackPointer - 2]) return -1;
uint64_t index = context->c->stack[context->c->stackPointer - 2].i;
if (!index) {
PrintError4(context, instructionPointer - 1, "The list is null.\n");
return 0;
}
if (context->heapEntriesAllocated <= index) return -1;
HeapEntry *entry = &context->heap[index];
if (entry->type != T_LIST) return -1;
index = context->c->stack[context->c->stackPointer - 1].i;
if (index >= entry->length) {
PrintError4(context, instructionPointer - 1, "The index %ld is not valid for the list, which has length %d.\n", index, entry->length);
return 0;
}
context->c->stack[context->c->stackPointer - 2] = entry->list[index];
context->c->stackIsManaged[context->c->stackPointer - 2] = entry->internalValuesAreManaged;
context->c->stackPointer--;
} else if (command == T_OP_FIRST || command == T_OP_LAST) {
if (context->c->stackPointer < 1) return -1;
if (!context->c->stackIsManaged[context->c->stackPointer - 1]) return -1;
uint64_t index = context->c->stack[context->c->stackPointer - 1].i;
if (!index) {
PrintError4(context, instructionPointer - 1, "The list is null.\n");
return 0;
}
if (context->heapEntriesAllocated <= index) return -1;
HeapEntry *entry = &context->heap[index];
if (entry->type != T_LIST) return -1;
if (!entry->length) {
PrintError4(context, instructionPointer - 1, "The list is empty.\n");
return 0;
}
context->c->stack[context->c->stackPointer - 1] = entry->list[command == T_OP_FIRST ? 0 : entry->length - 1];
context->c->stackIsManaged[context->c->stackPointer - 1] = entry->internalValuesAreManaged;
} else if (command == T_DOT) {
if (context->c->stackPointer < 1) return -1;
if (!context->c->stackIsManaged[context->c->stackPointer - 1]) return -1;
uint64_t index = context->c->stack[context->c->stackPointer - 1].i;
if (!index) {
PrintError4(context, instructionPointer - 1, "The struct is null.\n");
return 0;
}
if (context->heapEntriesAllocated <= index) return -1;
HeapEntry *entry = &context->heap[index];
if (entry->type != T_STRUCT) return -1;
int16_t fieldIndex;
MemoryCopy(&fieldIndex, &functionData[instructionPointer], sizeof(fieldIndex));
instructionPointer += sizeof(fieldIndex);
bool isManaged = fieldIndex < 0;
if (isManaged) fieldIndex = -fieldIndex - 1;
if (fieldIndex < 0 || fieldIndex >= entry->fieldCount) return -1;
// Only allow the isManaged bool to be incorrect if it's a null managed variable.
if (isManaged != ((uint8_t *) entry->fields - 1)[-fieldIndex] && (entry->fields[fieldIndex].i || !isManaged)) return -1;
context->c->stack[context->c->stackPointer - 1] = entry->fields[fieldIndex];
context->c->stackIsManaged[context->c->stackPointer - 1] = isManaged;
} else if (command == T_BIT_SHIFT_LEFT) {
if (context->c->stackPointer < 2) return -1;
context->c->stack[context->c->stackPointer - 2].i = context->c->stack[context->c->stackPointer - 2].i << context->c->stack[context->c->stackPointer - 1].i;
context->c->stackPointer--;
} else if (command == T_BIT_SHIFT_RIGHT) {
if (context->c->stackPointer < 2) return -1;
context->c->stack[context->c->stackPointer - 2].i = context->c->stack[context->c->stackPointer - 2].i >> context->c->stack[context->c->stackPointer - 1].i;
context->c->stackPointer--;
} else if (command == T_BITWISE_OR) {
if (context->c->stackPointer < 2) return -1;
context->c->stack[context->c->stackPointer - 2].i = context->c->stack[context->c->stackPointer - 2].i | context->c->stack[context->c->stackPointer - 1].i;
context->c->stackPointer--;
} else if (command == T_BITWISE_AND) {
if (context->c->stackPointer < 2) return -1;
context->c->stack[context->c->stackPointer - 2].i = context->c->stack[context->c->stackPointer - 2].i & context->c->stack[context->c->stackPointer - 1].i;
context->c->stackPointer--;
} else if (command == T_BITWISE_XOR) {
if (context->c->stackPointer < 2) return -1;
context->c->stack[context->c->stackPointer - 2].i = context->c->stack[context->c->stackPointer - 2].i ^ context->c->stack[context->c->stackPointer - 1].i;
context->c->stackPointer--;
} else if (command == T_ADD) {
if (context->c->stackPointer < 2) return -1;
context->c->stack[context->c->stackPointer - 2].i = context->c->stack[context->c->stackPointer - 2].i + context->c->stack[context->c->stackPointer - 1].i;
context->c->stackPointer--;
} else if (command == T_MINUS) {
if (context->c->stackPointer < 2) return -1;
context->c->stack[context->c->stackPointer - 2].i = context->c->stack[context->c->stackPointer - 2].i - context->c->stack[context->c->stackPointer - 1].i;
context->c->stackPointer--;
} else if (command == T_ASTERISK) {
if (context->c->stackPointer < 2) return -1;
context->c->stack[context->c->stackPointer - 2].i = context->c->stack[context->c->stackPointer - 2].i * context->c->stack[context->c->stackPointer - 1].i;
context->c->stackPointer--;
} else if (command == T_SLASH) {
if (context->c->stackPointer < 2) return -1;
if (0 == context->c->stack[context->c->stackPointer - 1].i) {
PrintError4(context, instructionPointer - 1, "Attempted division by zero.\n");
return 0;
}
context->c->stack[context->c->stackPointer - 2].i = context->c->stack[context->c->stackPointer - 2].f / context->c->stack[context->c->stackPointer - 1].f;
context->c->stackPointer--;
} else if (command == T_NEGATE) {
if (context->c->stackPointer < 1) return -1;
context->c->stack[context->c->stackPointer - 1].i = -context->c->stack[context->c->stackPointer - 1].i;
} else if (command == T_BITWISE_NOT) {
if (context->c->stackPointer < 1) return -1;
context->c->stack[context->c->stackPointer - 1].i = ~context->c->stack[context->c->stackPointer - 1].i;
} else if (command == T_FLOAT_ADD) {
if (context->c->stackPointer < 2) return -1;
context->c->stack[context->c->stackPointer - 2].f = context->c->stack[context->c->stackPointer - 2].f + context->c->stack[context->c->stackPointer - 1].f;
context->c->stackPointer--;
} else if (command == T_FLOAT_MINUS) {
if (context->c->stackPointer < 2) return -1;
context->c->stack[context->c->stackPointer - 2].f = context->c->stack[context->c->stackPointer - 2].f - context->c->stack[context->c->stackPointer - 1].f;
context->c->stackPointer--;
} else if (command == T_FLOAT_ASTERISK) {
if (context->c->stackPointer < 2) return -1;
context->c->stack[context->c->stackPointer - 2].f = context->c->stack[context->c->stackPointer - 2].f * context->c->stack[context->c->stackPointer - 1].f;
context->c->stackPointer--;
} else if (command == T_FLOAT_SLASH) {
if (context->c->stackPointer < 2) return -1;
context->c->stack[context->c->stackPointer - 2].f = context->c->stack[context->c->stackPointer - 2].f / context->c->stack[context->c->stackPointer - 1].f;
context->c->stackPointer--;
} else if (command == T_FLOAT_NEGATE) {
if (context->c->stackPointer < 1) return -1;
context->c->stack[context->c->stackPointer - 1].f = -context->c->stack[context->c->stackPointer - 1].f;
} else if (command == T_LESS_THAN) {
if (context->c->stackPointer < 2) return -1;
context->c->stack[context->c->stackPointer - 2].i = context->c->stack[context->c->stackPointer - 2].i < context->c->stack[context->c->stackPointer - 1].i;
context->c->stackPointer--;
} else if (command == T_GREATER_THAN) {
if (context->c->stackPointer < 2) return -1;
context->c->stack[context->c->stackPointer - 2].i = context->c->stack[context->c->stackPointer - 2].i > context->c->stack[context->c->stackPointer - 1].i;
context->c->stackPointer--;
} else if (command == T_LT_OR_EQUAL) {
if (context->c->stackPointer < 2) return -1;
context->c->stack[context->c->stackPointer - 2].i = context->c->stack[context->c->stackPointer - 2].i <= context->c->stack[context->c->stackPointer - 1].i;
context->c->stackPointer--;
} else if (command == T_GT_OR_EQUAL) {
if (context->c->stackPointer < 2) return -1;
context->c->stack[context->c->stackPointer - 2].i = context->c->stack[context->c->stackPointer - 2].i >= context->c->stack[context->c->stackPointer - 1].i;
context->c->stackPointer--;
} else if (command == T_DOUBLE_EQUALS) {
if (context->c->stackPointer < 2) return -1;
context->c->stack[context->c->stackPointer - 2].i = context->c->stack[context->c->stackPointer - 2].i == context->c->stack[context->c->stackPointer - 1].i;
context->c->stackPointer--;
} else if (command == T_NOT_EQUALS) {
if (context->c->stackPointer < 2) return -1;
context->c->stack[context->c->stackPointer - 2].i = context->c->stack[context->c->stackPointer - 2].i != context->c->stack[context->c->stackPointer - 1].i;
context->c->stackPointer--;
} else if (command == T_LOGICAL_NOT) {
if (context->c->stackPointer < 1) return -1;
context->c->stack[context->c->stackPointer - 1].i = !context->c->stack[context->c->stackPointer - 1].i;
} else if (command == T_FLOAT_LESS_THAN) {
if (context->c->stackPointer < 2) return -1;
context->c->stack[context->c->stackPointer - 2].i = context->c->stack[context->c->stackPointer - 2].f < context->c->stack[context->c->stackPointer - 1].f;
context->c->stackPointer--;
} else if (command == T_FLOAT_GREATER_THAN) {
if (context->c->stackPointer < 2) return -1;
context->c->stack[context->c->stackPointer - 2].i = context->c->stack[context->c->stackPointer - 2].f > context->c->stack[context->c->stackPointer - 1].f;
context->c->stackPointer--;
} else if (command == T_FLOAT_LT_OR_EQUAL) {
if (context->c->stackPointer < 2) return -1;
context->c->stack[context->c->stackPointer - 2].i = context->c->stack[context->c->stackPointer - 2].f <= context->c->stack[context->c->stackPointer - 1].f;
context->c->stackPointer--;
} else if (command == T_FLOAT_GT_OR_EQUAL) {
if (context->c->stackPointer < 2) return -1;
context->c->stack[context->c->stackPointer - 2].i = context->c->stack[context->c->stackPointer - 2].f >= context->c->stack[context->c->stackPointer - 1].f;
context->c->stackPointer--;
} else if (command == T_FLOAT_DOUBLE_EQUALS) {
if (context->c->stackPointer < 2) return -1;
context->c->stack[context->c->stackPointer - 2].i = context->c->stack[context->c->stackPointer - 2].f == context->c->stack[context->c->stackPointer - 1].f;
context->c->stackPointer--;
} else if (command == T_FLOAT_NOT_EQUALS) {
if (context->c->stackPointer < 2) return -1;
context->c->stack[context->c->stackPointer - 2].i = context->c->stack[context->c->stackPointer - 2].f != context->c->stack[context->c->stackPointer - 1].f;
context->c->stackPointer--;
} else if (command == T_STR_DOUBLE_EQUALS || command == T_STR_NOT_EQUALS) {
STACK_READ_STRING(text1, bytes1, 2);
STACK_READ_STRING(text2, bytes2, 1);
bool equal = bytes1 == bytes2 && 0 == MemoryCompare(text1, text2, bytes1);
context->c->stack[context->c->stackPointer - 2].i = command == T_STR_NOT_EQUALS ? !equal : equal;
context->c->stackIsManaged[context->c->stackPointer - 2] = false;
context->c->stackPointer--;
} else if (command == T_OP_LEN) {
if (context->c->stackPointer < 1) return -1;
if (!context->c->stackIsManaged[context->c->stackPointer - 1]) return -1;
uint64_t index = context->c->stack[context->c->stackPointer - 1].i;
if (context->heapEntriesAllocated <= index) return -1;
HeapEntry *entry = &context->heap[index];
if (entry->type == T_LIST) {
context->c->stack[context->c->stackPointer - 1].i = entry->length;
} else {
STACK_READ_STRING(stringText, stringBytes, 1);
context->c->stack[context->c->stackPointer - 1].i = stringBytes;
}
context->c->stackIsManaged[context->c->stackPointer - 1] = false;
} else if (command == T_INDEX) {
if (context->c->stackPointer < 2) return -1;
STACK_READ_STRING(text, bytes, 2);
if (context->c->stackIsManaged[context->c->stackPointer - 1]) return -1;
uintptr_t index = context->c->stack[context->c->stackPointer - 1].i;
if (index >= bytes) {
PrintError4(context, instructionPointer - 1, "Index %ld out of bounds in string '%.*s' of length %ld.\n",
index, bytes, text, bytes);
return 0;
}
char c = text[index];
index = HeapAllocate(context);
context->heap[index].type = T_STR;
context->heap[index].bytes = 1;
context->heap[index].text = (char *) AllocateResize(NULL, 1); // TODO Handling allocation failure.
context->heap[index].text[0] = c;
context->c->stack[context->c->stackPointer - 2].i = index;
context->c->stackIsManaged[context->c->stackPointer - 2] = true;
context->c->stackPointer--;
} else if (command == T_CALL) {
callCommand:;
if (context->c->stackPointer < 1) return -1;
if (!context->c->stackIsManaged[context->c->stackPointer - 1]) return -1;
Value newBody = context->c->stack[--context->c->stackPointer];
if (newBody.i == 0) {
PrintError4(context, instructionPointer - 1, "Function pointer was null.\n");
return 0;
}
bool popResult = false;
bool assertResult = false;
while (true) {
uint64_t index = newBody.i;
if (context->heapEntriesAllocated <= index) return -1;
HeapEntry *entry = &context->heap[index];
newBody.i = entry->lambdaID;
if (entry->type == T_OP_DISCARD) {
popResult = true;
} else if (entry->type == T_OP_ASSERT) {
assertResult = true;
} else if (entry->type == T_OP_CURRY) {
if (context->c->stackPointer == context->c->stackEntriesAllocated) {
PrintError4(context, instructionPointer - 1, "Stack overflow.\n");
return 0;
}
context->c->stack[context->c->stackPointer] = entry->curryValue;
context->c->stackIsManaged[context->c->stackPointer] = entry->internalValuesAreManaged;
context->c->stackPointer++;
} else if (entry->type == T_FUNCPTR) {
break;
} else {
return -1;
}
}
if (context->c->backTracePointer == sizeof(context->c->backTrace) / sizeof(context->c->backTrace[0])) {
PrintError4(context, instructionPointer - 1, "Back trace overflow.\n");
return 0;
}
BackTraceItem *link = &context->c->backTrace[context->c->backTracePointer];
context->c->backTracePointer++;
link->instructionPointer = instructionPointer;
link->variableBase = variableBase;
link->popResult = popResult;
link->assertResult = assertResult;
instructionPointer = newBody.i;
variableBase = context->c->localVariableCount - 1;
} else if (command == T_IF) {
if (context->c->stackPointer < 1) return -1;
Value condition = context->c->stack[--context->c->stackPointer];
int32_t delta;
MemoryCopy(&delta, &functionData[instructionPointer], sizeof(delta));
instructionPointer += condition.i ? (int32_t) sizeof(delta) : delta;
} else if (command == T_LOGICAL_OR) {
if (context->c->stackPointer < 1) return -1;
Value condition = context->c->stack[context->c->stackPointer - 1];
int32_t delta;
MemoryCopy(&delta, &functionData[instructionPointer], sizeof(delta));
instructionPointer += condition.i ? delta : (int32_t) sizeof(delta);
if (!condition.i) context->c->stackPointer--;
} else if (command == T_LOGICAL_AND) {
if (context->c->stackPointer < 1) return -1;
Value condition = context->c->stack[context->c->stackPointer - 1];
int32_t delta;
MemoryCopy(&delta, &functionData[instructionPointer], sizeof(delta));
instructionPointer += condition.i ? (int32_t) sizeof(delta) : delta;
if (condition.i) context->c->stackPointer--;
} else if (command == T_BRANCH) {
int32_t delta;
MemoryCopy(&delta, &functionData[instructionPointer], sizeof(delta));
instructionPointer += delta;
} else if (command == T_POP) {
if (context->c->stackPointer < 1) return -1;
context->c->stackPointer--;
} else if (command == T_DUP) {
if (context->c->stackPointer < 1) return -1;
if (context->c->stackPointer == context->c->stackEntriesAllocated) {
PrintError4(context, instructionPointer - 1, "Stack overflow.\n");
return 0;
}
context->c->stack[context->c->stackPointer] = context->c->stack[context->c->stackPointer - 1];
context->c->stackIsManaged[context->c->stackPointer] = context->c->stackIsManaged[context->c->stackPointer - 1];
context->c->stackPointer++;
} else if (command == T_SWAP) {
if (context->c->stackPointer < 2) return -1;
Value v1 = context->c->stack[context->c->stackPointer - 1];
Value v2 = context->c->stack[context->c->stackPointer - 2];
bool m1 = context->c->stackIsManaged[context->c->stackPointer - 1];
bool m2 = context->c->stackIsManaged[context->c->stackPointer - 2];
context->c->stack[context->c->stackPointer - 1] = v2;
context->c->stack[context->c->stackPointer - 2] = v1;
context->c->stackIsManaged[context->c->stackPointer - 1] = m2;
context->c->stackIsManaged[context->c->stackPointer - 2] = m1;
} else if (command == T_ROT3) {
if (context->c->stackPointer < 3) return -1;
Value v1 = context->c->stack[context->c->stackPointer - 1];
Value v2 = context->c->stack[context->c->stackPointer - 2];
Value v3 = context->c->stack[context->c->stackPointer - 3];
bool m1 = context->c->stackIsManaged[context->c->stackPointer - 1];
bool m2 = context->c->stackIsManaged[context->c->stackPointer - 2];
bool m3 = context->c->stackIsManaged[context->c->stackPointer - 3];
context->c->stack[context->c->stackPointer - 1] = v3;
context->c->stack[context->c->stackPointer - 2] = v1;
context->c->stack[context->c->stackPointer - 3] = v2;
context->c->stackIsManaged[context->c->stackPointer - 1] = m3;
context->c->stackIsManaged[context->c->stackPointer - 2] = m1;
context->c->stackIsManaged[context->c->stackPointer - 3] = m2;
} else if (command == T_ASSERT) {
if (context->c->stackPointer < 1) return -1;
Value condition = context->c->stack[--context->c->stackPointer];
if (condition.i == 0) {
PrintError4(context, instructionPointer - 1, "Assertion failed.\n");
return 0;
}
} else if (command == T_ERR_CAST) {
if (context->c->stackPointer < 1) return -1;
// TODO Handle memory allocation failures here.
uintptr_t index = HeapAllocate(context);
context->heap[index].type = T_ERR;
context->heap[index].success = true;
context->heap[index].internalValuesAreManaged = context->c->stackIsManaged[context->c->stackPointer - 1];;
context->heap[index].errorValue = context->c->stack[context->c->stackPointer - 1];
Value v;
v.i = index;
context->c->stackIsManaged[context->c->stackPointer - 1] = true;
context->c->stack[context->c->stackPointer - 1] = v;
} else if (command == T_ANYTYPE_CAST) {
if (context->c->stackPointer < 1) return -1;
// TODO Handle memory allocation failures here.
uintptr_t index = HeapAllocate(context);
context->heap[index].type = T_ANYTYPE;
MemoryCopy(&context->heap[index].anyType, &functionData[instructionPointer], sizeof(context->heap[index].anyType));
context->heap[index].internalValuesAreManaged = ASTIsManagedType(context->heap[index].anyType);
context->heap[index].anyValue = context->c->stack[context->c->stackPointer - 1];
Value v;
v.i = index;
context->c->stackIsManaged[context->c->stackPointer - 1] = true;
context->c->stack[context->c->stackPointer - 1] = v;
instructionPointer += sizeof(context->heap[index].anyType);
} else if (command == T_OP_CAST) {
if (context->c->stackPointer < 1) return -1;
if (!context->c->stackIsManaged[context->c->stackPointer - 1]) return -1;
uintptr_t index = context->c->stack[context->c->stackPointer - 1].i;
if (index == 0) {
PrintError4(context, instructionPointer - 1, "The object is null.\n");
return 0;
}
if (context->heapEntriesAllocated <= index) return -1;
HeapEntry *entry = &context->heap[index];
if (entry->type != T_ANYTYPE) return -1;
Node *expressionType;
MemoryCopy(&expressionType, &functionData[instructionPointer], sizeof(expressionType));
if (!ASTMatching(expressionType, entry->anyType)) {
PrintError4(context, instructionPointer - 1, "Invalid cast.\n");
return 0;
}
Assert(ASTIsManagedType(expressionType) == entry->internalValuesAreManaged);
context->c->stackIsManaged[context->c->stackPointer - 1] = entry->internalValuesAreManaged;
context->c->stack[context->c->stackPointer - 1] = entry->anyValue;
instructionPointer += sizeof(expressionType);
} else if (command == T_OP_SUCCESS) {
if (context->c->stackPointer < 1) return -1;
if (!context->c->stackIsManaged[context->c->stackPointer - 1]) return -1;
uintptr_t index = context->c->stack[context->c->stackPointer - 1].i;
bool success = false;
if (index) {
if (context->heapEntriesAllocated <= index) return -1;
HeapEntry *entry = &context->heap[index];
if (entry->type != T_ERR) return -1;
success = entry->success;
}
context->c->stack[context->c->stackPointer - 1].i = success;
context->c->stackIsManaged[context->c->stackPointer - 1] = false;
} else if (command == T_OP_ASSERT_ERR) {
if (context->c->stackPointer < 1) return -1;
if (!context->c->stackIsManaged[context->c->stackPointer - 1]) return -1;
uintptr_t index = context->c->stack[context->c->stackPointer - 1].i;
if (index == 0) {
PrintError4(context, instructionPointer - 1, "Assertion failed. Unknown error.\n");
return 0;
} else {
if (context->heapEntriesAllocated <= index) return -1;
HeapEntry *entry = &context->heap[index];
if (entry->type != T_ERR) return -1;
if (!entry->success) {
if (!entry->internalValuesAreManaged) return -1;
size_t textBytes;
const char *text;
ScriptHeapEntryToString(context, &context->heap[entry->errorValue.i], &text, &textBytes);
PrintError4(context, instructionPointer - 1, "Assertion failed.\nThe error code is: '%.*s'.\n", textBytes, text);
return 0;
}
context->c->stack[context->c->stackPointer - 1] = entry->errorValue;
context->c->stackIsManaged[context->c->stackPointer - 1] = entry->internalValuesAreManaged;
}
} else if (command == T_OP_ERROR) {
if (context->c->stackPointer < 1) return -1;
if (!context->c->stackIsManaged[context->c->stackPointer - 1]) return -1;
uintptr_t index = context->c->stack[context->c->stackPointer - 1].i;
if (index == 0) {
index = HeapAllocate(context);
context->heap[index].type = T_STR;
context->heap[index].text = (char *) AllocateResize(NULL, 7);
context->heap[index].bytes = 7;
MemoryCopy(context->heap[index].text, "UNKNOWN", 7);
} else {
if (context->heapEntriesAllocated <= index) return -1;
HeapEntry *entry = &context->heap[index];
if (entry->type != T_ERR) return -1;
if (!entry->success && !entry->internalValuesAreManaged) return -1;
index = entry->success ? 0 : entry->errorValue.i;
}
context->c->stack[context->c->stackPointer - 1].i = index;
context->c->stackIsManaged[context->c->stackPointer - 1] = true;
} else if (command == T_OP_DEFAULT) {
if (context->c->stackPointer < 2) return -1;
if (!context->c->stackIsManaged[context->c->stackPointer - 2]) return -1;
uintptr_t index = context->c->stack[context->c->stackPointer - 2].i;
if (index) {
if (context->heapEntriesAllocated <= index) return -1;
HeapEntry *entry = &context->heap[index];
if (entry->type != T_ERR) return -1;
if (!entry->success && !entry->internalValuesAreManaged) return -1;
if (entry->success) {
context->c->stack[context->c->stackPointer - 1] = entry->errorValue;
context->c->stackIsManaged[context->c->stackPointer - 1] = entry->internalValuesAreManaged;
}
}
context->c->stack[context->c->stackPointer - 2] = context->c->stack[context->c->stackPointer - 1];
context->c->stackIsManaged[context->c->stackPointer - 2] = context->c->stackIsManaged[context->c->stackPointer - 1];
context->c->stackPointer--;
} else if (command == T_OP_INT_TO_FLOAT) {
if (context->c->stackPointer < 1) return -1;
if (context->c->stackIsManaged[context->c->stackPointer - 1]) return -1;
context->c->stack[context->c->stackPointer - 1].f = context->c->stack[context->c->stackPointer - 1].i;
} else if (command == T_OP_FLOAT_TRUNCATE) {
if (context->c->stackPointer < 1) return -1;
if (context->c->stackIsManaged[context->c->stackPointer - 1]) return -1;
context->c->stack[context->c->stackPointer - 1].i = context->c->stack[context->c->stackPointer - 1].f;
} else if (command == T_PERSIST) {
if (!ExternalPersistWrite(context, NULL)) {
return 0;
}
} else if (command == T_NEW) {
if (context->c->stackPointer == context->c->stackEntriesAllocated) {
PrintError4(context, instructionPointer - 1, "Stack overflow.\n");
return 0;
}
int16_t fieldCount = functionData[instructionPointer + 0] + (functionData[instructionPointer + 1] << 8);
instructionPointer += 2;
uintptr_t index = HeapAllocate(context);
context->heap[index].type = fieldCount >= 0 ? T_STRUCT : fieldCount >= -2 ? T_LIST : T_ERR;
if (fieldCount >= 0) {
context->heap[index].fields = (Value *) ((uint8_t *) AllocateResize(NULL, fieldCount * (1 + sizeof(Value))) + fieldCount);
context->heap[index].fieldCount = fieldCount;
for (intptr_t i = 0; i < fieldCount; i++) {
context->heap[index].fields[i].i = 0;
// Default all fields to being unmanaged.
// The first type they are set this will be updated.
((uint8_t *) context->heap[index].fields)[-1 - i] = false;
}
} else if (fieldCount >= -2) {
context->heap[index].internalValuesAreManaged = fieldCount == -2;
context->heap[index].length = context->heap[index].allocated = 0;
context->heap[index].list = NULL;
} else {
context->heap[index].internalValuesAreManaged = true;
context->heap[index].success = false;
if (context->c->stackPointer < 1) return -1;
if (!context->c->stackIsManaged[context->c->stackPointer - 1]) return -1;
context->heap[index].errorValue = context->c->stack[context->c->stackPointer - 1];
context->c->stackPointer--;
}
Value v;
v.i = index;
context->c->stackIsManaged[context->c->stackPointer] = true;
context->c->stack[context->c->stackPointer++] = v;
} else if (command == T_OP_RESIZE) {
if (context->c->stackPointer < 2) return -1;
if (!context->c->stackIsManaged[context->c->stackPointer - 2]) return -1;
uint64_t index = context->c->stack[context->c->stackPointer - 2].i;
if (!index) {
PrintError4(context, instructionPointer - 1, "The list is null.\n");
return 0;
}
if (context->heapEntriesAllocated <= index) return -1;
HeapEntry *entry = &context->heap[index];
if (entry->type != T_LIST) return -1;
int64_t newLength = context->c->stack[context->c->stackPointer - 1].i;
if (newLength < 0 || newLength >= 1000000000) {
PrintError4(context, instructionPointer - 1, "The new length of the list is out of the supported range (0..1000000000).\n");
return 0;
}
uint32_t oldLength = context->heap[index].length;
context->heap[index].length = newLength;
context->heap[index].allocated = newLength;
// TODO Handling out of memory errors.
context->heap[index].list = (Value *) AllocateResize(context->heap[index].list, newLength * sizeof(Value));
for (uintptr_t i = oldLength; i < (size_t) newLength; i++) {
context->heap[index].list[i].i = 0;
}
context->c->stackPointer -= 2;
} else if (command == T_OP_ADD) {
if (context->c->stackPointer < 2) return -1;
if (!context->c->stackIsManaged[context->c->stackPointer - 2]) return -1;
uint64_t index = context->c->stack[context->c->stackPointer - 2].i;
if (!index) {
PrintError4(context, instructionPointer - 1, "The list is null.\n");
return 0;
}
if (context->heapEntriesAllocated <= index) return -1;
HeapEntry *entry = &context->heap[index];
if (entry->type != T_LIST) return -1;
int64_t newLength = entry->length + 1;
if (newLength < 0 || newLength >= 1000000000) {
PrintError4(context, instructionPointer - 1, "The new length of the list is out of the supported range (0..1000000000).\n");
return 0;
}
uint32_t oldLength = context->heap[index].length;
entry->length = newLength;
if (entry->length > entry->allocated) {
// TODO Handling out of memory errors.
entry->allocated = entry->allocated ? entry->allocated * 2 : 4;
entry->list = (Value *) AllocateResize(entry->list, entry->allocated * sizeof(Value));
Assert(entry->length <= entry->allocated);
}
if (entry->internalValuesAreManaged != context->c->stackIsManaged[context->c->stackPointer - 1]) return -1;
entry->list[oldLength] = context->c->stack[context->c->stackPointer - 1];
context->c->stackPointer -= 2;
} else if (command == T_OP_INSERT) {
if (context->c->stackPointer < 3) return -1;
if (!context->c->stackIsManaged[context->c->stackPointer - 3]) return -1;
uint64_t index = context->c->stack[context->c->stackPointer - 3].i;
if (!index) {
PrintError4(context, instructionPointer - 1, "The list is null.\n");
return 0;
}
if (context->heapEntriesAllocated <= index) return -1;
HeapEntry *entry = &context->heap[index];
if (entry->type != T_LIST) return -1;
int64_t newLength = entry->length + 1;
if (newLength < 0 || newLength >= 1000000000) {
PrintError4(context, instructionPointer - 1, "The new length of the list is out of the supported range (0..1000000000).\n");
return 0;
}
uint32_t oldLength = context->heap[index].length;
entry->length = newLength;
if (entry->length > entry->allocated) {
// TODO Handling out of memory errors.
entry->allocated = entry->allocated ? entry->allocated * 2 : 4;
entry->list = (Value *) AllocateResize(entry->list, entry->allocated * sizeof(Value));
Assert(entry->length <= entry->allocated);
}
if (context->c->stackIsManaged[context->c->stackPointer - 1]) return -1;
int64_t insertIndex = context->c->stack[context->c->stackPointer - 1].i;
if (insertIndex < 0 || insertIndex > oldLength) {
PrintError4(context, instructionPointer - 1, "Cannot insert at index %ld. The list has length %ld.\n",
insertIndex, oldLength);
return 0;
}
for (int64_t i = oldLength - 1; i >= insertIndex; i--) {
entry->list[i + 1] = entry->list[i];
}
if (entry->internalValuesAreManaged != context->c->stackIsManaged[context->c->stackPointer - 2]) return -1;
entry->list[insertIndex] = context->c->stack[context->c->stackPointer - 2];
context->c->stackPointer -= 3;
} else if (command == T_OP_INSERT_MANY) {
if (context->c->stackPointer < 3) return -1;
if (!context->c->stackIsManaged[context->c->stackPointer - 3]) return -1;
uint64_t index = context->c->stack[context->c->stackPointer - 3].i;
if (!index) {
PrintError4(context, instructionPointer - 1, "The list is null.\n");
return 0;
}
if (context->heapEntriesAllocated <= index) return -1;
HeapEntry *entry = &context->heap[index];
if (entry->type != T_LIST) return -1;
if (context->c->stackIsManaged[context->c->stackPointer - 1]) return -1;
int64_t insertCount = context->c->stack[context->c->stackPointer - 1].i;
int64_t newLength = (int64_t) entry->length + insertCount;
if (insertCount < 0) {
PrintError4(context, instructionPointer - 1, "The number of items to insert is negative (%ld).\n", insertCount);
return 0;
} else if (newLength < 0 || newLength >= 1000000000) {
PrintError4(context, instructionPointer - 1, "The new length of the list (%ld + %ld = %ld) "
"is out of the supported range (0..1000000000).\n", (int64_t) entry->length, insertCount, newLength);
return 0;
}
uint32_t oldLength = context->heap[index].length;
entry->length = newLength;
if (entry->length > entry->allocated) {
// TODO Handling out of memory errors.
entry->allocated = entry->allocated ? entry->allocated * 2 : 4;
if (entry->length > entry->allocated) entry->allocated = entry->length + 5;
entry->list = (Value *) AllocateResize(entry->list, entry->allocated * sizeof(Value));
Assert(entry->length <= entry->allocated);
}
if (context->c->stackIsManaged[context->c->stackPointer - 2]) return -1;
int64_t insertIndex = context->c->stack[context->c->stackPointer - 2].i;
if (insertIndex < 0 || insertIndex > oldLength) {
PrintError4(context, instructionPointer - 1, "Cannot insert at index %ld. The list has length %ld.\n",
insertIndex, oldLength);
return 0;
}
for (int64_t i = oldLength - 1; i >= insertIndex; i--) {
entry->list[i + insertCount] = entry->list[i];
}
for (uintptr_t i = 0; i < (uintptr_t) insertCount; i++) {
entry->list[i + insertIndex].i = 0;
}
context->c->stackPointer -= 3;
} else if (command == T_OP_DELETE || command == T_OP_DELETE_MANY) {
int stackIndexList = command == T_OP_DELETE ? 2 : 3;
int stackIndexIndex = command == T_OP_DELETE ? 1 : 2;
if (context->c->stackPointer < (uintptr_t) stackIndexList) return -1;
if (!context->c->stackIsManaged[context->c->stackPointer - stackIndexList]) return -1;
uint64_t index = context->c->stack[context->c->stackPointer - stackIndexList].i;
if (!index) {
PrintError4(context, instructionPointer - 1, "The list is null.\n");
return 0;
}
if (context->heapEntriesAllocated <= index) return -1;
HeapEntry *entry = &context->heap[index];
if (entry->type != T_LIST) return -1;
if (context->c->stackIsManaged[context->c->stackPointer - 1]) return -1;
int64_t deleteCount = command == T_OP_DELETE ? 1 : context->c->stack[context->c->stackPointer - 1].i;
int64_t newLength = (int64_t) entry->length - deleteCount;
if (deleteCount < 0) {
PrintError4(context, instructionPointer - 1, "The number of items to delete is negative (%ld).\n", deleteCount);
return 0;
} else if (newLength < 0 || newLength >= 1000000000) {
PrintError4(context, instructionPointer - 1, "The new length of the list (%ld - %ld = %ld) "
"is out of the supported range (0..1000000000).\n", (int64_t) entry->length, deleteCount, newLength);
return 0;
}
// TODO Maybe shrink the list storage, if it will save a lot of memory.
if (context->c->stackIsManaged[context->c->stackPointer - stackIndexIndex]) return -1;
int64_t deleteIndex = context->c->stack[context->c->stackPointer - stackIndexIndex].i;
if (deleteIndex < 0 || deleteIndex > newLength) {
PrintError4(context, instructionPointer - 1, "Cannot delete %ld items starting at index %ld. The list has length %ld.\n",
deleteCount, deleteIndex, (int64_t) entry->length);
return 0;
}
for (int64_t i = deleteIndex; i < newLength; i++) {
entry->list[i] = entry->list[i + deleteCount];
}
entry->length = newLength;
context->c->stackPointer -= command == T_OP_DELETE ? 2 : 3;
} else if (command == T_OP_DELETE_ALL) {
if (context->c->stackPointer < 1) return -1;
if (!context->c->stackIsManaged[context->c->stackPointer - 1]) return -1;
uint64_t index = context->c->stack[context->c->stackPointer - 1].i;
if (!index) {
PrintError4(context, instructionPointer - 1, "The list is null.\n");
return 0;
}
if (context->heapEntriesAllocated <= index) return -1;
HeapEntry *entry = &context->heap[index];
if (entry->type != T_LIST) return -1;
context->heap[index].length = context->heap[index].allocated = 0;
context->heap[index].list = (Value *) AllocateResize(context->heap[index].list, 0);
context->c->stackPointer--;
} else if (command == T_OP_FIND_AND_DELETE || command == T_OP_FIND
|| command == T_OP_FIND_AND_DEL_STR || command == T_OP_FIND_STR) {
if (context->c->stackPointer < 2) return -1;
if (!context->c->stackIsManaged[context->c->stackPointer - 2]) return -1;
uint64_t index = context->c->stack[context->c->stackPointer - 2].i;
if (!index) {
PrintError4(context, instructionPointer - 1, "The list is null.\n");
return 0;
}
if (context->heapEntriesAllocated <= index) return -1;
HeapEntry *entry = &context->heap[index];
if (entry->type != T_LIST) return -1;
if (entry->internalValuesAreManaged != context->c->stackIsManaged[context->c->stackPointer - 1]) return -1;
if ((command == T_OP_FIND_STR || command == T_OP_FIND_AND_DEL_STR) && !entry->internalValuesAreManaged) return -1;
context->c->stack[context->c->stackPointer - 2].i = command == T_OP_FIND || command == T_OP_FIND_STR ? -1 : 0;
for (uintptr_t i = 0; i < entry->length; i++) {
if (command == T_OP_FIND_STR || command == T_OP_FIND_AND_DEL_STR) {
const char *text1, *text2;
size_t bytes1, bytes2;
ScriptHeapEntryToString(context, &context->heap[entry->list[i].i], &text1, &bytes1);
ScriptHeapEntryToString(context, &context->heap[context->c->stack[context->c->stackPointer - 1].i], &text2, &bytes2);
bool equal = bytes1 == bytes2 && 0 == MemoryCompare(text1, text2, bytes1);
if (!equal) continue;
} else {
bool equal = entry->list[i].i == context->c->stack[context->c->stackPointer - 1].i;
if (!equal) continue;
}
if (command == T_OP_FIND || command == T_OP_FIND_STR) {
context->c->stack[context->c->stackPointer - 2].i = i;
} else {
context->c->stack[context->c->stackPointer - 2].i = 1;
entry->length--;
for (uintptr_t j = i; j < entry->length; j++) {
entry->list[j] = entry->list[j + 1];
}
}
break;
}
context->c->stackIsManaged[context->c->stackPointer - 2] = false;
context->c->stackPointer--;
} else if (command == T_OP_DISCARD || command == T_OP_ASSERT) {
if (context->c->stackPointer < 1) return -1;
if (!context->c->stackIsManaged[context->c->stackPointer - 1]) return -1;
int64_t id = context->c->stack[context->c->stackPointer - 1].i;
uintptr_t index = HeapAllocate(context);
context->heap[index].type = command;
context->heap[index].lambdaID = id;
context->c->stackIsManaged[context->c->stackPointer - 1] = true;
context->c->stack[context->c->stackPointer - 1].i = index;
} else if (command == T_OP_CURRY) {
if (context->c->stackPointer < 2) return -1;
if (!context->c->stackIsManaged[context->c->stackPointer - 2]) return -1;
bool valueIsManaged = context->c->stackIsManaged[context->c->stackPointer - 1];
Value value = context->c->stack[context->c->stackPointer - 1];
int64_t id = context->c->stack[context->c->stackPointer - 2].i;
uintptr_t index = HeapAllocate(context);
context->heap[index].type = command;
context->heap[index].lambdaID = id;
context->heap[index].curryValue = value;
context->heap[index].internalValuesAreManaged = valueIsManaged;
context->c->stackIsManaged[context->c->stackPointer - 2] = true;
context->c->stack[context->c->stackPointer - 2].i = index;
context->c->stackPointer--;
} else if (command == T_OP_ASYNC) {
if (context->c->stackPointer < 1) return -1;
if (!context->c->stackIsManaged[context->c->stackPointer - 1]) return -1;
CoroutineState *c = (CoroutineState *) AllocateResize(NULL, sizeof(CoroutineState)); // TODO Handle allocation failure.
CoroutineState empty = { 0 };
*c = empty;
c->id = ++context->lastCoroutineID;
c->startedByAsync = true;
c->stackEntriesAllocated = sizeof(context->c->stack) / sizeof(context->c->stack[0]);
c->stackPointer = 2;
c->stack[0].i = -1; // Indicates to T_AWAIT to remove the coroutine.
c->stackIsManaged[0] = false;
c->stack[1] = context->c->stack[context->c->stackPointer - 1];
c->stackIsManaged[1] = true;
c->nextCoroutine = context->allCoroutines;
if (c->nextCoroutine) c->nextCoroutine->previousCoroutineLink = &c->nextCoroutine;
c->previousCoroutineLink = &context->allCoroutines;
context->allCoroutines = c;
c->nextUnblockedCoroutine = context->unblockedCoroutines;
if (c->nextUnblockedCoroutine) c->nextUnblockedCoroutine->previousUnblockedCoroutineLink = &c->nextUnblockedCoroutine;
c->previousUnblockedCoroutineLink = &context->unblockedCoroutines;
context->unblockedCoroutines = c;
context->c->stackIsManaged[context->c->stackPointer - 1] = false;
context->c->stack[context->c->stackPointer - 1].i = c->id;
} else if (command == T_AWAIT) {
awaitCommand:;
if (context->c->stackPointer < 1 && !context->c->externalCoroutine) return -1;
// PrintDebug("== AWAIT from %ld\n", context->c->id);
Assert(!context->c->nextUnblockedCoroutine && !context->c->previousUnblockedCoroutineLink);
bool unblockImmediately = false;
if (context->c->externalCoroutine) {
// PrintDebug("== external coroutine\n");
context->c->unblockedBy = -1;
context->c->awaiting = true;
context->c->instructionPointer = instructionPointer;
context->c->variableBase = variableBase;
context->c->waitingOnCount = 0;
} else if (context->c->stack[context->c->stackPointer - 1].i == -1) {
if (context->c->stackPointer != 1) return -1;
// The coroutine has finished. Remove it from the list of all coroutines.
*context->c->previousCoroutineLink = context->c->nextCoroutine;
if (context->c->nextCoroutine) context->c->nextCoroutine->previousCoroutineLink = context->c->previousCoroutineLink;
// PrintDebug("== finished\n");
for (uintptr_t i = 0; i < context->c->waiterCount; i++) {
CoroutineState *c = context->c->waiters[i];
if (!c) continue;
Assert(!c->nextUnblockedCoroutine && !c->previousUnblockedCoroutineLink);
c->unblockedBy = context->c->id;
c->nextUnblockedCoroutine = context->unblockedCoroutines;
if (c->nextUnblockedCoroutine) c->nextUnblockedCoroutine->previousUnblockedCoroutineLink = &c->nextUnblockedCoroutine;
c->previousUnblockedCoroutineLink = &context->unblockedCoroutines;
context->unblockedCoroutines = c;
for (uintptr_t j = 0; j < c->waitingOnCount; j++) {
Assert(*(c->waitingOn[j]) == c);
*(c->waitingOn[j]) = NULL;
}
c->waitingOnCount = 0;
// PrintDebug("== unblocked %ld\n", c->id);
}
ScriptFreeCoroutine(context->c);
} else {
if (!context->c->stackIsManaged[context->c->stackPointer - 1]) return -1;
// The coroutine is waiting.
context->c->unblockedBy = -1;
context->c->awaiting = true;
context->c->instructionPointer = instructionPointer;
context->c->variableBase = variableBase;
uint64_t index = context->c->stack[context->c->stackPointer - 1].i;
if (context->heapEntriesAllocated <= index) return -1;
HeapEntry *entry = &context->heap[index];
if (entry->internalValuesAreManaged || entry->type != T_LIST) return -1;
context->c->waitingOn = (CoroutineState ***) AllocateResize(context->c->waitingOn, sizeof(CoroutineState **) * entry->length);
Assert(context->c->waitingOnCount == 0);
CoroutineState *c = context->allCoroutines;
while (c) {
for (uintptr_t i = 0; i < entry->length; i++) {
if (c->id == (uint64_t) entry->list[i].i) {
if (c->waiterCount == c->waitersAllocated) {
c->waitersAllocated = c->waitersAllocated ? c->waitersAllocated * 2 : 4;
c->waiters = (CoroutineState **) AllocateResize(c->waiters, sizeof(CoroutineState *) * c->waitersAllocated);
}
c->waiters[c->waiterCount] = context->c;
context->c->waitingOn[context->c->waitingOnCount++] = &c->waiters[c->waiterCount];
c->waiterCount++;
}
}
c = c->nextCoroutine;
}
// PrintDebug("== waiting on %d...\n", context->c->waitingOnCount);
if (!context->c->waitingOnCount) {
// PrintDebug("== immediately unblocking\n");
context->c->unblockedBy = entry->length ? entry->list[0].i : -1;
unblockImmediately = true;
}
}
CoroutineState *next = unblockImmediately ? context->c : context->unblockedCoroutines;
if (!next) {
if (context->externalCoroutineCount) {
// PrintDebug("== wait for an external coroutine\n");
next = ExternalCoroutineWaitAny(context);
Assert(next->externalCoroutine);
unblockImmediately = true;
} else {
// TODO Earlier deadlock detection.
PrintError4(context, instructionPointer - 1, "No tasks can run if this task (ID %ld) starts waiting.\n", context->c->id);
PrintDebug("All tasks:\n");
CoroutineState *c = context->allCoroutines;
while (c) {
PrintDebug("\t%ld blocks ", c->id);
bool first = true;
for (uintptr_t i = 0; i < c->waiterCount; i++) {
if (!c->waiters[i]) continue;
PrintDebug("%s%ld", first ? "" : ", ", c->waiters[i]->id);
first = false;
}
PrintDebug("\n");
PrintBackTrace(context, c->instructionPointer - 1, c, "\t");
c = c->nextCoroutine;
}
return 0;
}
}
if (!unblockImmediately) {
Assert(next->previousUnblockedCoroutineLink);
*next->previousUnblockedCoroutineLink = next->nextUnblockedCoroutine;
if (next->nextUnblockedCoroutine) next->nextUnblockedCoroutine->previousUnblockedCoroutineLink = next->previousUnblockedCoroutineLink;
}
next->nextUnblockedCoroutine = NULL;
next->previousUnblockedCoroutineLink = NULL;
context->c = next;
// PrintDebug("== switch to %ld\n", next->id);
if (context->c->awaiting) {
if (!context->c->externalCoroutine) {
context->c->stackIsManaged[context->c->stackPointer - 1] = false;
context->c->stack[context->c->stackPointer - 1].i = context->c->unblockedBy;
}
instructionPointer = context->c->instructionPointer;
variableBase = context->c->variableBase;
// PrintDebug("== unblocked by %ld\n", context->c->unblockedBy);
} else {
// PrintDebug("== just started\n");
instructionPointer = 1; // There is a T_AWAIT command at address 1.
goto callCommand;
}
} else if (command == T_REPL_RESULT) {
if (context->c->stackPointer < 1) return -1;
ExternalPassREPLResult(context, context->c->stack[--context->c->stackPointer]);
} else if (command == T_END_FUNCTION || command == T_EXTCALL || command == T_LIBCALL) {
if (command == T_EXTCALL) {
uint16_t index = functionData[instructionPointer + 0] + (functionData[instructionPointer + 1] << 8);
instructionPointer += 2;
if (index < sizeof(externalFunctions) / sizeof(externalFunctions[0])) {
Value returnValue;
int result = externalFunctions[index].callback(context, &returnValue);
if (result <= 0) return result;
if (result == EXTCALL_START_COROUTINE) {
context->externalCoroutineCount++;
context->c->externalCoroutine = true;
instructionPointer -= 3;
// PrintDebug("start external coroutine %ld\n", context->c->id);
goto awaitCommand;
} else if (context->c->externalCoroutine) {
context->externalCoroutineCount--;
context->c->externalCoroutine = false;
// PrintDebug("end external coroutine %ld\n", context->c->id);
}
bool isErr = result == EXTCALL_RETURN_ERR_ERROR
|| result == EXTCALL_RETURN_ERR_MANAGED
|| result == EXTCALL_RETURN_ERR_UNMANAGED;
if (result == EXTCALL_RETURN_UNMANAGED || result == EXTCALL_RETURN_MANAGED || isErr) {
if (context->c->stackPointer == context->c->stackEntriesAllocated) {
PrintDebug("Evaluation stack overflow.\n");
return -1;
}
if (isErr) {
if (result != EXTCALL_RETURN_ERR_ERROR || returnValue.i) {
// Temporarily put the return value on the stack in case garbage collection occurs
// in the following HeapAllocate (i.e. before the return value has been wrapped).
context->c->stackIsManaged[context->c->stackPointer] = result != EXTCALL_RETURN_ERR_UNMANAGED;
context->c->stack[context->c->stackPointer++] = returnValue;
// TODO Handle memory allocation failures here.
uintptr_t index = HeapAllocate(context);
context->heap[index].type = T_ERR;
context->heap[index].success = result != EXTCALL_RETURN_ERR_ERROR;
context->heap[index].internalValuesAreManaged = result != EXTCALL_RETURN_ERR_UNMANAGED;
context->heap[index].errorValue = returnValue;
returnValue.i = index;
context->c->stackPointer--;
} else {
// Unknown error.
returnValue.i = 0;
}
result = EXTCALL_RETURN_MANAGED;
}
context->c->stackIsManaged[context->c->stackPointer] = result == EXTCALL_RETURN_MANAGED;
context->c->stack[context->c->stackPointer++] = returnValue;
}
} else {
return -1;
}
} else if (command == T_LIBCALL) {
context->c->parameterCount = 0;
context->c->returnValueType = EXTCALL_NO_RETURN;
void *address;
MemoryCopy(&address, &functionData[instructionPointer], sizeof(address));
instructionPointer += sizeof(address);
if (!((bool (*)(void *)) address)(context)) {
return 0;
}
context->c->stackPointer -= context->c->parameterCount;
if (context->c->returnValueType != EXTCALL_NO_RETURN) {
if (context->c->stackPointer == context->c->stackEntriesAllocated) {
PrintDebug("Evaluation stack overflow.\n");
return -1;
}
context->c->stackIsManaged[context->c->stackPointer] = context->c->returnValueType == EXTCALL_RETURN_MANAGED;
context->c->stack[context->c->stackPointer++] = context->c->returnValue;
}
}
context->c->localVariableCount = variableBase + 1;
if (context->c->backTracePointer) {
BackTraceItem *item = &context->c->backTrace[context->c->backTracePointer - 1];
if (command == T_EXTCALL || command == T_LIBCALL) {
context->c->backTracePointer--;
instructionPointer = item->instructionPointer;
variableBase = item->variableBase;
}
if (item->popResult) {
if (context->c->stackPointer < 1) return -1;
context->c->stackPointer--;
} else if (item->assertResult) {
if (context->c->stackPointer < 1) return -1;
Value condition = context->c->stack[--context->c->stackPointer];
if (condition.i == 0) {
PrintError4(context, instructionPointer - 1, "Return value was false on an asserting function pointer.\n");
return 0;
}
}
if (command != T_EXTCALL && command != T_LIBCALL) {
context->c->backTracePointer--;
instructionPointer = item->instructionPointer;
variableBase = item->variableBase;
}
} else {
break;
}
} else if (command == T_END_CALLBACK) {
break;
} else {
PrintDebug("Unknown command %d.\n", command);
return -1;
}
}
if (context->allCoroutines->nextCoroutine || context->allCoroutines->startedByAsync) {
PrintError3("Script ended with unfinished tasks.\n");
return false;
}
return true;
}
bool ScriptParseOptions(ExecutionContext *context) {
for (uintptr_t i = 0; i < optionCount; i++) {
uintptr_t equalsPosition = 0;
uintptr_t optionLength = 0;
for (uintptr_t j = 0; options[i][j]; j++) {
if (options[i][j] == '=') {
equalsPosition = j;
break;
}
}
for (uintptr_t j = 0; options[i][j]; j++) {
optionLength++;
}
if (!equalsPosition) {
PrintError3("Invalid script option passed on command line '%s'.\n", options[i]);
return false;
}
uintptr_t index = 0;
Node *node = NULL;
for (uintptr_t j = 0; j < context->rootNode->scope->entryCount; j++) {
if (context->rootNode->scope->entries[j]->token.textBytes == equalsPosition
&& 0 == MemoryCompare(context->rootNode->scope->entries[j]->token.text, options[i], equalsPosition)
&& context->rootNode->scope->entries[j]->type == T_DECLARE) {
node = context->rootNode->scope->entries[j];
break;
}
if (ScopeIsVariableType(context->rootNode->scope->entries[j])) {
index++;
}
}
if (!node) {
continue;
}
index += context->functionData->globalVariableOffset;
if (node->expressionType->type == T_STR) {
uintptr_t heapIndex = HeapAllocate(context);
context->heap[heapIndex].type = T_STR;
context->heap[heapIndex].bytes = optionLength - equalsPosition - 1;
context->heap[heapIndex].text = (char *) AllocateResize(NULL, context->heap[heapIndex].bytes);
context->globalVariables[index].i = heapIndex;
MemoryCopy(context->heap[heapIndex].text, options[i] + equalsPosition + 1, context->heap[heapIndex].bytes);
} else if (node->expressionType->type == T_INT) {
// TODO Overflow checking.
Value v;
v.i = 0;
for (uintptr_t j = 0; options[i][j + equalsPosition + 1]; j++) {
char c = options[i][j + equalsPosition + 1];
if (c >= '0' && c <= '9') {
v.i *= 10;
v.i += c - '0';
} else {
PrintError3("Option '%s' should be an integer.\n", options[i]);
return false;
}
}
context->globalVariables[index] = v;
} else if (node->expressionType->type == T_BOOL) {
char c = options[i][equalsPosition + 1];
bool truthy = c == 't' || c == 'y' || c == '1';
bool falsey = c == 'f' || c == 'n' || c == '0';
if (!truthy && !falsey) {
PrintError3("#option variable '%.*s' should be a boolean value 'true' or 'false'.\n", node->token.textBytes, node->token.text);
return false;
}
context->globalVariables[index].i = truthy ? 1 : 0;
} else {
PrintError3("#option variable '%.*s' is not of string, boolean or integer type.\n", node->token.textBytes, node->token.text);
return false;
}
if (optionsMatched[i]) {
PrintError3("Script option passed on command line '%s' matches multiple #option variables in different modules.\n", options[i]);
return false;
}
optionsMatched[i] = true;
}
return true;
}
bool ScriptParameterCString(void *engine, char **output) {
ExecutionContext *context = (ExecutionContext *) engine;
context->c->parameterCount++;
if (context->c->stackPointer < context->c->parameterCount) return false;
if (!context->c->stackIsManaged[context->c->stackPointer - context->c->parameterCount]) return false;
uint64_t index = context->c->stack[context->c->stackPointer - context->c->parameterCount].i;
if (context->heapEntriesAllocated <= index) return false;
const char *text;
size_t bytes;
HeapEntry *entry = &context->heap[index];
ScriptHeapEntryToString(context, entry, &text, &bytes);
*output = (char *) AllocateResize(NULL, bytes + 1);
MemoryCopy(*output, text, bytes);
(*output)[bytes] = 0;
return true;
}
void ScriptHeapRefClose(void *engine, intptr_t index) {
ExecutionContext *context = (ExecutionContext *) engine;
Assert(index >= 0 || index < (intptr_t) context->heapEntriesAllocated);
Assert(context->heap[index].externalReferenceCount);
context->heap[index].externalReferenceCount--;
}
bool ScriptParameterHeapRef(void *engine, intptr_t *output) {
ExecutionContext *context = (ExecutionContext *) engine;
context->c->parameterCount++;
if (context->c->stackPointer < context->c->parameterCount) return false;
intptr_t index = context->c->stack[context->c->stackPointer - context->c->parameterCount].i;
if (index < 0 || index >= (intptr_t) context->heapEntriesAllocated) return false;
if (context->heap[index].externalReferenceCount == 0xFFFFFFFF) return false;
context->heap[index].externalReferenceCount++;
*output = index;
return true;
}
bool ScriptParameterInt64(void *engine, int64_t *output) {
ExecutionContext *context = (ExecutionContext *) engine;
context->c->parameterCount++;
if (context->c->stackPointer < context->c->parameterCount) return false;
*output = context->c->stack[context->c->stackPointer - context->c->parameterCount].i;
return true;
}
bool ScriptParameterDouble(void *engine, double *output) {
ExecutionContext *context = (ExecutionContext *) engine;
context->c->parameterCount++;
if (context->c->stackPointer < context->c->parameterCount) return false;
*output = context->c->stack[context->c->stackPointer - context->c->parameterCount].f;
return true;
}
bool ScriptParameterBool (void *engine, bool *output) { int64_t i; if (!ScriptParameterInt64(engine, &i)) return false; *output = i; return true; }
bool ScriptParameterUint32(void *engine, uint32_t *output) { int64_t i; if (!ScriptParameterInt64(engine, &i)) return false; *output = i; return true; }
bool ScriptParameterUint64(void *engine, uint64_t *output) { int64_t i; if (!ScriptParameterInt64(engine, &i)) return false; *output = i; return true; }
bool ScriptParameterInt32 (void *engine, int32_t *output) { int64_t i; if (!ScriptParameterInt64(engine, &i)) return false; *output = i; return true; }
void ScriptReturnInt(void *engine, int64_t input) {
ExecutionContext *context = (ExecutionContext *) engine;
Assert(context->c->returnValueType == EXTCALL_NO_RETURN);
context->c->returnValueType = EXTCALL_RETURN_UNMANAGED;
context->c->returnValue.i = input;
}
bool ScriptParameterPointer(void *engine, void **output) {
int64_t i;
if (!ScriptParameterInt64(engine, &i)) return false;
*output = (void *) (intptr_t) i;
return true;
}
void ScriptReturnPointer(void *engine, void *input) {
ScriptReturnInt(engine, (int64_t) (intptr_t) input);
}
bool ScriptRunCallback(void *engine, intptr_t functionPointer, int64_t *parameters, bool *managedParameters, size_t parameterCount) {
// TODO Do this in a separate coroutine?
ExecutionContext *context = (ExecutionContext *) engine;
for (intptr_t i = parameterCount - 1; i >= -1; i--) {
if (context->c->stackPointer == context->c->stackEntriesAllocated) {
PrintError4(context, 0, "Stack overflow.\n");
return false;
}
if (i == -1) {
context->c->stack[context->c->stackPointer].i = functionPointer;
context->c->stackIsManaged[context->c->stackPointer] = true;
} else {
context->c->stack[context->c->stackPointer].i = parameters[i];
context->c->stackIsManaged[context->c->stackPointer] = managedParameters[i];
}
context->c->stackPointer++;
}
int result = ScriptExecuteFunction(2, context);
if (result == -1) PrintError3("The script was malformed.\n");
return result > 0;
}
bool ScriptLoad(Tokenizer tokenizer, ExecutionContext *context, ImportData *importData, bool replMode) {
Node *previousRootNode = context->rootNode;
ImportData *previousImportData = context->functionData->importData;
context->rootNode = replMode ? ParseRootREPL(&tokenizer) : ParseRoot(&tokenizer);
context->functionData->importData = tokenizer.module;
uint8_t b = 0; // Make sure no function can start at 0.
FunctionBuilderAppend(context->functionData, &b, sizeof(b));
b = T_AWAIT; // Put a T_AWAIT command at address 1.
FunctionBuilderAppend(context->functionData, &b, sizeof(b));
b = T_CALL; // Put a T_CALL command at address 2 (for ScriptRunCallback).
FunctionBuilderAppend(context->functionData, &b, sizeof(b));
b = T_END_CALLBACK; // Put a T_END_CALLBACK command at address 3 (for ScriptRunCallback).
FunctionBuilderAppend(context->functionData, &b, sizeof(b));
bool success = context->rootNode
&& ASTSetScopes(&tokenizer, context, context->rootNode, NULL)
&& ASTLookupTypeIdentifiers(&tokenizer, context->rootNode)
&& ASTSetTypes(&tokenizer, context->rootNode)
&& ASTCheckForReturnStatements(&tokenizer, context->rootNode)
&& ASTGenerate(&tokenizer, context->rootNode, context)
&& ScriptParseOptions(context);
importData->globalVariableOffset = context->functionData->globalVariableOffset;
importData->rootNode = context->rootNode;
*importedModulesLink = importData;
importedModulesLink = &importData->nextImport;
context->rootNode = previousRootNode;
context->functionData->importData = previousImportData;
return success;
}
int ScriptExecute(ExecutionContext *context, ImportData *mainModule) {
bool optionMatchingError = false;
for (uintptr_t i = 0; i < optionCount; i++) {
if (!optionsMatched[i]) {
PrintError3("Script option passed on command line '%s' does not match any #option variable.\n", options[i]);
optionMatchingError = true;
}
}
if (optionMatchingError) {
return 1;
}
Node n;
n.token.textBytes = startFunctionBytes;
n.token.text = startFunction;
intptr_t startIndex = ScopeLookupIndex(&n, mainModule->rootNode->scope, true, false);
if (startIndex == -1) {
PrintError3("The script does not have a start function '%.*s'.\n", startFunctionBytes, startFunction);
return 1;
}
Node mainFunctionArguments = { 0 };
mainFunctionArguments.type = T_ARGUMENTS;
Node mainFunctionReturn = { 0 };
mainFunctionReturn.type = T_VOID;
Node mainFunctionType = { 0 };
mainFunctionType.type = T_FUNCPTR;
mainFunctionType.firstChild = &mainFunctionArguments;
mainFunctionArguments.sibling = &mainFunctionReturn;
if (!ASTMatching(&mainFunctionType, mainModule->rootNode->scope->entries[ScopeLookupIndex(&n, mainModule->rootNode->scope, false, true)]->expressionType)) {
PrintError3("The start function '%.*s' should take no arguments and return 'void'.\n", startFunctionBytes, startFunction);
return 1;
}
ImportData *module = importedModules;
while (module) {
Node n;
n.token.textBytes = 10;
n.token.text = "Initialise";
intptr_t index = ScopeLookupIndex(&n, module->rootNode->scope, true, false);
if (index != -1) {
if (!ASTMatching(&mainFunctionType, module->rootNode->scope->entries[ScopeLookupIndex(&n, module->rootNode->scope, false, true)]->expressionType)) {
PrintError3("The 'Initialise' function in the module '%s' should take no arguments and return 'void'.\n", module->path);
return 1;
}
int result = ScriptExecuteFunction(context->heap[context->globalVariables[index + module->globalVariableOffset].i].lambdaID, context);
if (result == 0) {
// A runtime error occurred.
return 1;
} else if (result == -1 || context->c->stackPointer != 0) {
PrintError3("The script was malformed.\n");
return 1;
}
}
module = module->nextImport;
}
int result = ScriptExecuteFunction(context->heap[context->globalVariables[context->functionData->globalVariableOffset + startIndex].i].lambdaID, context);
if (result == 0) {
// A runtime error occurred.
return 1;
} else if (result == -1 || context->c->stackPointer != 0) {
PrintError3("The script was malformed.\n");
return 1;
}
return 0;
}
void ScriptFreeCoroutine(CoroutineState *c) {
AllocateResize(c->waiters, 0);
AllocateResize(c->waitingOn, 0);
AllocateResize(c->localVariables, 0);
AllocateResize(c->localVariableIsManaged, 0);
AllocateResize(c, 0);
}
void ScriptFree(ExecutionContext *context) {
ImportData *module = importedModules;
while (module) {
if (module->pathBytes != 15 || 0 != MemoryCompare(module->path, "__base_module__", module->pathBytes)) {
AllocateResize(module->fileData, 0);
}
ASTFreeScopes(module->rootNode);
module = module->nextImport;
}
for (uintptr_t i = 1; i < context->heapEntriesAllocated; i++) {
if (context->heap[i].type != T_ERROR) {
HeapFreeEntry(context, i);
}
}
CoroutineState *coroutine = context->allCoroutines;
while (coroutine) {
CoroutineState *next = coroutine->nextCoroutine;
ScriptFreeCoroutine(coroutine);
coroutine = next;
}
AllocateResize(context->heap, 0);
AllocateResize(context->globalVariables, 0);
AllocateResize(context->globalVariableIsManaged, 0);
AllocateResize(context->functionData->lineNumbers, 0);
AllocateResize(context->functionData->data, 0);
AllocateResize(context->scriptPersistFile, 0);
}
// --------------------------------- Helpers.
void LineNumberLookup(ExecutionContext *context, uint32_t instructionPointer, LineNumber *output) {
for (uintptr_t i = 0; i < context->functionData->lineNumberCount; i++) {
if (context->functionData->lineNumbers[i].instructionPointer == instructionPointer) {
*output = context->functionData->lineNumbers[i];
return;
}
}
}
void PrintBackTrace(ExecutionContext *context, uint32_t instructionPointer, CoroutineState *c, const char *prefix) {
LineNumber lineNumber = { 0 };
LineNumberLookup(context, instructionPointer, &lineNumber);
if (lineNumber.importData) {
PrintDebug("%s\t%s:%d %s %.*s\n", prefix, lineNumber.importData->path, lineNumber.lineNumber, lineNumber.function ? "in" : "",
lineNumber.function ? (int) lineNumber.function->textBytes : 0, lineNumber.function ? lineNumber.function->text : "");
}
uintptr_t btp = c->backTracePointer;
uintptr_t minimum = c->startedByAsync ? 1 : 0;
while (btp > minimum) {
BackTraceItem *link = &c->backTrace[--btp];
LineNumberLookup(context, link->instructionPointer - 1, &lineNumber);
PrintDebug("%s\t%s:%d %s %.*s\n", prefix, lineNumber.importData->path ? lineNumber.importData->path : "??",
lineNumber.lineNumber, lineNumber.function ? "in" : "",
lineNumber.function ? (int) lineNumber.function->textBytes : 0, lineNumber.function ? lineNumber.function->text : "");
}
}
void PrintLine(ImportData *importData, uintptr_t line) {
if (!importData) {
return;
}
uintptr_t position = 0;
for (uintptr_t i = 1; i < line; i++) {
while (position < importData->fileDataBytes) {
if (((char *) importData->fileData)[position] == '\n') {
position++;
break;
}
position++;
}
}
uintptr_t length = 0;
for (uintptr_t i = position; i <= importData->fileDataBytes; i++) {
if (i == importData->fileDataBytes || ((char *) importData->fileData)[i] == '\n') {
length = i - position;
break;
}
}
PrintDebug(">> %.*s\n", (int) length, &((char *) importData->fileData)[position]);
}
int ScriptExecuteFromFile(char *scriptPath, size_t scriptPathBytes, char *fileData, size_t fileDataBytes, bool replMode) {
Tokenizer tokenizer = { 0 };
ImportData importData = { 0 };
importData.path = scriptPath;
importData.pathBytes = scriptPathBytes;
importData.fileData = fileData;
importData.fileDataBytes = fileDataBytes;
tokenizer.module = &importData;
tokenizer.line = 1;
tokenizer.input = fileData;
tokenizer.inputBytes = fileDataBytes;
FunctionBuilder builder = { 0 };
ExecutionContext context = { 0 };
context.functionData = &builder;
context.mainModule = &importData;
context.heapEntriesAllocated = 2;
context.heap = (HeapEntry *) AllocateResize(NULL, sizeof(HeapEntry) * context.heapEntriesAllocated);
context.heap[0].type = T_EOF;
context.heap[1].type = T_ERROR;
context.heap[1].nextUnusedEntry = 0;
context.heapFirstUnusedEntry = 1;
context.c = (CoroutineState *) AllocateResize(0, sizeof(CoroutineState));
CoroutineState empty = { 0 };
*context.c = empty;
context.c->stackEntriesAllocated = sizeof(context.c->stack) / sizeof(context.c->stack[0]);
context.c->previousCoroutineLink = &context.allCoroutines;
context.allCoroutines = context.c;
int result = ScriptLoad(tokenizer, &context, &importData, replMode) ? ScriptExecute(&context, &importData) : 1;
ScriptFree(&context);
importedModules = NULL;
importedModulesLink = &importedModules;
return result;
}
int ExternalStringSlice(ExecutionContext *context, Value *returnValue) {
(void) returnValue;
if (context->c->stackPointer < 3) return -1;
STACK_POP_STRING(string, bytes);
uint64_t start = context->c->stack[--context->c->stackPointer].i;
if (context->c->stackIsManaged[context->c->stackPointer]) return -1;
uint64_t end = context->c->stack[--context->c->stackPointer].i;
if (context->c->stackIsManaged[context->c->stackPointer]) return -1;
if (start > bytes || end > bytes || end < start) {
PrintError4(context, 0, "The slice range (%ld..%ld) is invalid for the string of length %ld.\n",
start, end, bytes);
return 0;
}
RETURN_STRING_COPY(string + start, end - start);
return EXTCALL_RETURN_MANAGED;
}
int ExternalCharacterToByte(ExecutionContext *context, Value *returnValue) {
(void) returnValue;
STACK_POP_STRING(entryText, entryBytes);
returnValue->i = entryBytes ? entryText[0] : -1;
return EXTCALL_RETURN_UNMANAGED;
}
// --------------------------------- Platform layer.
#if defined(_WIN32) || defined(__linux__) || defined(__APPLE__)
#ifdef _WIN32
#include <direct.h>
#include <windows.h>
#define getcwd _getcwd
#define popen _popen
#define pclose _pclose
#define setenv(x, y, z) !SetEnvironmentVariable(x, y)
#else
#include <dlfcn.h>
#include <dirent.h>
#include <unistd.h>
#include <sys/utsname.h>
#include <sys/wait.h>
#include <pthread.h>
#include <semaphore.h>
#endif
#include <errno.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
void **fixedAllocationBlocks;
uint8_t *fixedAllocationCurrentBlock;
uintptr_t fixedAllocationCurrentPosition;
size_t fixedAllocationCurrentSize;
sem_t externalCoroutineSemaphore;
pthread_mutex_t externalCoroutineMutex;
CoroutineState *externalCoroutineUnblockedList;
bool systemShellLoggingEnabled = true;
bool coloredOutput;
char *scriptSourceDirectory;
DIR *directoryIterator;
char *StringZeroTerminate(const char *text, size_t bytes) {
char *buffer = malloc(bytes + 1);
if (!buffer) return NULL;
memcpy(buffer, text, bytes);
buffer[bytes] = 0;
return buffer;
}
#define RETURN_ERROR(error) do { MakeError(context, returnValue, error); return EXTCALL_RETURN_ERR_ERROR; } while (0)
void MakeError(ExecutionContext *context, Value *returnValue, int error) {
const char *text = NULL;
if (error == EAGAIN || error == EBUSY) text = "OPERATION_BLOCKED";
if (error == ENOTEMPTY) text = "DIRECTORY_NOT_EMPTY";
if (error == EFBIG) text = "FILE_TOO_LARGE";
if (error == ENOSPC || error == EDQUOT) text = "DRIVE_FULL";
if (error == EROFS) text = "FILE_ON_READ_ONLY_VOLUME";
if (error == ENOTDIR || error == EISDIR) text = "INCORRECT_NODE_TYPE";
if (error == ENOENT) text = "FILE_DOES_NOT_EXIST";
if (error == EEXIST) text = "ALREADY_EXISTS";
if (error == ENOMEM) text = "INSUFFICIENT_RESOURCES";
if (error == EPERM || error == EACCES) text = "PERMISSION_NOT_GRANTED";
if (error == EXDEV) text = "VOLUME_MISMATCH";
if (error == EIO) text = "HARDWARE_FAILURE";
if (text) {
RETURN_STRING_COPY(text, strlen(text));
} else {
returnValue->i = 0;
}
}
void ExternalCoroutineDone(CoroutineState *coroutine) {
#ifdef __linux__
pthread_mutex_lock(&externalCoroutineMutex);
coroutine->nextExternalCoroutine = externalCoroutineUnblockedList;
externalCoroutineUnblockedList = coroutine;
pthread_mutex_unlock(&externalCoroutineMutex);
sem_post(&externalCoroutineSemaphore);
#else
(void) coroutine;
#endif
}
void *SystemShellExecuteThread(void *_coroutine) {
CoroutineState *coroutine = (CoroutineState *) _coroutine;
coroutine->externalCoroutineData.i = system((char *) coroutine->externalCoroutineData2) == 0;
free((char *) coroutine->externalCoroutineData2);
ExternalCoroutineDone(coroutine);
return NULL;
}
int ExternalSystemShellExecute(ExecutionContext *context, Value *returnValue) {
if (context->c->externalCoroutine) {
*returnValue = context->c->externalCoroutineData;
return EXTCALL_RETURN_UNMANAGED;
}
STACK_POP_STRING(text, bytes);
char *temporary = StringZeroTerminate(text, bytes);
if (temporary) {
if (systemShellLoggingEnabled) PrintDebug("\033[0;32m%s\033[0m\n", temporary);
context->c->externalCoroutineData2 = temporary;
#ifdef __linux__
pthread_t thread;
pthread_create(&thread, NULL, SystemShellExecuteThread, context->c);
pthread_detach(thread);
return EXTCALL_START_COROUTINE;
#else
SystemShellExecuteThread(context->c);
*returnValue = context->c->externalCoroutineData;
return EXTCALL_RETURN_UNMANAGED;
#endif
} else {
fprintf(stderr, "Error in ExternalSystemShellExecute: Out of memory.\n");
returnValue->i = 0;
return EXTCALL_RETURN_UNMANAGED;
}
}
void *SystemShellExecuteWithWorkingDirectoryThread(void *_coroutine) {
CoroutineState *coroutine = (CoroutineState *) _coroutine;
int status;
pid_t p = waitpid(coroutine->externalCoroutineData.i, &status, 0);
if (p != coroutine->externalCoroutineData.i) {
fprintf(stderr, "waitpid returned %d\n", p);
perror("waitpid failed");
coroutine->externalCoroutineData.i = 0;
} else {
coroutine->externalCoroutineData.i = WEXITSTATUS(status) == 0;
}
ExternalCoroutineDone(coroutine);
return NULL;
}
int ExternalSystemShellExecuteWithWorkingDirectory(ExecutionContext *context, Value *returnValue) {
if (context->c->externalCoroutine) {
*returnValue = context->c->externalCoroutineData;
return EXTCALL_RETURN_UNMANAGED;
}
STACK_POP_STRING_2(entryText, entryBytes, entry2Text, entry2Bytes);
returnValue->i = 0;
char *temporary = StringZeroTerminate(entryText, entryBytes);
if (!temporary) return EXTCALL_RETURN_MANAGED;
char *temporary2 = StringZeroTerminate(entry2Text, entry2Bytes);
if (!temporary2) return EXTCALL_RETURN_MANAGED;
if (systemShellLoggingEnabled) PrintDebug("\033[0;32m(%s) %s\033[0m\n", temporary, temporary2);
#ifdef __linux__
pid_t pid = fork();
if (pid == 0) {
Assert(chdir(temporary) == 0);
exit(system(temporary2));
} else if (pid < 0) {
PrintDebug("Unable to fork(), got pid = %d, errno = %d.\n", pid, errno);
returnValue->i = 0;
}
free(temporary);
free(temporary2);
if (pid > 0) {
context->c->externalCoroutineData.i = pid;
pthread_t thread;
pthread_create(&thread, NULL, SystemShellExecuteWithWorkingDirectoryThread, context->c);
pthread_detach(thread);
return EXTCALL_START_COROUTINE;
}
#else
char *data = (char *) malloc(10000);
if (!data || data != getcwd(data, 10000)) {
PrintError4(context, 0, "Could not get the working directory.\n");
free(data);
return 0;
}
Assert(chdir(temporary) == 0);
returnValue->i = system(temporary2) == 0;
chdir(data);
free(temporary);
free(temporary2);
free(data);
#endif
return EXTCALL_RETURN_UNMANAGED;
}
int ExternalSystemShellEvaluate(ExecutionContext *context, Value *returnValue) {
STACK_POP_STRING(text, bytes);
char *temporary = StringZeroTerminate(text, bytes);
if (temporary) {
FILE *f = popen(temporary, "r");
if (f) {
char *buffer = NULL;
size_t position = 0;
size_t bufferAllocated = 0;
while (true) {
if (position == bufferAllocated) {
bufferAllocated = bufferAllocated ? bufferAllocated * 2 : 64;
char *reallocated = (char *) realloc(buffer, bufferAllocated);
if (!reallocated) break;
buffer = reallocated;
}
intptr_t bytesRead = fread(buffer + position, 1, bufferAllocated - position, f);
if (bytesRead <= 0) {
break;
}
position += bytesRead;
}
buffer = (char *) realloc(buffer, position); // Shrink to match the size exactly.
pclose(f);
RETURN_STRING_NO_COPY(buffer, position);
} else {
returnValue->i = 0;
}
free(temporary);
} else {
fprintf(stderr, "Error in ExternalSystemShellEvaluate: Out of memory.\n");
returnValue->i = 0;
}
return EXTCALL_RETURN_MANAGED;
}
int ExternalSystemShellEnableLogging(ExecutionContext *context, Value *returnValue) {
(void) returnValue;
if (context->c->stackPointer < 1) return -1;
systemShellLoggingEnabled = context->c->stack[--context->c->stackPointer].i;
if (context->c->stackIsManaged[context->c->stackPointer]) return -1;
return EXTCALL_NO_RETURN;
}
int ExternalLog(ExecutionContext *context, Value *returnValue) {
(void) returnValue;
STACK_POP_STRING(entryText, entryBytes);
fprintf(stderr, "%.*s", (int) entryBytes, (char *) entryText);
fprintf(stderr, coloredOutput ? "\033[0;m\n" : "\n");
return EXTCALL_NO_RETURN;
}
int ExternalConsoleWriteStdout(ExecutionContext *context, Value *returnValue) {
(void) returnValue;
STACK_POP_STRING(entryText, entryBytes);
printf("%.*s", (int) entryBytes, (char *) entryText);
return EXTCALL_NO_RETURN;
}
int ExternalConsoleWriteStderr(ExecutionContext *context, Value *returnValue) {
(void) returnValue;
STACK_POP_STRING(entryText, entryBytes);
fprintf(stderr, "%.*s", (int) entryBytes, (char *) entryText);
return EXTCALL_NO_RETURN;
}
int ExternalLogOpenGroup(ExecutionContext *context, Value *returnValue) {
(void) returnValue;
if (context->c->stackPointer < 1) return -1;
context->c->stackPointer--;
return EXTCALL_NO_RETURN;
}
int ExternalLogClose(ExecutionContext *context, Value *returnValue) {
(void) context;
(void) returnValue;
return EXTCALL_NO_RETURN;
}
int ExternalTextFormat(ExecutionContext *context, Value *returnValue, const char *mode) {
if (coloredOutput) {
char *buffer = malloc(32);
uintptr_t index = HeapAllocate(context);
context->heap[index].type = T_STR;
context->heap[index].bytes = sprintf(buffer, "\033[0;%sm", mode);
context->heap[index].text = buffer;
returnValue->i = index;
} else {
returnValue->i = 0;
}
return EXTCALL_RETURN_MANAGED;
}
int ExternalTextColorError (ExecutionContext *context, Value *returnValue) { return ExternalTextFormat(context, returnValue, "31"); }
int ExternalTextColorHighlight(ExecutionContext *context, Value *returnValue) { return ExternalTextFormat(context, returnValue, "36"); }
int ExternalTextMonospaced (ExecutionContext *context, Value *returnValue) { return ExternalTextFormat(context, returnValue, ""); }
int ExternalTextPlain (ExecutionContext *context, Value *returnValue) { return ExternalTextFormat(context, returnValue, ""); }
int ExternalTextWeight(ExecutionContext *context, Value *returnValue) {
if (context->c->stackPointer < 1) return -1;
return ExternalTextFormat(context, returnValue, context->c->stack[--context->c->stackPointer].i > 500 ? "1" : "");
}
int ExternalPathCreateDirectory(ExecutionContext *context, Value *returnValue) {
STACK_POP_STRING(entryText, entryBytes);
char *temporary = StringZeroTerminate(entryText, entryBytes);
if (!temporary) RETURN_ERROR(ENOMEM);
#ifdef _WIN32
#pragma message ("ExternalPathCreateDirectory unimplemented")
#else
returnValue->i = 1;
if (mkdir(temporary, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH)) returnValue->i = errno == EEXIST;
#endif
free(temporary);
if (!returnValue->i) RETURN_ERROR(errno);
return EXTCALL_RETURN_ERR_UNMANAGED;
}
int ExternalPathDelete(ExecutionContext *context, Value *returnValue) {
(void) returnValue;
STACK_POP_STRING(entryText, entryBytes);
returnValue->i = 0;
char *temporary = StringZeroTerminate(entryText, entryBytes);
if (!temporary) RETURN_ERROR(ENOMEM);
struct stat s = { 0 };
bool isDirectory = lstat(temporary, &s) == 0 && S_ISDIR(s.st_mode);
returnValue->i = isDirectory ? (rmdir(temporary) == 0) : (unlink(temporary) == 0);
free(temporary);
if (!returnValue->i) RETURN_ERROR(errno);
return EXTCALL_RETURN_ERR_UNMANAGED;
}
int ExternalPathExists(ExecutionContext *context, Value *returnValue) {
STACK_POP_STRING(entryText, entryBytes);
returnValue->i = 0;
if (entryBytes == 0) return EXTCALL_RETURN_UNMANAGED;
char *temporary = StringZeroTerminate(entryText, entryBytes);
if (!temporary) return EXTCALL_RETURN_UNMANAGED;
struct stat s = { 0 };
returnValue->i = stat(temporary, &s) == 0;
free(temporary);
return EXTCALL_RETURN_UNMANAGED;
}
int ExternalPathIsFile(ExecutionContext *context, Value *returnValue) {
STACK_POP_STRING(entryText, entryBytes);
returnValue->i = 0;
if (entryBytes == 0) return EXTCALL_RETURN_UNMANAGED;
char *temporary = StringZeroTerminate(entryText, entryBytes);
if (!temporary) return EXTCALL_RETURN_UNMANAGED;
struct stat s = { 0 };
returnValue->i = lstat(temporary, &s) == 0 && S_ISREG(s.st_mode);
free(temporary);
return EXTCALL_RETURN_UNMANAGED;
}
int ExternalPathIsDirectory(ExecutionContext *context, Value *returnValue) {
STACK_POP_STRING(entryText, entryBytes);
returnValue->i = 0;
if (entryBytes == 0) return EXTCALL_RETURN_UNMANAGED;
char *temporary = StringZeroTerminate(entryText, entryBytes);
if (!temporary) return EXTCALL_RETURN_UNMANAGED;
struct stat s = { 0 };
returnValue->i = lstat(temporary, &s) == 0 && S_ISDIR(s.st_mode);
free(temporary);
return EXTCALL_RETURN_UNMANAGED;
}
int ExternalPathIsLink(ExecutionContext *context, Value *returnValue) {
STACK_POP_STRING(entryText, entryBytes);
returnValue->i = 0;
if (entryBytes == 0) return EXTCALL_RETURN_UNMANAGED;
char *temporary = StringZeroTerminate(entryText, entryBytes);
if (!temporary) return EXTCALL_RETURN_UNMANAGED;
struct stat s = { 0 };
returnValue->i = lstat(temporary, &s) == 0 && S_ISLNK(s.st_mode);
free(temporary);
return EXTCALL_RETURN_UNMANAGED;
}
int ExternalPathMove(ExecutionContext *context, Value *returnValue) {
STACK_POP_STRING_2(entryText, entryBytes, entry2Text, entry2Bytes);
returnValue->i = 0;
char *temporary = StringZeroTerminate(entryText, entryBytes);
char *temporary2 = StringZeroTerminate(entry2Text, entry2Bytes);
bool success = temporary && temporary2 && rename(temporary, temporary2) == 0;
free(temporary);
free(temporary2);
if (!temporary || !temporary2) RETURN_ERROR(ENOMEM);
if (!success) RETURN_ERROR(errno);
return EXTCALL_RETURN_ERR_UNMANAGED;
}
int ExternalFileCopy(ExecutionContext *context, Value *returnValue) {
STACK_POP_STRING_2(entryText, entryBytes, entry2Text, entry2Bytes);
returnValue->i = 0;
char *temporary = StringZeroTerminate(entryText, entryBytes);
char *temporary2 = StringZeroTerminate(entry2Text, entry2Bytes);
if (!temporary || !temporary2) {
free(temporary);
free(temporary2);
RETURN_ERROR(ENOMEM);
}
if (0 == strcmp(temporary, temporary2)) {
free(temporary);
free(temporary2);
PrintError4(context, 0, "FileCopy called with the source and destination paths identical. Attempting to copy a file to itself is undefined behaviour!\n");
return 0;
}
FILE *f = fopen(temporary, "rb");
off_t inputFileSize = 0;
if (f) {
fseek(f, 0, SEEK_END);
inputFileSize = ftell(f);
fseek(f, 0, SEEK_SET);
}
FILE *f2 = fopen(temporary2, "wb");
free(temporary);
free(temporary2);
bool okay = true;
bool modifiedDuringCopy = false;
if (f && f2) {
char buffer[4096];
off_t totalBytesRead = 0;
while (okay) {
intptr_t bytesRead = fread(buffer, 1, sizeof(buffer), f);
totalBytesRead += bytesRead;
if (totalBytesRead > inputFileSize) { modifiedDuringCopy = true; break; }
if (bytesRead < 0) okay = false;
if (bytesRead <= 0) break;
intptr_t bytesWritten = fwrite(buffer, 1, bytesRead, f2);
if (bytesWritten != bytesRead) okay = false;
}
if (totalBytesRead != inputFileSize) {
modifiedDuringCopy = true;
}
} else {
okay = false;
}
if (f && fclose(f)) okay = false;
if (f2 && fclose(f2)) okay = false;
if (modifiedDuringCopy) {
RETURN_ERROR(-1);
} else if (okay) {
returnValue->i = 0;
return EXTCALL_RETURN_ERR_UNMANAGED;
} else {
RETURN_ERROR(errno);
}
}
int ExternalSystemGetEnvironmentVariable(ExecutionContext *context, Value *returnValue) {
STACK_POP_STRING(entryText, entryBytes);
returnValue->i = 0;
char *temporary = StringZeroTerminate(entryText, entryBytes);
if (!temporary) RETURN_ERROR(ENOMEM);
char *data = getenv(temporary);
free(temporary);
if (!data) RETURN_ERROR(-1);
RETURN_STRING_COPY(data, data ? strlen(data) : 0);
return EXTCALL_RETURN_ERR_MANAGED;
}
int ExternalSystemSetEnvironmentVariable(ExecutionContext *context, Value *returnValue) {
STACK_POP_STRING_2(entryText, entryBytes, entry2Text, entry2Bytes);
char *temporary = StringZeroTerminate(entryText, entryBytes);
char *temporary2 = StringZeroTerminate(entry2Text, entry2Bytes);
bool success = temporary && temporary2 && setenv(temporary, temporary2, true) == 0;
free(temporary);
free(temporary2);
if (!success) {
if (!temporary || !temporary2) RETURN_ERROR(ENOMEM);
RETURN_ERROR(errno);
}
return EXTCALL_RETURN_ERR_UNMANAGED;
}
int External_DirectoryInternalStartIteration(ExecutionContext *context, Value *returnValue) {
STACK_POP_STRING(entryText, entryBytes);
returnValue->i = 0;
char *temporary = StringZeroTerminate(entryText, entryBytes);
if (!temporary) RETURN_ERROR(ENOMEM);
if (directoryIterator) RETURN_ERROR(-1);
directoryIterator = opendir(temporary);
free(temporary);
if (!directoryIterator) RETURN_ERROR(errno);
return EXTCALL_RETURN_ERR_UNMANAGED;
}
int External_DirectoryInternalEndIteration(ExecutionContext *context, Value *returnValue) {
(void) context;
(void) returnValue;
if (!directoryIterator) return 0;
closedir(directoryIterator);
directoryIterator = NULL;
return EXTCALL_NO_RETURN;
}
int External_DirectoryInternalNextIteration(ExecutionContext *context, Value *returnValue) {
(void) context;
if (!directoryIterator) return 0;
struct dirent *entry = readdir(directoryIterator);
while (entry && (0 == strcmp(entry->d_name, ".") || 0 == strcmp(entry->d_name, ".."))) entry = readdir(directoryIterator);
if (!entry) { returnValue->i = 0; return EXTCALL_RETURN_MANAGED; }
RETURN_STRING_COPY(entry->d_name, strlen(entry->d_name));
return EXTCALL_RETURN_MANAGED;
}
int ExternalFileReadAll(ExecutionContext *context, Value *returnValue) {
STACK_POP_STRING(entryText, entryBytes);
returnValue->i = 0;
char *temporary = StringZeroTerminate(entryText, entryBytes);
if (!temporary) RETURN_ERROR(ENOMEM);
size_t length = 0;
void *data = FileLoad(temporary, &length);
free(temporary);
if (!data) RETURN_ERROR(errno);
RETURN_STRING_NO_COPY(data, length);
return EXTCALL_RETURN_ERR_MANAGED;
}
int ExternalFileGetSize(ExecutionContext *context, Value *returnValue) {
STACK_POP_STRING(entryText, entryBytes);
returnValue->i = 0;
char *temporary = StringZeroTerminate(entryText, entryBytes);
if (!temporary) RETURN_ERROR(ENOMEM);
FILE *file = fopen(temporary, "rb");
free(temporary);
if (file) {
fseek(file, 0, SEEK_END);
returnValue->i = ftell(file);
fclose(file);
return EXTCALL_RETURN_ERR_UNMANAGED;
} else {
RETURN_ERROR(errno);
}
}
int ExternalFileWriteAll(ExecutionContext *context, Value *returnValue) {
STACK_POP_STRING_2(entryText, entryBytes, entry2Text, entry2Bytes);
returnValue->i = 0;
char *temporary = StringZeroTerminate(entryText, entryBytes);
if (!temporary) RETURN_ERROR(ENOMEM);
FILE *f = fopen(temporary, "wb");
free(temporary);
if (f) {
returnValue->i = entry2Bytes == fwrite(entry2Text, 1, entry2Bytes, f);
if (fclose(f)) RETURN_ERROR(errno);
if (!returnValue->i) RETURN_ERROR(errno);
return EXTCALL_RETURN_ERR_UNMANAGED;
} else {
RETURN_ERROR(errno);
}
}
int ExternalFileAppend(ExecutionContext *context, Value *returnValue) {
STACK_POP_STRING_2(entryText, entryBytes, entry2Text, entry2Bytes);
returnValue->i = 0;
char *temporary = StringZeroTerminate(entryText, entryBytes);
if (!temporary) RETURN_ERROR(ENOMEM);
FILE *f = fopen(temporary, "ab");
free(temporary);
if (f) {
returnValue->i = entry2Bytes == fwrite(entry2Text, 1, entry2Bytes, f);
if (fclose(f)) RETURN_ERROR(errno);
if (!returnValue->i) RETURN_ERROR(errno);
return EXTCALL_RETURN_ERR_UNMANAGED;
} else {
RETURN_ERROR(errno);
}
}
int ExternalPathGetDefaultPrefix(ExecutionContext *context, Value *returnValue) {
(void) returnValue;
char *data = (char *) malloc(10000);
if (!data || data != getcwd(data, 10000)) {
PrintError4(context, 0, "Could not get the working directory.\n");
free(data);
return 0;
}
RETURN_STRING_NO_COPY(realloc(data, strlen(data) + 1), strlen(data));
return EXTCALL_RETURN_MANAGED;
}
int ExternalPathSetDefaultPrefixToScriptSourceDirectory(ExecutionContext *context, Value *returnValue) {
(void) context;
returnValue->i = chdir(scriptSourceDirectory) == 0;
if (!returnValue->i) RETURN_ERROR(errno);
return EXTCALL_RETURN_ERR_UNMANAGED;
}
int ExternalPersistRead(ExecutionContext *context, Value *returnValue) {
(void) returnValue;
STACK_POP_STRING(entryText, entryBytes);
returnValue->i = 0;
if (entryBytes == 0) return EXTCALL_RETURN_UNMANAGED;
char *temporary = StringZeroTerminate(entryText, entryBytes);
if (!temporary) return EXTCALL_RETURN_UNMANAGED;
free(context->scriptPersistFile);
context->scriptPersistFile = temporary;
size_t length = 0;
uint8_t *data = (uint8_t *) FileLoad(temporary, &length);
returnValue->i = 1;
for (uintptr_t i = 0; i < length; ) {
uint32_t variableNameLength, variableDataLength;
char variableName[256];
if (length < sizeof(uint32_t) * 2) break;
if (i > length - sizeof(uint32_t) * 2) break;
memcpy(&variableNameLength, &data[i], sizeof(uint32_t)); i += sizeof(uint32_t);
memcpy(&variableDataLength, &data[i], sizeof(uint32_t)); i += sizeof(uint32_t);
if (variableNameLength > 256) break;
if (length < variableNameLength + variableDataLength) break;
if (i > length - variableNameLength - variableDataLength) break;
memcpy(variableName, &data[i], variableNameLength); i += variableNameLength;
uintptr_t k = context->mainModule->globalVariableOffset;
Scope *scope = context->mainModule->rootNode->scope;
for (uintptr_t j = 0; j < scope->entryCount; j++) {
if (scope->entries[j]->token.textBytes == variableNameLength
&& 0 == MemoryCompare(scope->entries[j]->token.text, variableName, variableNameLength)
&& scope->entries[j]->type == T_DECLARE
&& scope->entries[j]->isPersistentVariable) {
if (scope->entries[j]->expressionType->type == T_STR) {
// TODO Handling allocation failures.
context->globalVariables[k].i = HeapAllocate(context);
context->heap[context->globalVariables[k].i].type = T_STR;
context->heap[context->globalVariables[k].i].bytes = variableDataLength;
context->heap[context->globalVariables[k].i].text = AllocateResize(NULL, variableDataLength);
memcpy(context->heap[context->globalVariables[k].i].text, &data[i], variableDataLength);
} else if (scope->entries[j]->expressionType->type == T_INT) {
if (variableDataLength == sizeof(int64_t)) memcpy(&context->globalVariables[k].i, &data[i], sizeof(int64_t));
} else if (scope->entries[j]->expressionType->type == T_FLOAT) {
if (variableDataLength == sizeof(double)) memcpy(&context->globalVariables[k].f, &data[i], sizeof(double));
} else if (scope->entries[j]->expressionType->type == T_BOOL) {
if (variableDataLength == 1) context->globalVariables[k].i = data[i] == 1;
} else {
// TODO What should happen here?
}
break;
}
if (ScopeIsVariableType(scope->entries[j])) {
k++;
}
}
i += variableDataLength;
}
free(data);
return EXTCALL_RETURN_UNMANAGED;
}
int ExternalPersistWrite(ExecutionContext *context, Value *returnValue) {
(void) returnValue;
if (!context->scriptPersistFile) {
// TODO Report the file/line number.
PrintError3("Attempted to modify a persistent variable before calling PersistRead.\n");
return 0;
}
FILE *f = fopen(context->scriptPersistFile, "wb");
if (!f) {
PrintDebug("\033[0;32mWarning: Persistent variables could not written. The file could not be opened.\033[0m\n");
return EXTCALL_NO_RETURN;
}
uintptr_t k = context->mainModule->globalVariableOffset;
Scope *scope = context->mainModule->rootNode->scope;
for (uintptr_t j = 0; j < scope->entryCount; j++) {
if (scope->entries[j]->type == T_DECLARE && scope->entries[j]->isPersistentVariable) {
uint32_t variableNameLength = scope->entries[j]->token.textBytes;
fwrite(&variableNameLength, 1, sizeof(uint32_t), f);
if (scope->entries[j]->expressionType->type == T_STR) {
HeapEntry *entry = &context->heap[context->globalVariables[k].i];
const char *text;
size_t bytes;
ScriptHeapEntryToString(context, entry, &text, &bytes);
uint32_t variableDataLength = bytes;
fwrite(&variableDataLength, 1, sizeof(uint32_t), f);
fwrite(scope->entries[j]->token.text, 1, variableNameLength, f);
if (bytes) fwrite(text, 1, variableDataLength, f);
} else if (scope->entries[j]->expressionType->type == T_INT) {
uint32_t variableDataLength = sizeof(int64_t);
fwrite(&variableDataLength, 1, sizeof(uint32_t), f);
fwrite(scope->entries[j]->token.text, 1, variableNameLength, f);
fwrite(&context->globalVariables[k].i, 1, sizeof(int64_t), f);
} else if (scope->entries[j]->expressionType->type == T_FLOAT) {
uint32_t variableDataLength = sizeof(double);
fwrite(&variableDataLength, 1, sizeof(uint32_t), f);
fwrite(scope->entries[j]->token.text, 1, variableNameLength, f);
fwrite(&context->globalVariables[k].f, 1, sizeof(double), f);
} else if (scope->entries[j]->expressionType->type == T_BOOL) {
uint32_t variableDataLength = 1;
fwrite(&variableDataLength, 1, sizeof(uint32_t), f);
fwrite(scope->entries[j]->token.text, 1, variableNameLength, f);
uint8_t b = context->globalVariables[k].i == 1;
fwrite(&b, 1, sizeof(uint8_t), f);
} else {
PrintDebug("\033[0;32mWarning: The persistent variable %.*s could not be written, because it had an unsupported type.\033[0m\n",
scope->entries[j]->token.textBytes, scope->entries[j]->token.text);
}
}
if (ScopeIsVariableType(scope->entries[j])) {
k++;
}
}
if (fclose(f)) {
PrintDebug("\033[0;32mWarning: Persistent variables could not written. The file could not be closed.\033[0m\n");
return EXTCALL_NO_RETURN;
}
return EXTCALL_NO_RETURN;
}
int ExternalConsoleGetLine(ExecutionContext *context, Value *returnValue) {
#ifdef _WIN32
#pragma message ("ExternalConsoleGetLine unimplemented")
return -1;
#else
char *line = NULL;
size_t pos;
size_t unused = getline(&line, &pos, stdin);
(void) unused;
uintptr_t index = HeapAllocate(context);
context->heap[index].type = T_STR;
context->heap[index].bytes = strlen(line) - 1;
context->heap[index].text = line;
returnValue->i = index;
return EXTCALL_RETURN_MANAGED;
#endif
}
int ExternalSystemGetProcessorCount(ExecutionContext *context, Value *returnValue) {
(void) context;
#ifdef _WIN32
#pragma message ("ExternalSystemGetProcessorCount unimplemented")
returnValue->i = 1;
#else
returnValue->i = sysconf(_SC_NPROCESSORS_CONF);
#endif
if (returnValue->i < 1) returnValue->i = 1;
if (returnValue->i > 10000) returnValue->i = 1; // Values this large are obviously wrong.
return EXTCALL_RETURN_UNMANAGED;
}
int ExternalSystemRunningAsAdministrator(ExecutionContext *context, Value *returnValue) {
(void) context;
#ifdef _WIN32
#pragma message ("ExternalSystemRunningAsAdministrator unimplemented")
returnValue->i = 0;
#else
returnValue->i = geteuid() == 0;
#endif
return EXTCALL_RETURN_UNMANAGED;
}
int ExternalSystemGetHostName(ExecutionContext *context, Value *returnValue) {
(void) context;
const char *name;
#ifdef _WIN32
name = "Windows";
#else
struct utsname buffer;
uname(&buffer);
name = buffer.sysname;
#endif
RETURN_STRING_COPY(name, strlen(name));
return EXTCALL_RETURN_MANAGED;
}
int ExternalRandomInt(ExecutionContext *context, Value *returnValue) {
if (context->c->stackPointer < 2) return -1;
int64_t min = context->c->stack[context->c->stackPointer - 1].i;
int64_t max = context->c->stack[context->c->stackPointer - 2].i;
if (max < min) { PrintError4(context, 0, "RandomInt() called with maximum limit (%ld) less than the minimum limit (%ld).\n", max, min); return 0; }
returnValue->i = rand() % (max - min + 1) + min;
context->c->stackPointer -= 2;
return EXTCALL_RETURN_UNMANAGED;
}
void *SystemSleepThread(void *_coroutine) {
CoroutineState *coroutine = (CoroutineState *) _coroutine;
struct timespec sleepTime;
uint64_t x = 1000000 * coroutine->externalCoroutineData.i;
sleepTime.tv_sec = x / 1000000000;
sleepTime.tv_nsec = x % 1000000000;
nanosleep(&sleepTime, NULL);
ExternalCoroutineDone(coroutine);
return NULL;
}
int ExternalSystemSleepMs(ExecutionContext *context, Value *returnValue) {
(void) returnValue;
if (context->c->externalCoroutine) return EXTCALL_NO_RETURN;
if (context->c->stackPointer < 1) return -1;
context->c->externalCoroutineData = context->c->stack[--context->c->stackPointer];
#ifdef __linux__
pthread_t thread;
pthread_create(&thread, NULL, SystemSleepThread, context->c);
pthread_detach(thread);
return EXTCALL_START_COROUTINE;
#else
struct timespec sleepTime;
uint64_t x = 1000000 * context->c->externalCoroutineData.i;
sleepTime.tv_sec = x / 1000000000;
sleepTime.tv_nsec = x % 1000000000;
nanosleep(&sleepTime, NULL);
return EXTCALL_NO_RETURN;
#endif
}
int ExternalOpenDocumentEnumerate(ExecutionContext *context, Value *returnValue) {
(void) context;
returnValue->i = 0;
return EXTCALL_RETURN_MANAGED;
}
CoroutineState *ExternalCoroutineWaitAny(ExecutionContext *context) {
(void) context;
while (sem_wait(&externalCoroutineSemaphore) == -1);
pthread_mutex_lock(&externalCoroutineMutex);
CoroutineState *unblocked = externalCoroutineUnblockedList;
Assert(unblocked);
externalCoroutineUnblockedList = unblocked->nextExternalCoroutine;
unblocked->nextExternalCoroutine = NULL;
pthread_mutex_unlock(&externalCoroutineMutex);
return unblocked;
}
void PrintREPLResult(ExecutionContext *context, Node *type, Value value) {
if (type->type == T_INT) {
printf("%ld", value.i);
} else if (type->type == T_BOOL) {
printf("%s", value.i ? "true" : "false");
} else if (type->type == T_NULL) {
printf("null");
} else if (type->type == T_FLOAT) {
printf("%f", value.f);
} else if (type->type == T_STR) {
Assert(context->heapEntriesAllocated > (uint64_t) value.i);
HeapEntry *entry = &context->heap[value.i];
const char *valueText;
size_t valueBytes;
ScriptHeapEntryToString(context, entry, &valueText, &valueBytes);
printf("%.*s", (int) valueBytes, valueText);
} else if (type->type == T_ERR) {
if (value.i) {
Assert(context->heapEntriesAllocated > (uint64_t) value.i);
HeapEntry *entry = &context->heap[value.i];
if (entry->success) {
if (type->firstChild->type == T_VOID) {
printf("Success.");
} else {
PrintREPLResult(context, type->firstChild, entry->errorValue);
}
} else {
Assert(context->heapEntriesAllocated > (uint64_t) entry->errorValue.i);
const char *valueText;
size_t valueBytes;
ScriptHeapEntryToString(context, &context->heap[entry->errorValue.i], &valueText, &valueBytes);
printf("Error: %.*s.", (int) valueBytes, valueText);
}
} else {
printf("Error: UNKNOWN.");
}
} else if (type->type == T_LIST) {
Assert(context->heapEntriesAllocated > (uint64_t) value.i);
HeapEntry *entry = &context->heap[value.i];
Assert(entry->type == T_LIST);
if (!entry->length) {
printf("Empty list.\n");
} else {
printf("[ ");
for (uintptr_t i = 0; i < entry->length; i++) {
if (i) printf(", ");
PrintREPLResult(context, type->firstChild, entry->list[i]);
}
printf(" ]");
}
} else if (type->type == T_STRUCT) {
Assert(context->heapEntriesAllocated > (uint64_t) value.i);
HeapEntry *entry = &context->heap[value.i];
Assert(entry->type == T_STRUCT);
uintptr_t i = 0;
printf("{ ");
Node *field = type->firstChild;
while (field) {
if (i) printf(", ");
Assert(i != entry->fieldCount);
PrintREPLResult(context, field->firstChild, entry->fields[i]);
field = field->sibling;
i++;
}
printf(" }");
} else if (type->type == T_FUNCPTR) {
printf("Function pointer.");
} else {
printf("The type of the result was not recognized.");
}
}
void ExternalPassREPLResult(ExecutionContext *context, Value value) {
PrintREPLResult(context, context->functionData->replResultType, value);
printf("\n");
}
void *AllocateFixed(size_t bytes) {
if (!bytes) {
return NULL;
}
bytes = (bytes + sizeof(uintptr_t) - 1) & ~(sizeof(uintptr_t) - 1);
if (bytes >= fixedAllocationCurrentSize || fixedAllocationCurrentPosition >= fixedAllocationCurrentSize - bytes) {
#if 1
fixedAllocationCurrentSize = bytes > 1048576 ? bytes : 1048576;
#else
fixedAllocationCurrentSize = bytes;
#endif
fixedAllocationCurrentPosition = 0;
fixedAllocationCurrentBlock = calloc(1, fixedAllocationCurrentSize + sizeof(void *));
if (!fixedAllocationCurrentBlock) {
fprintf(stderr, "Internal error: not enough memory to run the script.\n");
exit(1);
}
*(void **) fixedAllocationCurrentBlock = fixedAllocationBlocks;
fixedAllocationBlocks = (void **) fixedAllocationCurrentBlock;
fixedAllocationCurrentBlock += sizeof(void *);
}
void *p = fixedAllocationCurrentBlock + fixedAllocationCurrentPosition;
fixedAllocationCurrentPosition += bytes;
return p;
}
void *AllocateResize(void *old, size_t bytes) {
if (bytes == 0) {
free(old);
return NULL;
}
void *p = realloc(old, bytes);
if (!p && bytes) {
fprintf(stderr, "Internal error: not enough memory to run the script.\n");
exit(1);
// TODO Better error handling.
}
return p;
}
int MemoryCompare(const void *a, const void *b, size_t bytes) {
return memcmp(a, b, bytes);
}
void MemoryCopy(void *a, const void *b, size_t bytes) {
memcpy(a, b, bytes);
}
size_t PrintIntegerToBuffer(char *buffer, size_t bufferBytes, int64_t i) {
snprintf(buffer, bufferBytes, "%ld", i);
return strlen(buffer);
}
size_t PrintFloatToBuffer(char *buffer, size_t bufferBytes, double f) {
snprintf(buffer, bufferBytes, "%f", f);
return strlen(buffer);
}
void PrintDebug(const char *format, ...) {
va_list arguments;
va_start(arguments, format);
vfprintf(stderr, format, arguments);
va_end(arguments);
}
void PrintError(Tokenizer *tokenizer, const char *format, ...) {
fprintf(stderr, "\033[0;33mError on line %d of '%s':\033[0m\n", (int) tokenizer->line, tokenizer->module->path);
va_list arguments;
va_start(arguments, format);
vfprintf(stderr, format, arguments);
va_end(arguments);
PrintLine(tokenizer->module, tokenizer->line);
}
void PrintError2(Tokenizer *tokenizer, Node *node, const char *format, ...) {
fprintf(stderr, "\033[0;33mError on line %d of '%s':\033[0m\n", (int) node->token.line, tokenizer->module->path);
va_list arguments;
va_start(arguments, format);
vfprintf(stderr, format, arguments);
va_end(arguments);
PrintLine(tokenizer->module, node->token.line);
}
void PrintError3(const char *format, ...) {
fprintf(stderr, "\033[0;33mGeneral error:\033[0m\n");
va_list arguments;
va_start(arguments, format);
vfprintf(stderr, format, arguments);
va_end(arguments);
}
void PrintError4(ExecutionContext *context, uint32_t instructionPointer, const char *format, ...) {
LineNumber lineNumber = { 0 };
LineNumberLookup(context, instructionPointer, &lineNumber);
fprintf(stderr, "\033[0;33mRuntime error on line %d of '%s'\033[0m:\n", lineNumber.lineNumber,
lineNumber.importData ? lineNumber.importData->path : "??");
va_list arguments;
va_start(arguments, format);
vfprintf(stderr, format, arguments);
va_end(arguments);
PrintLine(lineNumber.importData, lineNumber.lineNumber);
fprintf(stderr, "Back trace:\n");
PrintBackTrace(context, instructionPointer, context->c, "");
}
void *LibraryLoad(const char *name) {
Assert(strlen(name) < 256);
char name2[256 + 20];
strcpy(name2, "l");
strcat(name2, name);
strcat(name2, ".so");
void *library = dlopen(name2, RTLD_LAZY);
if (!library) {
PrintError3("The library \"%s\" could not be found or loaded.\n", name2);
}
return library;
}
void *LibraryGetAddress(void *library, const char *name) {
Assert(strlen(name) < 256);
Assert(library);
char name2[256 + 20];
strcpy(name2, "ScriptExt");
strcat(name2, name);
void *address = dlsym(library, name2);
if (!address) {
PrintError3("The library symbol \"%s\" could not be found.\n", name2);
}
return address;
}
void *FileLoad(const char *path, size_t *length) {
FILE *file = fopen(path, "rb");
if (!file) return NULL;
struct stat s;
fstat(fileno(file), &s);
if (!S_ISREG(s.st_mode)) { fclose(file); errno = EISDIR; return NULL; }
fseek(file, 0, SEEK_END);
size_t fileSize = ftell(file);
fseek(file, 0, SEEK_SET);
char *buffer = (char *) malloc(fileSize + 1);
buffer[fileSize] = 0;
size_t readBytes = fread(buffer, 1, fileSize, file);
fclose(file);
if (readBytes != fileSize) { free(buffer); return NULL; }
if (length) *length = fileSize;
return buffer;
}
int main(int argc, char **argv) {
if (argc < 2) {
fprintf(stderr, "Usage: %s <engine options...> <path to script> <script options...>\n", argv[0]);
return 1;
}
coloredOutput = isatty(STDERR_FILENO);
srand(time(NULL));
sem_init(&externalCoroutineSemaphore, 0, 0);
char *scriptPath = NULL;
char *evaluateString = NULL;
bool evaluateMode = false;
for (int i = 1; i < argc; i++) {
if (argv[i][0] != '-') {
if (evaluateMode) {
evaluateString = argv[i];
} else {
scriptPath = argv[i];
}
options = argv + i + 1;
optionCount = argc - i - 1;
optionsMatched = (bool *) calloc(argc, sizeof(bool));
break;
} else if (0 == memcmp(argv[i], "--start=", 8)) {
startFunction = argv[i] + 8;
startFunctionBytes = strlen(argv[i]) - 8;
} else if (0 == memcmp(argv[i], "--debug-bytecode=", 17)) {
debugBytecodeLevel = atoi(argv[i] + 17);
} else if (0 == strcmp(argv[i], "--evaluate") || 0 == strcmp(argv[i], "-e")) {
evaluateMode = true;
} else {
fprintf(stderr, "Unrecognised engine option: '%s'.\n", argv[i]);
return 1;
}
}
if (!scriptPath && !evaluateString) {
fprintf(stderr, "Error: %s\n", evaluateMode ? "String to evaluate not specified." : "Path to script not specified.");
return 1;
}
if (scriptPath) {
scriptSourceDirectory = (char *) malloc(strlen(scriptPath) + 2);
strcpy(scriptSourceDirectory, scriptPath);
char *lastSlash = strrchr(scriptSourceDirectory, '/');
if (lastSlash) *lastSlash = 0;
else strcpy(scriptSourceDirectory, ".");
} else {
scriptSourceDirectory = (char *) malloc(2);
scriptSourceDirectory[0] = '.';
scriptSourceDirectory[1] = 0;
}
size_t dataBytes = evaluateMode ? strlen(evaluateString) : 0;
void *data = evaluateMode ? malloc(strlen(evaluateString)) : FileLoad(scriptPath, &dataBytes);
if (evaluateMode) memcpy(data, evaluateString, dataBytes);
if (!data) {
PrintDebug("Error: Could not load the input file '%s'.\n", scriptPath);
return 1;
}
if (evaluateMode) scriptPath = "[input]";
int result = ScriptExecuteFromFile(scriptPath, strlen(scriptPath), data, dataBytes, evaluateMode);
while (fixedAllocationBlocks) {
void *block = fixedAllocationBlocks;
fixedAllocationBlocks = (void **) *fixedAllocationBlocks;
free(block);
}
free(scriptSourceDirectory);
free(optionsMatched);
return result;
}
#endif
View Git Blame Copy Permalink