From f3dc1fd4bb5e09276c8ac6542d3dbf199cb31f13 Mon Sep 17 00:00:00 2001
From: nakst <>
Date: Fri, 4 Mar 2022 10:19:47 +0000
Subject: [PATCH] scripting engine: bitwise operators
---
util/script.c | 182 ++++++++++++++++++++++++++++++++++++--------------
1 file changed, 133 insertions(+), 49 deletions(-)
diff --git a/util/script.c b/util/script.c
index bb30621..e2d2585 100644
--- a/util/script.c
+++ b/util/script.c
@@ -2,7 +2,7 @@
// - Other list operations: insert_many, delete_many.
// - Maps: T[int], T[str].
// - Control flow: break, continue.
-// - Other operators: remainder, bitwise shifts, bitwise AND/OR/XOR/NOT, ternary.
+// - Other operators: remainder, ternary.
// - Named optional arguments with default values.
// - Accessing structs and functypes from imported modules.
// - inttype and struct inheritance.
@@ -52,35 +52,41 @@
#define T_STRING_LITERAL (3)
#define T_NUMERIC_LITERAL (4)
-#define T_ADD (40)
-#define T_MINUS (41)
-#define T_ASTERISK (42)
-#define T_SLASH (43)
-#define T_NEGATE (44)
-#define T_LEFT_ROUND (45)
-#define T_RIGHT_ROUND (46)
-#define T_LEFT_SQUARE (47)
-#define T_RIGHT_SQUARE (48)
-#define T_LEFT_FANCY (49)
-#define T_RIGHT_FANCY (50)
-#define T_COMMA (51)
-#define T_EQUALS (52)
-#define T_SEMICOLON (53)
-#define T_GREATER_THAN (54)
-#define T_LESS_THAN (55)
-#define T_GT_OR_EQUAL (56)
-#define T_LT_OR_EQUAL (57)
-#define T_DOUBLE_EQUALS (58)
-#define T_NOT_EQUALS (59)
-#define T_LOGICAL_AND (60)
-#define T_LOGICAL_OR (61)
-#define T_ADD_EQUALS (62)
-#define T_MINUS_EQUALS (63)
-#define T_ASTERISK_EQUALS (64)
-#define T_SLASH_EQUALS (65)
-#define T_DOT (66)
-#define T_COLON (67)
-#define T_LOGICAL_NOT (68)
+#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)
@@ -419,6 +425,7 @@ size_t startFunctionBytes = 5;
char **options;
bool *optionsMatched;
size_t optionCount;
+int debugBytecodeLevel;
ImportData *importedModules;
ImportData **importedModulesLink = &importedModules;
@@ -842,17 +849,23 @@ uint8_t TokenLookupPrecedence(uint8_t t) {
if (t == T_COMMA) return 12;
if (t == T_LOGICAL_OR) return 14;
if (t == T_LOGICAL_AND) return 15;
- if (t == T_GREATER_THAN) return 20;
- if (t == T_LESS_THAN) return 20;
- if (t == T_GT_OR_EQUAL) return 20;
- if (t == T_LT_OR_EQUAL) return 20;
+ 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;
@@ -907,6 +920,9 @@ Token TokenNext(Tokenizer *tokenizer) {
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;
@@ -926,6 +942,9 @@ Token TokenNext(Tokenizer *tokenizer) {
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;
@@ -1315,8 +1334,8 @@ Node *ParseExpression(Tokenizer *tokenizer, bool allowAssignment, uint8_t preced
} else if (node->token.type == T_NUMERIC_LITERAL || node->token.type == T_SUCCESS
|| 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->type = node->token.type == T_MINUS ? T_NEGATE : T_LOGICAL_NOT;
+ } 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);
@@ -1412,12 +1431,14 @@ Node *ParseExpression(Tokenizer *tokenizer, bool allowAssignment, uint8_t preced
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_ASTERISK || token.type == T_SLASH
- || token.type == T_GREATER_THAN || token.type == T_LESS_THAN
- || 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)
+ } 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);
@@ -2690,6 +2711,12 @@ int64_t ASTEvaluateIntConstant(Tokenizer *tokenizer, Node *node, bool *error) {
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);
@@ -2702,8 +2729,24 @@ int64_t ASTEvaluateIntConstant(Tokenizer *tokenizer, Node *node, bool *error) {
} 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;
@@ -2716,7 +2759,13 @@ bool ASTIsIntegerConstant(Node *node) {
&& node->type != T_MINUS
&& node->type != T_ASTERISK
&& node->type != T_SLASH
- && node->type != T_NEGATE) {
+ && 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;
}
@@ -2803,7 +2852,9 @@ bool ASTSetTypes(Tokenizer *tokenizer, Node *node) {
}
} 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_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) {
if (!ASTMatching(node->firstChild->expressionType, node->firstChild->sibling->expressionType)) {
PrintError2(tokenizer, node, "The expression on the left and right side of a binary operator must have the same type.\n");
return false;
@@ -3317,10 +3368,10 @@ bool ASTSetTypes(Tokenizer *tokenizer, Node *node) {
}
node->expressionType = &globalExpressionTypeBool;
- } else if (node->type == T_NEGATE) {
+ } 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 unary negate '-' operator.\n");
+ PrintError2(tokenizer, node, "Expected a int or float for the %s operator.\n", node->type == T_NEGATE ? "unary negate '-'" : "bitwise not '~'");
return false;
}
@@ -4074,7 +4125,9 @@ bool FunctionBuilderRecurse(Tokenizer *tokenizer, Node *node, FunctionBuilder *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) {
+ } 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);
@@ -4518,8 +4571,11 @@ int ScriptExecuteFunction(uintptr_t instructionPointer, ExecutionContext *contex
while (true) {
uint8_t command = functionData[instructionPointer++];
- // PrintDebug("--> %d, %ld, %ld, %ld\n", command, instructionPointer - 1, context->c->id, context->c->stackPointer);
- // PrintBackTrace(context, instructionPointer - 1, context->c, "");
+
+ 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);
@@ -4854,6 +4910,26 @@ int ScriptExecuteFunction(uintptr_t instructionPointer, ExecutionContext *contex
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;
@@ -4879,6 +4955,9 @@ int ScriptExecuteFunction(uintptr_t instructionPointer, ExecutionContext *contex
} 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;
@@ -7123,6 +7202,11 @@ int main(int argc, char **argv) {
} 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 {
+ fprintf(stderr, "Unrecognised engine option: '%s'.\n", argv[i]);
+ return 1;
}
}