12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130 |
- #include <setjmp.h>
- #include <stdarg.h>
- #include <stdio.h>
- #include <stdlib.h>
- #include <string.h>
- #include "Compiler.h"
- #include "DataType.h"
- #include "tokenizer/Tokenizer.h"
- #include "utils/Functions.h"
- #include "utils/Variables.h"
- #include "vm/Operation.h"
- static Error* error = NULL;
- static ByteCode* code;
- static int16 line = 1;
- static const char* path = NULL;
- static jmp_buf errorJump;
- #define RETURN_BUFFER 16
- #define BREAK_BUFFER 32
- #define DT_OPERATION(op) \
- case DT_INT: cAddOperation(OP_##op##_INT); break; \
- case DT_FLOAT: cAddOperation(OP_##op##_FLOAT); break;
- typedef DataType (*Parser)(void);
- static bool onLine = false;
- static Variables vars;
- static Variables globalVars;
- static Functions functions;
- static Functions functionQueue;
- static Structs structs;
- static int returns[RETURN_BUFFER];
- static int returnIndex = 0;
- static int hasReturn = 0;
- static DataType returnType;
- static int breaks[BREAK_BUFFER];
- static int breakIndex = 0;
- static int forWhileStack = 0;
- static int continueAt = 0;
- typedef struct {
- const char* name;
- Operation intOp;
- Operation floatOp;
- Operation pointerOp;
- char padding[sizeof(Operation)];
- } TypedOp;
- #define TYPE_OP(NAME, FLOAT, POINTER, text) \
- static const TypedOp TYPED_##NAME = { \
- text, OP_##NAME##_INT, OP_##FLOAT, OP_##POINTER, {0}};
- TYPE_OP(MUL, MUL_FLOAT, NOTHING, "*")
- TYPE_OP(DIV, DIV_FLOAT, NOTHING, "/")
- TYPE_OP(MOD, NOTHING, NOTHING, "%")
- TYPE_OP(ADD, ADD_FLOAT, NOTHING, "+")
- TYPE_OP(SUB, SUB_FLOAT, NOTHING, "-")
- TYPE_OP(LESS, LESS_FLOAT, NOTHING, "<")
- TYPE_OP(LESS_EQUAL, LESS_EQUAL_FLOAT, NOTHING, "<=")
- TYPE_OP(GREATER, GREATER_FLOAT, NOTHING, ">")
- TYPE_OP(GREATER_EQUAL, GREATER_EQUAL_FLOAT, NOTHING, ">=")
- TYPE_OP(EQUAL, EQUAL_FLOAT, EQUAL_POINTER, "==")
- TYPE_OP(NOT_EQUAL, NOT_EQUAL_FLOAT, NOT_EQUAL_POINTER, "!=")
- TYPE_OP(BIT_OR, NOTHING, NOTHING, "|")
- TYPE_OP(BIT_XOR, NOTHING, NOTHING, "^")
- TYPE_OP(BIT_AND, NOTHING, NOTHING, "&")
- TYPE_OP(LEFT_SHIFT, NOTHING, NOTHING, "<<")
- TYPE_OP(RIGHT_SHIFT, NOTHING, NOTHING, ">>")
- static void cError(const char* format, ...) {
- va_list args;
- va_start(args, format);
- eInitErrorV(error, path, line, format, args);
- va_end(args);
- longjmp(errorJump, 0);
- }
- static const char* cGetName(DataType dt) {
- return dtGetName(&structs, dt);
- }
- static void cInvalidOperation(DataType a, DataType b, const char* op) {
- cError("invalid operation: %s %s %s", cGetName(a), op, cGetName(b));
- }
- static void cNotDeclared(const char* name) {
- cError("variable %s has not been declared", name);
- }
- static void cDeclared(const char* name) {
- cError("%s has already been declared", name);
- }
- static void cTooMuchArguments(void) {
- cError("too much function arguments");
- }
- static void cUnexpectedToken(Token t) {
- cError("unexpected token: %s", tGetName(t));
- }
- #define BUFFER_SIZE 256
- static void cUnknownFunction(Function* f) {
- int max = 0;
- char buffer[BUFFER_SIZE] = {'\0'};
- for(int i = 0; i < f->arguments; i++) {
- const char* name = dtGetName(&structs, f->argumentTypes[i]);
- max += snprintf(buffer + max, (size_t)(BUFFER_SIZE - max),
- i > 0 ? ", %s" : "%s", name);
- }
- cError("unknown function: %s(%s)", f->name, buffer);
- }
- static void cAddOperation(Operation token) {
- unsigned char c = token;
- bcAddBytes(code, &c, 1);
- }
- static int32 cReserveInt32(void) {
- return bcReserveBytes(code, sizeof(int32));
- }
- static void cSetInt32(int p, int32 i) {
- bcSetBytes(code, p, &i, sizeof(int32));
- }
- static void cAddInt32(int32 i) {
- bcAddBytes(code, &i, sizeof(int32));
- }
- static void cAddInt32Operation(Operation token, int32 i) {
- cAddOperation(token);
- cAddInt32(i);
- }
- static void cAddByteOperation(Operation token, int8 i) {
- cAddOperation(token);
- bcAddBytes(code, &i, sizeof(int8));
- }
- static void cAddLine(int16 l) {
- cAddOperation(OP_LINE);
- bcAddBytes(code, &l, sizeof(int16));
- }
- static Token cReadTokenAndLine(void) {
- hasReturn--;
- Token t;
- if(tReadTokenAndLine(&t, &line)) {
- return T_END;
- }
- return t;
- }
- static void cConsumeToken(Token wanted) {
- Token t = cReadTokenAndLine();
- if(wanted != t) {
- cError("expected '%s' got '%s'", tGetName(wanted), tGetName(t));
- }
- }
- static bool cConsumeTokenIf(Token t) {
- return tPeekToken() == t && cReadTokenAndLine() == t;
- }
- static void cConstantInt32(void) {
- int32 value;
- if(tReadInt32(&value)) {
- cError("int token without an int");
- }
- cAddInt32Operation(OP_PUSH_INT, value);
- }
- static void cConstantFloat(void) {
- float value;
- if(tReadFloat(&value)) {
- cError("float token without a float");
- }
- cAddOperation(OP_PUSH_FLOAT);
- bcAddBytes(code, &value, sizeof(float));
- }
- static const char* cReadString(void) {
- const char* literal = tReadString();
- if(literal == NULL) {
- cError("literal without string on line %d", line);
- }
- return literal;
- }
- static int cGetSize(DataType dt) {
- return dtGetSize(dt, &structs);
- }
- static DataType cExtendType(DataType dt) {
- if(cConsumeTokenIf(T_OPEN_SQUARE_BRACKET)) {
- cConsumeToken(T_CLOSE_SQUARE_BRACKET);
- dt = dtToArray(dt);
- }
- return dt;
- }
- static DataType cReadType(Token t, bool force) {
- switch(t) {
- case T_INT: return dtInt();
- case T_FLOAT: return dtFloat();
- case T_LITERAL: {
- Struct* st = stsSearch(&structs, cReadString());
- if(st == NULL) {
- if(force) {
- cError("struct %s does not exist");
- } else {
- return dtVoid();
- }
- }
- return dtStruct(st);
- }
- default:
- if(force) {
- cUnexpectedToken(t);
- }
- return dtVoid();
- }
- }
- static DataType cReadExtendedType(Token t, bool force) {
- DataType dt = cReadType(t, force);
- if(!dtIsVoid(dt)) {
- dt = cExtendType(dt);
- }
- return dt;
- }
- static DataType cExpression(void);
- static void cLoadRef(DataType type) {
- if(dtIsArray(type)) {
- cAddOperation(OP_LOAD_ARRAY);
- return;
- }
- switch(type.type) {
- DT_OPERATION(LOAD);
- default: cError("cannot load type %s", cGetName(type));
- }
- }
- static DataType cUnpack(DataType dt) {
- if(dt.type != DT_STRUCT && dtRemovePointer(&dt)) {
- cLoadRef(dt);
- }
- return dt;
- }
- static DataType cUnpackedExpression(void) {
- return cUnpack(cExpression());
- }
- static void cCallFunctionArguments(Function* f) {
- if(cConsumeTokenIf(T_CLOSE_BRACKET)) {
- return;
- }
- while(true) {
- DataType dt = cUnpackedExpression();
- if(fAddArgument(f, dt, &structs)) {
- cTooMuchArguments();
- } else if(cConsumeTokenIf(T_CLOSE_BRACKET)) {
- return;
- }
- cConsumeToken(T_COMMA);
- }
- }
- static DataType cCallFunction(const char* name) {
- int returnAddress = bcGetAddress(code);
- Function f;
- fInit(&f, name, line);
- int oldOnLine = onLine;
- onLine = false;
- cCallFunctionArguments(&f);
- onLine = oldOnLine;
- Function* found = fsSearch(&functions, &f);
- if(found == NULL) {
- cUnknownFunction(&f);
- } else if(found->global) {
- cAddInt32Operation(OP_CALL, found->line);
- return found->returnType;
- }
- char push[1 + sizeof(int32)] = {OP_PUSH_INT};
- bcInsertBytes(code, push, sizeof(push), returnAddress);
- cAddOperation(OP_GOSUB);
- if(found->address == -1) {
- f.returnType = found->returnType;
- f.address = cReserveInt32();
- fsAdd(&functionQueue, &f);
- } else {
- cAddInt32(found->address);
- }
- cAddInt32(found->size);
- return found->returnType;
- }
- static void cStore(DataType left, DataType right, const char* name) {
- if(dtIsArray(left)) {
- if(!dtCompare(left, right)) {
- cInvalidOperation(left, right, name);
- }
- cAddOperation(OP_STORE_ARRAY);
- return;
- }
- if(!dtCompare(left, right)) {
- cInvalidOperation(left, right, name);
- }
- switch(left.type) {
- DT_OPERATION(STORE);
- default: cError("cannot store type %s", cGetName(left));
- }
- }
- static DataType cLiteral(void) {
- const char* literal = cReadString();
- if(cConsumeTokenIf(T_OPEN_BRACKET)) {
- return cCallFunction(literal);
- }
- Variable v;
- if(!vsSearch(&vars, &v, literal)) {
- if(v.type.pointer != 0) {
- if(v.type.type != DT_STRUCT) {
- cError("non struct type %s should not be a pointer here",
- cGetName(v.type));
- }
- cAddInt32Operation(OP_PUSH_STRUCT_REFERENCE, v.address);
- } else {
- cAddInt32Operation(OP_DEREFERENCE_VAR, v.address);
- }
- return dtToPointer(v.type);
- } else if(!vsSearch(&globalVars, &v, literal)) {
- cAddInt32Operation(OP_DEREFERENCE_GVAR, v.address);
- return dtToPointer(v.type);
- }
- cNotDeclared(literal);
- return dtVoid();
- }
- static DataType cText(void) {
- cAddOperation(OP_PUSH_TEXT);
- int32 lengthAddress = cReserveInt32();
- int32 length = 0;
- int32 c;
- while(!tReadInt32(&c) && c != 0) {
- cAddInt32(c);
- length++;
- }
- cSetInt32(lengthAddress, length);
- return dtText();
- }
- static DataType cBracketPrimary(void) {
- DataType result = cExpression();
- cConsumeToken(T_CLOSE_BRACKET);
- return result;
- }
- static void cArrayIndex(void) {
- if(!dtIsInt(cUnpackedExpression())) {
- cError("array index must be an int");
- }
- }
- static DataType cAllocArray(void) {
- DataType dt = cReadType(cReadTokenAndLine(), true);
- if(dt.array != 0) {
- cError("array type must not be an array");
- }
- cConsumeToken(T_OPEN_SQUARE_BRACKET);
- cArrayIndex();
- cConsumeToken(T_CLOSE_SQUARE_BRACKET);
- cAddInt32Operation(OP_NEW, cGetSize(dt));
- return dtToArray(dt);
- }
- static DataType cLength(void) {
- DataType array = cUnpackedExpression();
- if(!dtIsArray(array)) {
- cError("length expects an array");
- }
- cAddOperation(OP_LENGTH);
- return dtInt();
- }
- static DataType cPrimary(void) {
- Token t = cReadTokenAndLine();
- switch(t) {
- case T_INT_VALUE: cConstantInt32(); return dtInt();
- case T_FLOAT_VALUE: cConstantFloat(); return dtFloat();
- case T_TEXT: return cText();
- case T_OPEN_BRACKET: return cBracketPrimary();
- case T_LITERAL: return cLiteral();
- case T_NEW: return cAllocArray();
- case T_LENGTH: return cLength();
- default: cUnexpectedToken(t); return dtVoid();
- }
- }
- static void cRemoveReference(DataType* dt, const char* name) {
- if(!dtRemovePointer(dt)) {
- cError("%s needs a reference not %s", name, cGetName(*dt));
- }
- }
- static void cExpectType(DataType actual, DataType wanted, const char* name) {
- if(!dtCompare(actual, wanted)) {
- cError("%s needs %s not %s", name, cGetName(wanted), cGetName(actual));
- }
- }
- static void cChangeType(DataType* dt, Operation op, Operation pushOp,
- int8 change) {
- if(onLine) {
- cAddByteOperation(op, change);
- *dt = dtVoid();
- } else {
- cAddByteOperation(pushOp, change);
- }
- }
- static void cPostChange(DataType* dt, int8 change, const char* name) {
- cRemoveReference(dt, name);
- if(dtIsInt(*dt)) {
- cChangeType(dt, OP_CHANGE_INT, OP_PUSH_POST_CHANGE_INT, change);
- } else {
- cError("%s needs an int not %s", name, cGetName(*dt));
- }
- }
- static DataType cStructAccess(DataType dt) {
- Struct* st = dtGetStruct(&structs, dt);
- if(st == NULL) {
- cError(". expects a struct not %s", cGetName(dt));
- }
- cConsumeToken(T_LITERAL);
- const char* name = cReadString();
- Variable inner;
- if(vSearchStruct(&inner, &structs, st, name)) {
- cError("%s has no member %s", st->name, name);
- } else if(inner.address > 0) {
- cAddInt32Operation(OP_PUSH_INT, inner.address);
- cAddInt32Operation(OP_ADD_REFERENCE, 1);
- }
- return dtToPointer(inner.type);
- }
- static DataType cAccess(void) {
- DataType dt = cPrimary();
- while(true) {
- if(cConsumeTokenIf(T_INCREMENT)) {
- cPostChange(&dt, 1, "++");
- } else if(cConsumeTokenIf(T_DECREMENT)) {
- cPostChange(&dt, -1, "--");
- } else if(cConsumeTokenIf(T_POINT)) {
- cRemoveReference(&dt, ".");
- dt = cStructAccess(dt);
- } else if(cConsumeTokenIf(T_OPEN_SQUARE_BRACKET)) {
- if(!dtIsArray(dt)) {
- cError("[] needs an array");
- }
- cAddOperation(OP_LOAD_ARRAY);
- dtRemovePointer(&dt);
- cArrayIndex();
- cConsumeToken(T_CLOSE_SQUARE_BRACKET);
- cAddInt32Operation(OP_ADD_REFERENCE, cGetSize(dt));
- dt = dtToPointer(dtRemoveArray(dt));
- } else {
- return dt;
- }
- }
- }
- static DataType cPreChange(DataType dt, int8 change, const char* name) {
- cRemoveReference(&dt, name);
- if(dtIsInt(dt)) {
- cChangeType(&dt, OP_CHANGE_INT, OP_PUSH_PRE_CHANGE_INT, change);
- } else {
- cError("%s needs an int not %s", name, cGetName(dt));
- }
- return dt;
- }
- static DataType cInvertSign(DataType dt) {
- if(dtIsInt(dt)) {
- cAddOperation(OP_INVERT_SIGN_INT);
- } else if(dtIsFloat(dt)) {
- cAddOperation(OP_INVERT_SIGN_FLOAT);
- } else {
- cError("cannot invert sign of %s", cGetName(dt));
- }
- return dt;
- }
- static DataType cCast(DataType in, DataType a, Operation aOp, DataType out) {
- if(dtCompare(in, a)) {
- cAddOperation(aOp);
- } else {
- cError("cannot cast %s to %s", cGetName(in), cGetName(out));
- }
- return out;
- }
- static DataType cUnaryNot(DataType dt) {
- cExpectType(dt, dtInt(), "!");
- cAddOperation(OP_NOT);
- return dt;
- }
- static DataType cUnaryBitNot(DataType dt) {
- if(dtIsInt(dt)) {
- cAddOperation(OP_BIT_NOT_INT);
- } else {
- cError("~ needs an int not %s", cGetName(dt));
- }
- return dt;
- }
- static DataType cPreUnary(void) {
- int marker = tGetMarker();
- if(cConsumeTokenIf(T_OPEN_BRACKET)) {
- if(cConsumeTokenIf(T_FLOAT) && cConsumeTokenIf(T_CLOSE_BRACKET)) {
- return cCast(cUnpack(cPreUnary()), dtInt(), OP_INT_TO_FLOAT,
- dtFloat());
- } else if(cConsumeTokenIf(T_INT) && cConsumeTokenIf(T_CLOSE_BRACKET)) {
- return cCast(cUnpack(cPreUnary()), dtFloat(), OP_FLOAT_TO_INT,
- dtInt());
- }
- }
- tReset(marker);
- if(cConsumeTokenIf(T_INCREMENT)) {
- return cPreChange(cPreUnary(), 1, "++");
- } else if(cConsumeTokenIf(T_DECREMENT)) {
- return cPreChange(cPreUnary(), -1, "--");
- } else if(cConsumeTokenIf(T_SUB)) {
- return cInvertSign(cUnpack(cPreUnary()));
- } else if(cConsumeTokenIf(T_NOT)) {
- return cUnaryNot(cPreUnary());
- } else if(cConsumeTokenIf(T_BIT_NOT)) {
- return cUnaryBitNot(cPreUnary());
- }
- return cAccess();
- }
- static void cAddTypeOperation(DataType* a, Parser bf, const TypedOp* op) {
- *a = cUnpack(*a);
- DataType b = cUnpack(bf());
- if(!dtCompare(*a, b)) {
- cInvalidOperation(*a, b, op->name);
- } else if(dtIsInt(*a) && op->intOp != OP_NOTHING) {
- cAddOperation(op->intOp);
- } else if(dtIsFloat(*a) && op->floatOp != OP_NOTHING) {
- cAddOperation(op->floatOp);
- } else if(dtIsArray(*a) && op->pointerOp != OP_NOTHING) {
- cAddOperation(op->pointerOp);
- } else {
- cInvalidOperation(*a, b, op->name);
- }
- }
- static DataType cMul(void) {
- DataType a = cPreUnary();
- while(true) {
- if(cConsumeTokenIf(T_MUL)) {
- cAddTypeOperation(&a, cPreUnary, &TYPED_MUL);
- } else if(cConsumeTokenIf(T_DIV)) {
- cAddTypeOperation(&a, cPreUnary, &TYPED_DIV);
- } else if(cConsumeTokenIf(T_MOD)) {
- cAddTypeOperation(&a, cPreUnary, &TYPED_MOD);
- } else {
- return a;
- }
- }
- }
- static DataType cAdd(void) {
- DataType a = cMul();
- while(true) {
- if(cConsumeTokenIf(T_ADD)) {
- cAddTypeOperation(&a, cMul, &TYPED_ADD);
- } else if(cConsumeTokenIf(T_SUB)) {
- cAddTypeOperation(&a, cMul, &TYPED_SUB);
- } else {
- return a;
- }
- }
- }
- static DataType cShift(void) {
- DataType a = cAdd();
- while(true) {
- if(cConsumeTokenIf(T_LEFT_SHIFT)) {
- cAddTypeOperation(&a, cAdd, &TYPED_LEFT_SHIFT);
- } else if(cConsumeTokenIf(T_RIGHT_SHIFT)) {
- cAddTypeOperation(&a, cAdd, &TYPED_RIGHT_SHIFT);
- } else {
- return a;
- }
- }
- }
- static DataType cComparison(void) {
- DataType a = cShift();
- while(true) {
- if(cConsumeTokenIf(T_LESS)) {
- cAddTypeOperation(&a, cShift, &TYPED_LESS);
- a = dtInt();
- } else if(cConsumeTokenIf(T_LESS_EQUAL)) {
- cAddTypeOperation(&a, cShift, &TYPED_LESS_EQUAL);
- a = dtInt();
- } else if(cConsumeTokenIf(T_GREATER)) {
- cAddTypeOperation(&a, cShift, &TYPED_GREATER);
- a = dtInt();
- } else if(cConsumeTokenIf(T_GREATER_EQUAL)) {
- cAddTypeOperation(&a, cShift, &TYPED_GREATER_EQUAL);
- a = dtInt();
- } else {
- return a;
- }
- }
- }
- static DataType cEqual(void) {
- DataType a = cComparison();
- while(true) {
- if(cConsumeTokenIf(T_EQUAL)) {
- cAddTypeOperation(&a, cComparison, &TYPED_EQUAL);
- a = dtInt();
- } else if(cConsumeTokenIf(T_NOT_EQUAL)) {
- cAddTypeOperation(&a, cComparison, &TYPED_NOT_EQUAL);
- a = dtInt();
- } else {
- return a;
- }
- }
- }
- static DataType cRepeat(Token t, Parser f, const TypedOp* op) {
- DataType a = f();
- while(cConsumeTokenIf(t)) {
- cAddTypeOperation(&a, f, op);
- }
- return a;
- }
- static DataType cBitAnd(void) {
- return cRepeat(T_BIT_AND, cEqual, &TYPED_BIT_AND);
- }
- static DataType cBitXor(void) {
- return cRepeat(T_BIT_XOR, cBitAnd, &TYPED_BIT_XOR);
- }
- static DataType cBitOr(void) {
- return cRepeat(T_BIT_OR, cBitXor, &TYPED_BIT_OR);
- }
- static DataType cLogical(Parser f, Token t, Operation jump, Operation op) {
- DataType a = f();
- while(cConsumeTokenIf(t)) {
- cAddOperation(jump);
- int32 p = cReserveInt32();
- DataType b = f();
- if(!dtIsInt(a) || !dtIsInt(b)) {
- cInvalidOperation(a, b, tGetName(t));
- }
- cAddOperation(op);
- cSetInt32(p, code->length);
- }
- return a;
- }
- static DataType cAnd(void) {
- return cLogical(cBitOr, T_AND, OP_PEEK_FALSE_GOTO, OP_AND);
- }
- static DataType cExpression(void) {
- return cLogical(cAnd, T_OR, OP_PEEK_TRUE_GOTO, OP_OR);
- }
- static void cLine(void);
- static void cConsumeBody(void) {
- int16 oldLine = line;
- while(!cConsumeTokenIf(T_CLOSE_CURVED_BRACKET)) {
- if(tPeekToken() == T_END) {
- line = oldLine;
- cError("non closed curved bracket");
- }
- cLine();
- }
- }
- static void cConsumeScope(void) {
- Scope scope;
- vsEnterScope(&vars, &scope);
- cConsumeBody();
- vsLeaveScope(&vars, &scope);
- }
- static void cAddReturn(Operation op) {
- if(returnIndex >= RETURN_BUFFER) {
- cError("too much returns in function");
- }
- cAddOperation(op);
- returns[returnIndex++] = cReserveInt32();
- }
- static void cReturn(void) {
- if(dtIsVoid(returnType)) {
- cConsumeToken(T_SEMICOLON);
- cAddReturn(OP_RETURN);
- hasReturn = 2;
- return;
- }
- DataType dt = cUnpackedExpression();
- if(!dtCompare(returnType, dt)) {
- cError("wrong return type, should be %s", cGetName(returnType));
- } else if(dtIsInt(dt)) {
- cAddReturn(OP_RETURN_INT);
- } else if(dtIsFloat(dt)) {
- cAddReturn(OP_RETURN_FLOAT);
- } else if(dtIsArray(dt)) {
- cAddReturn(OP_RETURN_POINTER);
- } else {
- cError("cannot return %s", cGetName(dt));
- }
- cConsumeToken(T_SEMICOLON);
- hasReturn = 2;
- }
- static void cIf(void) {
- cConsumeToken(T_OPEN_BRACKET);
- cExpectType(cExpression(), dtInt(), "if");
- cConsumeToken(T_CLOSE_BRACKET);
- cAddOperation(OP_IF_GOTO);
- int32 ifP = cReserveInt32();
- cConsumeToken(T_OPEN_CURVED_BRACKET);
- cConsumeScope();
- cSetInt32(ifP, code->length);
- if(cConsumeTokenIf(T_ELSE)) {
- cAddOperation(OP_GOTO);
- int32 elseP = cReserveInt32();
- cSetInt32(ifP, code->length);
- if(cConsumeTokenIf(T_IF)) {
- cIf();
- } else {
- cConsumeToken(T_OPEN_CURVED_BRACKET);
- cConsumeScope();
- }
- cSetInt32(elseP, code->length);
- }
- }
- static void cConsumeBreaks(int start, int address) {
- for(int i = start; i < breakIndex; i++) {
- cSetInt32(breaks[i], address);
- }
- breakIndex = start;
- }
- static void cWhile(void) {
- int start = code->length;
- cConsumeToken(T_OPEN_BRACKET);
- cExpectType(cExpression(), dtInt(), "while");
- cConsumeToken(T_CLOSE_BRACKET);
- cAddOperation(OP_IF_GOTO);
- int32 ifP = cReserveInt32();
- int breakStart = breakIndex;
- forWhileStack++;
- int oldContinue = continueAt;
- continueAt = start;
- cConsumeToken(T_OPEN_CURVED_BRACKET);
- cConsumeScope();
- continueAt = oldContinue;
- forWhileStack--;
- cAddInt32Operation(OP_GOTO, start);
- cSetInt32(ifP, code->length);
- cConsumeBreaks(breakStart, code->length);
- }
- static void cOperationSet(DataType left, const TypedOp* op) {
- cAddOperation(OP_DUPLICATE_REFERENCE);
- cLoadRef(left);
- cAddTypeOperation(&left, cUnpackedExpression, op);
- cStore(left, left, "=");
- }
- static void cSetVariable(void) {
- onLine = true;
- DataType dt = cPreUnary();
- onLine = false;
- if(dtIsVoid(dt)) {
- return;
- }
- cRemoveReference(&dt, "setter");
- Token t = cReadTokenAndLine();
- switch(t) {
- case T_SET: cStore(dt, cUnpackedExpression(), "="); break;
- case T_ADD_SET: cOperationSet(dt, &TYPED_ADD); break;
- case T_SUB_SET: cOperationSet(dt, &TYPED_SUB); break;
- case T_MUL_SET: cOperationSet(dt, &TYPED_MUL); break;
- case T_DIV_SET: cOperationSet(dt, &TYPED_DIV); break;
- case T_MOD_SET: cOperationSet(dt, &TYPED_MOD); break;
- case T_BIT_AND_SET: cOperationSet(dt, &TYPED_BIT_AND); break;
- case T_BIT_OR_SET: cOperationSet(dt, &TYPED_BIT_OR); break;
- case T_BIT_XOR_SET: cOperationSet(dt, &TYPED_BIT_XOR); break;
- case T_LEFT_SHIFT_SET: cOperationSet(dt, &TYPED_LEFT_SHIFT); break;
- case T_RIGHT_SHIFT_SET: cOperationSet(dt, &TYPED_RIGHT_SHIFT); break;
- default: cUnexpectedToken(t);
- }
- }
- static void cDeclareSet(Variables* vs, DataType dt, const char* var,
- Operation op) {
- if(vsInScope(vs, var)) {
- cDeclared(var);
- }
- Variable* v = vsAdd(vs, var, dt, &structs);
- if(dt.type != DT_STRUCT || dtIsArray(dt)) {
- cConsumeToken(T_SET);
- cAddInt32Operation(op, v->address);
- DataType right = cUnpackedExpression();
- cStore(dt, right, "=");
- }
- }
- static bool cDeclaration(Token t) {
- DataType dt = cReadExtendedType(t, false);
- if(dtIsVoid(dt)) {
- return false;
- }
- cConsumeToken(T_LITERAL);
- const char* var = cReadString();
- cDeclareSet(&vars, dt, var, OP_DEREFERENCE_VAR);
- return true;
- }
- static void cLineExpression(void) {
- int marker = tGetMarker();
- Token t = cReadTokenAndLine();
- if(cDeclaration(t)) {
- return;
- }
- tReset(marker);
- cSetVariable();
- }
- static void cFor(void) {
- Scope scope;
- vsEnterScope(&vars, &scope);
- cConsumeToken(T_OPEN_BRACKET);
- cLineExpression();
- cConsumeToken(T_SEMICOLON);
- int startCheck = code->length;
- cExpectType(cExpression(), dtInt(), "for");
- cConsumeToken(T_SEMICOLON);
- cAddOperation(OP_IF_GOTO);
- int32 end = cReserveInt32();
- cAddOperation(OP_GOTO);
- int32 beginBody = cReserveInt32();
- int startPerLoop = code->length;
- cLineExpression();
- cAddInt32Operation(OP_GOTO, startCheck);
- cConsumeToken(T_CLOSE_BRACKET);
- cSetInt32(beginBody, code->length);
- int breakStart = breakIndex;
- forWhileStack++;
- int oldContinue = continueAt;
- continueAt = startPerLoop;
- cConsumeToken(T_OPEN_CURVED_BRACKET);
- cConsumeBody();
- continueAt = oldContinue;
- forWhileStack--;
- cAddInt32Operation(OP_GOTO, startPerLoop);
- cSetInt32(end, code->length);
- cConsumeBreaks(breakStart, code->length);
- vsLeaveScope(&vars, &scope);
- }
- static void cBreak(void) {
- if(forWhileStack == 0) {
- cError("break without for or while");
- } else if(breakIndex >= BREAK_BUFFER) {
- cError("too much breaks");
- }
- cAddOperation(OP_GOTO);
- breaks[breakIndex++] = cReserveInt32();
- cConsumeToken(T_SEMICOLON);
- }
- static void cContinue(void) {
- if(forWhileStack == 0) {
- cError("continue without for or while");
- }
- cAddInt32Operation(OP_GOTO, continueAt);
- cConsumeToken(T_SEMICOLON);
- }
- static void cLine(void) {
- int marker = tGetMarker();
- Token t = cReadTokenAndLine();
- cAddLine(line);
- switch(t) {
- case T_OPEN_CURVED_BRACKET: cConsumeScope(); break;
- case T_RETURN: cReturn(); break;
- case T_IF: cIf(); break;
- case T_WHILE: cWhile(); break;
- case T_FOR: cFor(); break;
- case T_BREAK: cBreak(); break;
- case T_CONTINUE: cContinue(); break;
- default:
- tReset(marker);
- cLineExpression();
- cConsumeToken(T_SEMICOLON);
- }
- }
- static void cBuildFunction(Function* f, DataType rType, const char* fName) {
- if(rType.type == DT_STRUCT && rType.array == 0) {
- cError("structs cannot be returned");
- }
- fInit(f, fName, line);
- f->returnType = rType;
- vsReset(&vars);
- cConsumeToken(T_OPEN_BRACKET);
- if(cConsumeTokenIf(T_CLOSE_BRACKET)) {
- return;
- }
- while(true) {
- DataType dt = cReadExtendedType(cReadTokenAndLine(), true);
- cConsumeToken(T_LITERAL);
- const char* name = cReadString();
- if(vsInScope(&vars, name)) {
- cDeclared(name);
- }
- if(dt.type == DT_STRUCT) {
- dt = dtToPointer(dt);
- }
- vsAdd(&vars, name, dt, &structs);
- if(fAddArgument(f, dt, &structs)) {
- cTooMuchArguments();
- } else if(cConsumeTokenIf(T_CLOSE_BRACKET)) {
- return;
- }
- cConsumeToken(T_COMMA);
- }
- }
- static void cAddFunction(Function* found, Function* f) {
- if(found == NULL) {
- fsAdd(&functions, f);
- } else if(found->global) {
- cError("system functions cannot be overwritten");
- } else if(found->address != -1 || f->address == -1 || found->global) {
- cError("function registered twice");
- } else if(!dtCompare(found->returnType, f->returnType)) {
- cError("function redeclared with different return type");
- } else {
- found->address = f->address;
- }
- }
- static void cInnerFunction(Function* f) {
- cConsumeToken(T_OPEN_CURVED_BRACKET);
- cAddOperation(OP_RESERVE);
- int32 p = cReserveInt32();
- cAddInt32(f->size);
- returnIndex = 0;
- cConsumeScope();
- if(!dtIsVoid(returnType) && hasReturn <= 0) {
- cError("missing return");
- }
- cAddInt32Operation(OP_RETURN, vars.maxAddress);
- cSetInt32(p, vars.maxAddress);
- for(int i = 0; i < returnIndex; i++) {
- cSetInt32(returns[i], vars.maxAddress);
- }
- returnIndex = 0;
- }
- static void cFunction(DataType rType, const char* name) {
- Function f;
- cBuildFunction(&f, rType, name);
- Function* found = fsSearch(&functions, &f);
- if(cConsumeTokenIf(T_SEMICOLON)) {
- cAddFunction(found, &f);
- return;
- }
- cAddLine(line);
- cAddOperation(OP_GOTO);
- int32 end = cReserveInt32();
- f.address = code->length;
- cAddFunction(found, &f);
- returnType = rType;
- cInnerFunction(&f);
- cSetInt32(end, code->length);
- }
- static void cStruct(void) {
- cConsumeToken(T_LITERAL);
- const char* name = cReadString();
- if(stsSearch(&structs, name) != NULL) {
- cError("struct '%s' registered twice", name);
- }
- Struct* st = stsAdd(&structs, name);
- DataType self = dtStruct(st);
- cConsumeToken(T_OPEN_CURVED_BRACKET);
- while(!cConsumeTokenIf(T_CLOSE_CURVED_BRACKET)) {
- DataType dt = cReadExtendedType(cReadTokenAndLine(), true);
- if(dtCompare(dt, self)) {
- cError("struct %s contains itself", name);
- }
- cConsumeToken(T_LITERAL);
- stAddVariable(st, cReadString(), dt);
- cConsumeToken(T_SEMICOLON);
- }
- cConsumeToken(T_SEMICOLON);
- }
- static void cGlobalScope(Token t) {
- if(t == T_OPEN_PATH) {
- path = cReadString();
- // printf("OPEN PATH %s\n", path);
- return;
- } else if(t == T_CLOSE_PATH) {
- path = cReadString();
- // printf("CLOSE OLD PATH - OPEN PATH %s\n", path);
- return;
- } else if(t == T_STRUCT) {
- cStruct();
- return;
- }
- DataType dt = dtVoid();
- if(t != T_VOID) {
- dt = cReadExtendedType(t, true);
- }
- cConsumeToken(T_LITERAL);
- const char* name = cReadString();
- if(tPeekToken() == T_OPEN_BRACKET) {
- cFunction(dt, name);
- return;
- }
- cDeclareSet(&globalVars, dt, name, OP_DEREFERENCE_GVAR);
- cConsumeToken(T_SEMICOLON);
- }
- static void cCallMain(void) {
- Function f;
- fInit(&f, "main", line);
- Function* found = fsSearch(&functions, &f);
- if(found != NULL && dtIsVoid(found->returnType)) {
- cAddInt32Operation(OP_PUSH_INT, 0);
- cAddInt32Operation(OP_GOSUB, found->address);
- cAddInt32(found->size);
- }
- }
- static void cForEachLine(void) {
- cAddOperation(OP_GRESERVE);
- int p = cReserveInt32();
- while(true) {
- Token t = cReadTokenAndLine();
- if(t == T_END) {
- break;
- }
- cGlobalScope(t);
- }
- cCallMain();
- cSetInt32(p, globalVars.maxAddress);
- cAddInt32Operation(OP_GRESERVE, -globalVars.maxAddress);
- }
- static void cLinkQueuedFunctions(void) {
- for(int i = 0; i < functionQueue.entries; i++) {
- Function* f = functionQueue.data + i;
- Function* found = fsSearch(&functions, f);
- if(found == NULL || found->address == -1) {
- line = f->line;
- cUnknownFunction(f);
- }
- cSetInt32(f->address, found->address);
- }
- }
- static void cAllocAndCompile(void) {
- forWhileStack = 0;
- breakIndex = 0;
- returnType = dtVoid();
- onLine = false;
- vsInit(&vars);
- vsInit(&globalVars);
- fsInit(&functions);
- fsInit(&functionQueue);
- stsInit(&structs);
- if(!setjmp(errorJump)) {
- cForEachLine();
- cLinkQueuedFunctions();
- }
- stsDelete(&structs);
- fsDelete(&functionQueue);
- fsDelete(&functions);
- vsDelete(&globalVars);
- vsDelete(&vars);
- }
- ByteCode* cCompile(Error* e) {
- error = e;
- eInitSuccess(e);
- code = bcInit();
- cAllocAndCompile();
- if(eHasError(e)) {
- bcDelete(code);
- return NULL;
- }
- return code;
- }
|