diff --git a/examples/func.zn b/examples/func.zn new file mode 100644 index 0000000..6c6ddac --- /dev/null +++ b/examples/func.zn @@ -0,0 +1,19 @@ +foreign u0 printf(*char) +foreign *u8 malloc(u64) + +struct Vec { + f32 x + f32 y +} + +u0 print() *Vec self { + printf("Received\n") +} + +i32 main() { + *Vec v = malloc(sizeof Vec) + + v.print() + + return 0 +} diff --git a/examples/function.zn b/examples/function.zn new file mode 100644 index 0000000..a538459 --- /dev/null +++ b/examples/function.zn @@ -0,0 +1,18 @@ +foreign u0 printf(*char) +struct Vec { + f32 x + f32 y +} + +u0 print() Vec self { + printf("Received\n") +} + +i32 main() { + v := Vec{ x: 10, y: 10 } + + v.print() + + return 0 +} + diff --git a/examples/input.zn b/examples/input.zn index 1bf245d..1f0eca0 100644 --- a/examples/input.zn +++ b/examples/input.zn @@ -1,5 +1,6 @@ foreign i32 read(i32, *u8, u64) foreign u0 printf(*char) +foreign u64 write(i32, *u8, u64) foreign *u8 malloc(u64) foreign *u8 memset(*u8, i32, u64) @@ -10,7 +11,8 @@ i32 main() { for bytesRead > 0 { memset(buf, 0, 1024) bytesRead = read(0, buf, 1024) - printf(buf) + + write(1, buf, bytesRead) } printf("Exited\n") diff --git a/zcolors.h b/zcolors.h new file mode 100644 index 0000000..edc4604 --- /dev/null +++ b/zcolors.h @@ -0,0 +1,12 @@ +#ifndef Z_COLORS_H +#define Z_COLORS_H + +#define COLOR_RESET "\033[0m" +#define COLOR_RED "\033[1;31m" +#define COLOR_GREEN "\033[1;32m" +#define COLOR_YELLOW "\033[1;33m" +#define COLOR_BLUE "\033[1;34m" +#define COLOR_CYAN "\033[1;36m" +#define COLOR_BOLD "\033[1m" + +#endif // Z_COLORS_H diff --git a/zgen.c b/zgen.c index 00634dc..b1a75b6 100644 --- a/zgen.c +++ b/zgen.c @@ -541,10 +541,14 @@ static LLVMValueRef genCall(ZCodegen *ctx, ZNode *node) { static LLVMValueRef genLvalue(ZCodegen *ctx, ZNode *node) { switch (node->type) { case NODE_IDENTIFIER: { - char *key = node->identNode.mangled ? node->identNode.mangled : node->tok->str; + char *key = node->identNode.mangled ? + node->identNode.mangled : + node->tok->str; LLVMValueRef val = getLLVMValueRef(ctx, key); if (!val) { - error(ctx->state, node->tok, "'%s' not found in the current scope", node->tok->str); + error(ctx->state, node->tok, + "'%s' not found in the current scope", + node->tok->str); return NULL; } return val; @@ -566,7 +570,6 @@ static LLVMValueRef genLvalue(ZCodegen *ctx, ZNode *node) { ); } case NODE_MEMBER: { - ZType *objType = node->memberAccess.object->resolved; ZToken *tok = node->memberAccess.field; i32 index = typeIndex(objType, tok->str); @@ -782,8 +785,38 @@ static LLVMValueRef castValue(ZCodegen *ctx, LLVMValueRef val, ZType *from, ZTyp } static LLVMValueRef genCast(ZCodegen *ctx, ZNode *node) { + ZType *from = node->castExpr.expr->resolved; + ZType *to = node->castExpr.toType; + + /* Array-literal cast: [n]T as []U — write each element directly into + * the pre-allocated slot with per-element casting. + * genArrayLit can't be used here because the stack slot is keyed on + * this cast node, not on the inner array-literal node. */ + if (from->kind == Z_TYPE_ARRAY && to->kind == Z_TYPE_ARRAY && + node->castExpr.expr->type == NODE_ARRAY_LIT) { + ZLLVMStack *stack = getStackValue(ctx, node); + if (!stack) { + error(ctx->state, node->tok, "Missing stack value for array cast"); + return NULL; + } + ZNode *lit = node->castExpr.expr; + for (usize i = 0; i < veclen(lit->arraylit); i++) { + LLVMValueRef indices[] = { + LLVMConstInt(i32Type, 0, false), + LLVMConstInt(i32Type, i, false) + }; + LLVMValueRef gep = LLVMBuildGEP2( + ctx->builder, stack->type, + stack->stack, indices, 2, label(ctx)); + LLVMValueRef elem = genExpr(ctx, lit->arraylit[i]); + elem = castValue(ctx, elem, from->array.base, to->array.base); + LLVMBuildStore(ctx->builder, elem, gep); + } + return stack->stack; + } + LLVMValueRef val = genExpr(ctx, node->castExpr.expr); - return castValue(ctx, val, node->castExpr.expr->resolved, node->castExpr.toType); + return castValue(ctx, val, from, to); } /* dest: optional pre-allocated slot to write into (e.g. an array element GEP). @@ -842,7 +875,7 @@ static LLVMValueRef genArrayLit(ZCodegen *ctx, ZNode *node) { ZLLVMStack *stack = getStackValue(ctx, node); if (!stack) { - error(ctx->state, node->tok, "Missing stack value"); + error(ctx->state, node->tok, "Missing stack value %p", node); return NULL; } @@ -1245,6 +1278,7 @@ static void buildFuncVar(ZCodegen *ctx, ZNode *node, const char *name, ZType *ty ZLLVMStack *item = zalloc(ZLLVMStack); *item = (ZLLVMStack){ .stack = val, .type = type, .node = node }; + info(ctx->state, node->tok, "Pushed %p, %p", ctx->scope, node); vecpush(ctx->scope->stackAlloca, item); } @@ -1274,7 +1308,9 @@ static void genFuncVars(ZCodegen *ctx, ZNode *node) { genFuncVars(ctx, node->ifStmt.body); break; case NODE_VAR_DECL: - buildFuncVar(ctx, node->varDecl.rvalue, node->varDecl.ident->identNode.tok->str, node->resolved); + buildFuncVar(ctx, node->varDecl.rvalue, + node->varDecl.ident->identNode.tok->str, + node->resolved); break; case NODE_CALL: if (!node->resolved) { @@ -1325,17 +1361,26 @@ static LLVMValueRef genFunc(ZCodegen *ctx, ZNode *f) { LLVMTypeRef funcType = LLVMFunctionType(ret, args, veclen(args), false); LLVMValueRef func = LLVMAddFunction(ctx->mod, f->funcDef.mangled, funcType); - - for (usize i = 0; i < veclen(f->funcDef.args); i++) { - char *name = f->funcDef.args[i]->field.identifier->str; - putLLVMValueRef(ctx, name, LLVMGetParam(func, i)); - } ctx->currentFunc = func; LLVMBasicBlockRef entry = makeblock(ctx); LLVMPositionBuilderAtEnd(ctx->builder, entry); - /* All variable declarations are declared ad the start of the function. */ + /* Allocate a stack slot for each parameter so they can be reassigned. + * The receiver (if present) occupies param index 0, so regular args + * start at offset 1. */ + usize paramOffset = f->funcDef.receiver ? 1 : 0; + for (usize i = 0; i < veclen(f->funcDef.args); i++) { + char *name = f->funcDef.args[i]->field.identifier->str; + LLVMTypeRef paramType = genType(ctx, f->funcDef.args[i]->field.type); + + LLVMValueRef slot = LLVMBuildAlloca(ctx->builder, paramType, name); + LLVMBuildStore(ctx->builder, LLVMGetParam(func, i + paramOffset), slot); + + putLLVMValueRef(ctx, name, slot); + } + + /* All variable declarations are declared at the start of the function. */ genFuncVars(ctx, f->funcDef.body); genBlock(ctx, f->funcDef.body); diff --git a/zinc.c b/zinc.c index 3aea1eb..138a382 100644 --- a/zinc.c +++ b/zinc.c @@ -1,4 +1,5 @@ #include "zinc.h" +#include "zcolors.h" #include #include @@ -159,7 +160,10 @@ int main(int argc, char **argv) { allocator.close(); - printf("Elapsed time: %.02f seconds\n", elapsed); + if (!res) { + printf(" " COLOR_BOLD COLOR_GREEN "Finished" COLOR_RESET + " build in %.02fs\n", elapsed); + } return res; } diff --git a/zmod.c b/zmod.c index 2e9e048..95d94ae 100644 --- a/zmod.c +++ b/zmod.c @@ -1,5 +1,6 @@ #include "zinc.h" #include "zvec.h" +#include "zcolors.h" #include #include @@ -134,11 +135,20 @@ static void _stype(ZType *type, char **buff) { vecunion(*buff, "struct ", 7); vecunion(*buff, type->strct.name->str, strlen(type->strct.name->str)); break; - case Z_TYPE_ARRAY: + case Z_TYPE_ARRAY: { vecpush(*buff, '['); + + usize len = type->array.size; + + while (len > 0) { + vecpush(*buff, 48 + len % 10); + len /= 10; + } + vecpush(*buff, ']'); _stype(type->array.base, buff); break; + } case Z_TYPE_TUPLE: vecpush(*buff, '('); for (usize i = 0; i < veclen(type->tuple); i++) { @@ -418,7 +428,7 @@ void printNode(ZNode *node, u8 depth) { printNode(node->deferStmt.expr, depth); break; case NODE_ARRAY_LIT: - printf("\n"); + printf(" %zu\n", veclen(node->arraylit)); for(usize i = 0; i < veclen(node->arraylit); i++) { printNode(node->arraylit[i], depth); } @@ -681,6 +691,7 @@ bool visit(ZState *state, char *filename) { if (strcmp(state->pathFiles[i], filename) == 0) return false; } + printf(" " COLOR_BOLD COLOR_GREEN "Building" COLOR_RESET " %s\n", filename); vecpush(state->visitedFiles, filename); vecpush(state->pathFiles, filename); state->filename = filename; diff --git a/zsem.c b/zsem.c index 9ebd7bc..4085f14 100644 --- a/zsem.c +++ b/zsem.c @@ -21,6 +21,7 @@ static void analyzeStmt(ZSemantic *, ZNode *); static void analyzeBlock(ZSemantic *, ZNode *, bool); static ZType *resolveTypeRef(ZSemantic *, ZType *); +static ZType *resolveReceiverCall(ZSemantic *, ZType *, ZToken *); /* ================== Scope / Symbol helpers ================== */ @@ -157,13 +158,17 @@ static void putReceiverFunc(ZSemantic *semantic, ZNode *node) { ZNode *receiver = node->funcDef.receiver; ZFuncTable **funcs = semantic->table->funcs; - for (usize i = 0; i < veclen(funcs); i++) { + ZFuncTable *table = NULL; + for (usize i = 0; i < veclen(funcs) && !table; i++) { if (typesEqual(funcs[i]->base, receiver->field.type)) { - vecpush(funcs[i]->funcDef, node); - return; + table = funcs[i]; } } + if (!table) table = makefunctable(receiver->field.type); + + vecpush(table->funcDef, node); + vecpush(semantic->table->funcs, table); } static void putStaticFunc(ZSemantic *semantic, ZNode *node) { @@ -380,7 +385,7 @@ ZType *typesCompatible(ZState *state, ZType *a, ZType *b) { return a; } - if (typesEqual(a, b)) return a; + if (typesEqual(a, b)) return b; if (a->kind != Z_TYPE_PRIMITIVE || b->kind != Z_TYPE_PRIMITIVE) return NULL; @@ -468,6 +473,13 @@ bool typesEqual(ZType *a, ZType *b) { case Z_TYPE_POINTER: return typesEqual(a->base, b->base); case Z_TYPE_ARRAY: + if (a->array.size == 0 && b->array.size > 0) { + a->array.size = b->array.size; + } else if (b->array.size == 0 && a->array.size > 0) { + b->array.size = a->array.size; + } else if (a->array.size != b->array.size) { + printf("Mismatch array size\n"); + } return typesEqual(a->array.base, b->array.base); case Z_TYPE_STRUCT: case Z_TYPE_FUNCTION: @@ -686,6 +698,13 @@ static ZType *resolveFuncCall(ZSemantic *semantic, ZNode *curr) { expectedArgs = func->resolved->func.args; } } + } else if (callee->type == NODE_MEMBER) { + ZType *obj = resolveType(semantic, callee->memberAccess.object); + + ZToken *prop = callee->memberAccess.field; + + result = resolveReceiverCall(semantic, obj, prop); + printType(result); } else { /* Expression call: resolve callee type and extract return type. */ ZType *calleeType = resolveType(semantic, callee); @@ -891,6 +910,8 @@ static ZType *resolveArrayLiteral(ZSemantic *semantic, ZNode *curr) { ZType *result = maketype(Z_TYPE_ARRAY); result->array.base = arrType; result->array.size = len; + + return result; } @@ -986,12 +1007,19 @@ ZType *resolveType(ZSemantic *semantic, ZNode *curr) { } break; - case NODE_CAST: + case NODE_CAST: { /* Resolve the inner expression type (for side-effects / validation). */ - resolveType(semantic, curr->castExpr.expr); + ZType *expr = resolveType(semantic, curr->castExpr.expr); result = resolveTypeRef(semantic, curr->castExpr.toType); + + if (expr->kind == Z_TYPE_ARRAY && + result->kind == Z_TYPE_ARRAY) { + result->array.size = expr->array.size; + } + curr->castExpr.toType = result; break; + } case NODE_SIZEOF: { /* sizeof yields u64. */ @@ -1028,14 +1056,16 @@ static ZType *resolveReceiverCall(ZSemantic *semantic, ZFuncTable **table = semantic->table->funcs; ZNode **funcs = NULL; - for (usize i = 0; i < veclen(table) && !funcs; i++) { + for (usize i = 0; i < veclen(table); i++) { ZType *receiverType = resolveTypeRef(semantic, table[i]->base); table[i]->base = receiverType; table[i]->base = receiverType; if (typesEqual(receiverType, caller)) { funcs = table[i]->funcDef; + break; } } + if (!funcs) return NULL; for (usize i = 0; i < veclen(funcs); i++) { @@ -1230,6 +1260,7 @@ static void analyzeFunc(ZSemantic *semantic, ZNode *curr) { if (curr->funcDef.receiver) { ZNode *receiver = curr->funcDef.receiver; ZType *recType = resolveTypeRef(semantic, receiver->field.type); + curr->funcDef.receiver->resolved = recType; receiver->field.type = recType; ZSymbol *sym = makesymbol(Z_SYM_VAR); diff --git a/ztok.h b/ztok.h index a8224e5..0aacbaf 100644 --- a/ztok.h +++ b/ztok.h @@ -7,20 +7,20 @@ #define TOK_BASE_MASK 16 -#define TOK_FLOWS_MASK (1 << (TOK_BASE_MASK)) -#define TOK_TYPES_MASK (1 << (TOK_BASE_MASK + 1)) -#define TOK_DYN_MASK (1 << (TOK_BASE_MASK + 2)) -#define TOK_SYMBOLS_MASK (1 << (TOK_BASE_MASK + 3)) -#define TOK_OPERATOR (1 << (TOK_BASE_MASK + 4)) -#define TOK_TYPES_SIGNATURE_MASK (1 << (TOK_BASE_MASK + 5)) -#define TOK_LITERAL (1 << (TOK_BASE_MASK + 6)) -#define TOK_SIGNED (1 << (TOK_BASE_MASK + 7)) -#define TOK_UNSIGNED (1 << (TOK_BASE_MASK + 8)) -#define TOK_FLOAT (1 << (TOK_BASE_MASK + 9)) -#define TOK_OVERRIDABLE (1 << (TOK_BASE_MASK + 10)) -#endif - -#ifdef TOK_FLOWS +#define TOK_FLOWS_MASK (1 << (TOK_BASE_MASK)) +#define TOK_TYPES_MASK (1 << (TOK_BASE_MASK + 1)) +#define TOK_DYN_MASK (1 << (TOK_BASE_MASK + 2)) +#define TOK_SYMBOLS_MASK (1 << (TOK_BASE_MASK + 3)) +#define TOK_OPERATOR (1 << (TOK_BASE_MASK + 4)) +#define TOK_TYPES_SIGNATURE_MASK (1 << (TOK_BASE_MASK + 5)) +#define TOK_LITERAL (1 << (TOK_BASE_MASK + 6)) +#define TOK_SIGNED (1 << (TOK_BASE_MASK + 7)) +#define TOK_UNSIGNED (1 << (TOK_BASE_MASK + 8)) +#define TOK_FLOAT (1 << (TOK_BASE_MASK + 9)) +#define TOK_OVERRIDABLE (1 << (TOK_BASE_MASK + 10)) +#endif + +#ifdef TOK_FLOWS DEF(TOK_IF, "if", TOK_FLOWS_MASK | TOK_OVERRIDABLE | 0x00) DEF(TOK_ELSE, "else", TOK_FLOWS_MASK | TOK_OVERRIDABLE | 0x01) DEF(TOK_FOR, "for", TOK_FLOWS_MASK | TOK_OVERRIDABLE | 0x02) @@ -31,82 +31,82 @@ DEF(TOK_GOTO, "goto", TOK_FLOWS_MASK | TOK_OVERRIDABLE | 0x06) DEF(TOK_SWITCH, "switch", TOK_FLOWS_MASK | TOK_OVERRIDABLE | 0x07) DEF(TOK_CASE, "case", TOK_FLOWS_MASK | TOK_OVERRIDABLE | 0x08) DEF(TOK_MODULE, "use", TOK_FLOWS_MASK | TOK_OVERRIDABLE | 0x09) -DEF(TOK_FOREIGN, "foreign", TOK_FLOWS_MASK | TOK_OVERRIDABLE | 0x0A) -DEF(TOK_DEFER, "defer", TOK_FLOWS_MASK | TOK_OVERRIDABLE | 0x0B) -DEF(TOK_IN, "in", TOK_FLOWS_MASK | TOK_OVERRIDABLE | 0x0C) -DEF(TOK_MATCH, "match", TOK_FLOWS_MASK | TOK_OVERRIDABLE | 0x0D) -DEF(TOK_MACRO, "macro", TOK_FLOWS_MASK | 0x0E) -DEF(TOK_SNOT, "not", TOK_FLOWS_MASK | 0x0F) -DEF(TOK_SOR, "or", TOK_FLOWS_MASK | 0x10) -DEF(TOK_SAND, "and", TOK_FLOWS_MASK | 0x11) -DEF(TOK_NONE, "none", TOK_FLOWS_MASK | 0x12) -DEF(TOK_TRUE, "true", TOK_FLOWS_MASK | TOK_LITERAL | 0x13) -DEF(TOK_FALSE, "false", TOK_FLOWS_MASK | TOK_LITERAL | 0x14) -DEF(TOK_CAST, "as", TOK_FLOWS_MASK | TOK_OVERRIDABLE | 0x15) -DEF(TOK_SIZEOF, "sizeof", TOK_FLOWS_MASK | TOK_OVERRIDABLE | 0x16) +DEF(TOK_FOREIGN, "foreign", TOK_FLOWS_MASK | TOK_OVERRIDABLE | 0x0A) +DEF(TOK_DEFER, "defer", TOK_FLOWS_MASK | TOK_OVERRIDABLE | 0x0B) +DEF(TOK_IN, "in", TOK_FLOWS_MASK | TOK_OVERRIDABLE | 0x0C) +DEF(TOK_MATCH, "match", TOK_FLOWS_MASK | TOK_OVERRIDABLE | 0x0D) +DEF(TOK_MACRO, "macro", TOK_FLOWS_MASK | 0x0E) +DEF(TOK_SNOT, "not", TOK_FLOWS_MASK | 0x0F) +DEF(TOK_SOR, "or", TOK_FLOWS_MASK | 0x10) +DEF(TOK_SAND, "and", TOK_FLOWS_MASK | 0x11) +DEF(TOK_NONE, "none", TOK_FLOWS_MASK | 0x12) +DEF(TOK_TRUE, "true", TOK_FLOWS_MASK | TOK_LITERAL | 0x13) +DEF(TOK_FALSE, "false", TOK_FLOWS_MASK | TOK_LITERAL | 0x14) +DEF(TOK_CAST, "as", TOK_FLOWS_MASK | TOK_OVERRIDABLE | 0x15) +DEF(TOK_SIZEOF, "sizeof", TOK_FLOWS_MASK | TOK_OVERRIDABLE | 0x16) #endif #ifdef TOK_TYPES -DEF(TOK_VOID, "u0", TOK_TYPES_MASK | 0x20) -DEF(TOK_BOOL, "u1", TOK_TYPES_MASK | TOK_SIGNED | 0x21) -DEF(TOK_CHAR, "char", TOK_TYPES_MASK | 0x22) -DEF(TOK_F32, "f32", TOK_TYPES_MASK | TOK_FLOAT | 0x23) -DEF(TOK_F64, "f64", TOK_TYPES_MASK | TOK_FLOAT | 0x24) -DEF(TOK_I8, "i8", TOK_TYPES_MASK | TOK_SIGNED | 0x25) -DEF(TOK_I16, "i16", TOK_TYPES_MASK | TOK_SIGNED | 0x26) -DEF(TOK_I32, "i32", TOK_TYPES_MASK | TOK_SIGNED | 0x27) -DEF(TOK_I64, "i64", TOK_TYPES_MASK | TOK_SIGNED | 0x28) -DEF(TOK_U8, "u8", TOK_TYPES_MASK | TOK_UNSIGNED | 0x29) -DEF(TOK_U16, "u16", TOK_TYPES_MASK | TOK_UNSIGNED | 0x2A) -DEF(TOK_U32, "u32", TOK_TYPES_MASK | TOK_UNSIGNED | 0x2B) -DEF(TOK_U64, "u64", TOK_TYPES_MASK | TOK_UNSIGNED | 0x2C) -DEF(TOK_STRUCT, "struct", TOK_TYPES_SIGNATURE_MASK | TOK_OVERRIDABLE | 0x2D) -DEF(TOK_UNION, "union", TOK_TYPES_SIGNATURE_MASK | TOK_OVERRIDABLE | 0x2E) -DEF(TOK_TYPEDEF, "type", TOK_TYPES_SIGNATURE_MASK | 0x2F) -DEF(TOK_ENUM, "enum", TOK_TYPES_SIGNATURE_MASK | TOK_OVERRIDABLE | 0x30) -DEF(TOK_CONST, "const", TOK_TYPES_SIGNATURE_MASK | 0x31) -DEF(TOK_PUB, "pub", TOK_TYPES_SIGNATURE_MASK | 0x32) +DEF(TOK_VOID, "u0", TOK_TYPES_MASK | 0x20) +DEF(TOK_BOOL, "u1", TOK_TYPES_MASK | TOK_SIGNED | 0x21) +DEF(TOK_CHAR, "char", TOK_TYPES_MASK | 0x22) +DEF(TOK_F32, "f32", TOK_TYPES_MASK | TOK_FLOAT | 0x23) +DEF(TOK_F64, "f64", TOK_TYPES_MASK | TOK_FLOAT | 0x24) +DEF(TOK_I8, "i8", TOK_TYPES_MASK | TOK_SIGNED | 0x25) +DEF(TOK_I16, "i16", TOK_TYPES_MASK | TOK_SIGNED | 0x26) +DEF(TOK_I32, "i32", TOK_TYPES_MASK | TOK_SIGNED | 0x27) +DEF(TOK_I64, "i64", TOK_TYPES_MASK | TOK_SIGNED | 0x28) +DEF(TOK_U8, "u8", TOK_TYPES_MASK | TOK_UNSIGNED | 0x29) +DEF(TOK_U16, "u16", TOK_TYPES_MASK | TOK_UNSIGNED | 0x2A) +DEF(TOK_U32, "u32", TOK_TYPES_MASK | TOK_UNSIGNED | 0x2B) +DEF(TOK_U64, "u64", TOK_TYPES_MASK | TOK_UNSIGNED | 0x2C) +DEF(TOK_STRUCT, "struct", TOK_TYPES_SIGNATURE_MASK | TOK_OVERRIDABLE | 0x2D) +DEF(TOK_UNION, "union", TOK_TYPES_SIGNATURE_MASK | TOK_OVERRIDABLE | 0x2E) +DEF(TOK_TYPEDEF, "type", TOK_TYPES_SIGNATURE_MASK | 0x2F) +DEF(TOK_ENUM, "enum", TOK_TYPES_SIGNATURE_MASK | TOK_OVERRIDABLE | 0x30) +DEF(TOK_CONST, "const", TOK_TYPES_SIGNATURE_MASK | 0x31) +DEF(TOK_PUB, "pub", TOK_TYPES_SIGNATURE_MASK | 0x32) #endif #ifdef TOK_DYN -DEF(TOK_STR_LIT, "string literal", TOK_DYN_MASK | TOK_LITERAL | 0x40) -DEF(TOK_INT_LIT, "int literal", TOK_DYN_MASK | TOK_LITERAL | 0x41) -DEF(TOK_FLOAT_LIT, "float literal", TOK_DYN_MASK | TOK_LITERAL | 0x43) -DEF(TOK_IDENT, "identifier", TOK_DYN_MASK | TOK_LITERAL | TOK_OVERRIDABLE | 0x44) +DEF(TOK_STR_LIT, "string literal", TOK_DYN_MASK | TOK_LITERAL | 0x40) +DEF(TOK_INT_LIT, "int literal", TOK_DYN_MASK | TOK_LITERAL | 0x41) +DEF(TOK_FLOAT_LIT, "float literal", TOK_DYN_MASK | TOK_LITERAL | 0x43) +DEF(TOK_IDENT, "identifier", TOK_DYN_MASK | TOK_LITERAL | TOK_OVERRIDABLE | 0x44) #endif #ifdef TOK_SYMBOLS -DEF(TOK_ARROW, "->", TOK_SYMBOLS_MASK | 0x50) -DEF(TOK_EQEQ, "==", TOK_SYMBOLS_MASK | 0x51) -DEF(TOK_NOTEQ, "!=", TOK_SYMBOLS_MASK | 0x52) -DEF(TOK_AND, "&&", TOK_SYMBOLS_MASK | 0x53) -DEF(TOK_OR, "||", TOK_SYMBOLS_MASK | 0x54) -DEF(TOK_ASSIGN, ":=", TOK_SYMBOLS_MASK | 0x55) +DEF(TOK_ARROW, "->", TOK_SYMBOLS_MASK | 0x50) +DEF(TOK_EQEQ, "==", TOK_SYMBOLS_MASK | 0x51) +DEF(TOK_NOTEQ, "!=", TOK_SYMBOLS_MASK | 0x52) +DEF(TOK_AND, "&&", TOK_SYMBOLS_MASK | 0x53) +DEF(TOK_OR, "||", TOK_SYMBOLS_MASK | 0x54) +DEF(TOK_ASSIGN, ":=", TOK_SYMBOLS_MASK | 0x55) DEF(TOK_DOUBLE_COLON, "::", TOK_SYMBOLS_MASK | 0x71) -DEF(TOK_LPAREN, "(", TOK_SYMBOLS_MASK | 0x56) -DEF(TOK_RPAREN, ")", TOK_SYMBOLS_MASK | 0x57) -DEF(TOK_LBRACKET, "{", TOK_SYMBOLS_MASK | 0x58) -DEF(TOK_RBRACKET, "}", TOK_SYMBOLS_MASK | 0x59) -DEF(TOK_LSBRACKET, "[", TOK_SYMBOLS_MASK | 0x5A) -DEF(TOK_RSBRACKET, "]", TOK_SYMBOLS_MASK | 0x5B) -DEF(TOK_REF, "&", TOK_SYMBOLS_MASK | 0x5C) -DEF(TOK_STAR, "*", TOK_OPERATOR | TOK_SYMBOLS_MASK | 0x5D) -DEF(TOK_PLUS, "+", TOK_OPERATOR | TOK_SYMBOLS_MASK | 0x60) -DEF(TOK_MINUS, "-", TOK_OPERATOR | TOK_SYMBOLS_MASK | 0x61) -DEF(TOK_DIV, "/", TOK_OPERATOR | TOK_SYMBOLS_MASK | 0x62) -DEF(TOK_NOT, "!", TOK_OPERATOR | TOK_SYMBOLS_MASK | 0x63) -DEF(TOK_COMMA, ",", TOK_SYMBOLS_MASK | TOK_OVERRIDABLE | 0x64) -DEF(TOK_EQ, "=", TOK_SYMBOLS_MASK | TOK_OVERRIDABLE | 0x65) -DEF(TOK_DOT, ".", TOK_SYMBOLS_MASK | TOK_OVERRIDABLE | 0x66) -DEF(TOK_GTE, ">=", TOK_SYMBOLS_MASK | 0x67) -DEF(TOK_LTE, "<=", TOK_SYMBOLS_MASK | 0x68) -DEF(TOK_GT, ">", TOK_SYMBOLS_MASK | 0x69) -DEF(TOK_LT, "<", TOK_SYMBOLS_MASK | 0x6A) -DEF(TOK_SEMICOLON, ";", TOK_SYMBOLS_MASK | TOK_OVERRIDABLE | 0x6B) -DEF(TOK_COLON, ":", TOK_SYMBOLS_MASK | TOK_OVERRIDABLE | 0x6C) -DEF(TOK_MACRO_EXPR, "$", TOK_SYMBOLS_MASK | 0x6D) -DEF(TOK_MACRO_IDENT, "@", TOK_SYMBOLS_MASK | 0x6E) -DEF(TOK_MACRO_TYPE, "#", TOK_SYMBOLS_MASK | 0x6F) -DEF(TOK_QUOTE, "'", TOK_SYMBOLS_MASK | 0x70) -DEF(TOK_MOD, "%%", TOK_OPERATOR | TOK_SYMBOLS_MASK | 0x72) +DEF(TOK_LPAREN, "(", TOK_SYMBOLS_MASK | 0x56) +DEF(TOK_RPAREN, ")", TOK_SYMBOLS_MASK | 0x57) +DEF(TOK_LBRACKET, "{", TOK_SYMBOLS_MASK | 0x58) +DEF(TOK_RBRACKET, "}", TOK_SYMBOLS_MASK | 0x59) +DEF(TOK_LSBRACKET, "[", TOK_SYMBOLS_MASK | 0x5A) +DEF(TOK_RSBRACKET, "]", TOK_SYMBOLS_MASK | 0x5B) +DEF(TOK_REF, "&", TOK_SYMBOLS_MASK | 0x5C) +DEF(TOK_STAR, "*", TOK_OPERATOR | TOK_SYMBOLS_MASK | 0x5D) +DEF(TOK_PLUS, "+", TOK_OPERATOR | TOK_SYMBOLS_MASK | 0x60) +DEF(TOK_MINUS, "-", TOK_OPERATOR | TOK_SYMBOLS_MASK | 0x61) +DEF(TOK_DIV, "/", TOK_OPERATOR | TOK_SYMBOLS_MASK | 0x62) +DEF(TOK_NOT, "!", TOK_OPERATOR | TOK_SYMBOLS_MASK | 0x63) +DEF(TOK_COMMA, ",", TOK_SYMBOLS_MASK | TOK_OVERRIDABLE | 0x64) +DEF(TOK_EQ, "=", TOK_SYMBOLS_MASK | TOK_OVERRIDABLE | 0x65) +DEF(TOK_DOT, ".", TOK_SYMBOLS_MASK | TOK_OVERRIDABLE | 0x66) +DEF(TOK_GTE, ">=", TOK_SYMBOLS_MASK | 0x67) +DEF(TOK_LTE, "<=", TOK_SYMBOLS_MASK | 0x68) +DEF(TOK_GT, ">", TOK_SYMBOLS_MASK | 0x69) +DEF(TOK_LT, "<", TOK_SYMBOLS_MASK | 0x6A) +DEF(TOK_SEMICOLON, ";", TOK_SYMBOLS_MASK | TOK_OVERRIDABLE | 0x6B) +DEF(TOK_COLON, ":", TOK_SYMBOLS_MASK | TOK_OVERRIDABLE | 0x6C) +DEF(TOK_MACRO_EXPR, "$", TOK_SYMBOLS_MASK | 0x6D) +DEF(TOK_MACRO_IDENT, "@", TOK_SYMBOLS_MASK | 0x6E) +DEF(TOK_MACRO_TYPE, "#", TOK_SYMBOLS_MASK | 0x6F) +DEF(TOK_QUOTE, "'", TOK_SYMBOLS_MASK | 0x70) +DEF(TOK_MOD, "%%", TOK_OPERATOR | TOK_SYMBOLS_MASK | 0x72) #endif