123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200 |
- #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"
- #define ERROR_LENGTH 256
- #define RETURN_BUFFER 16
- #define BREAK_BUFFER 32
- #define DT_OPERATION(op) \
- case DT_INT: cAddOperation(OP_##op##_INT); break; \
- case DT_BOOL: cAddOperation(OP_##op##_BOOL); break; \
- case DT_FLOAT: cAddOperation(OP_##op##_FLOAT); break;
- static jmp_buf errorJump;
- static char error[ERROR_LENGTH] = {'\0'};
- static ByteCode* code;
- static int16 line = 1;
- static bool onLine = false;
- static Variables vars;
- 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 {
- Operation intOp;
- Operation floatOp;
- Operation boolOp;
- Operation pointerOp;
- const char* name;
- } TypedOp;
- static const TypedOp TYPED_MUL = {OP_MUL_INT, OP_MUL_FLOAT, OP_NOTHING,
- OP_NOTHING, "*"};
- static const TypedOp TYPED_DIV = {OP_DIV_INT, OP_DIV_FLOAT, OP_NOTHING,
- OP_NOTHING, "/"};
- static const TypedOp TYPED_MOD = {OP_MOD_INT, OP_NOTHING, OP_NOTHING,
- OP_NOTHING, "%"};
- static const TypedOp TYPED_ADD = {OP_ADD_INT, OP_ADD_FLOAT, OP_NOTHING,
- OP_NOTHING, "+"};
- static const TypedOp TYPED_SUB = {OP_SUB_INT, OP_SUB_FLOAT, OP_NOTHING,
- OP_NOTHING, "-"};
- static const TypedOp TYPED_LESS = {OP_LESS_INT, OP_LESS_FLOAT, OP_NOTHING,
- OP_NOTHING, "<"};
- static const TypedOp TYPED_LESS_EQUAL = {OP_GREATER_INT, OP_GREATER_FLOAT,
- OP_NOTHING, OP_NOTHING, "<="};
- static const TypedOp TYPED_GREATER = {OP_GREATER_INT, OP_GREATER_FLOAT,
- OP_NOTHING, OP_NOTHING, ">"};
- static const TypedOp TYPED_GREATER_EQUAL = {OP_LESS_INT, OP_LESS_FLOAT,
- OP_NOTHING, OP_NOTHING, ">="};
- static const TypedOp TYPED_EQUAL = {OP_EQUAL_INT, OP_EQUAL_FLOAT, OP_EQUAL_BOOL,
- OP_EQUAL_POINTER, "=="};
- static const TypedOp TYPED_NOT_EQUAL = {OP_EQUAL_INT, OP_EQUAL_FLOAT,
- OP_EQUAL_BOOL, OP_EQUAL_POINTER, "!="};
- static const TypedOp TYPED_BIT_OR = {OP_BIT_OR, OP_NOTHING, OP_NOTHING,
- OP_NOTHING, "|"};
- static const TypedOp TYPED_BIT_XOR = {OP_BIT_XOR, OP_NOTHING, OP_NOTHING,
- OP_NOTHING, "^"};
- static const TypedOp TYPED_BIT_AND = {OP_BIT_AND, OP_NOTHING, OP_NOTHING,
- OP_NOTHING, "&"};
- static const TypedOp TYPED_LEFT_SHIFT = {OP_LEFT_SHIFT, OP_NOTHING, OP_NOTHING,
- OP_NOTHING, "<<"};
- static const TypedOp TYPED_RIGHT_SHIFT = {OP_RIGHT_SHIFT, OP_NOTHING,
- OP_NOTHING, OP_NOTHING, ">>"};
- static void cError(const char* format, ...) {
- va_list args;
- va_start(args, format);
- vsnprintf(error, ERROR_LENGTH, 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() {
- cError("too much function arguments");
- }
- static void cUnexpectedToken(Token t) {
- cError("unexpected token on line %d: %s", line, tGetName(t));
- }
- static void cAddOperation(Operation token) {
- unsigned char c = token;
- bcAddBytes(code, &c, 1);
- }
- static int cReserveInt() {
- return bcReserveBytes(code, sizeof(int));
- }
- static void cSetInt(int p, int i) {
- bcSetBytes(code, p, &i, sizeof(int));
- }
- static void cAddInt(int i) {
- bcAddBytes(code, &i, sizeof(int));
- }
- static void cAddIntOperation(Operation token, int i) {
- cAddOperation(token);
- cAddInt(i);
- }
- static void cAddByteOperation(Operation token, char c) {
- cAddOperation(token);
- bcAddBytes(code, &c, sizeof(char));
- }
- static void cAddInt16(int16 i) {
- bcAddBytes(code, &i, sizeof(int16));
- }
- static Token cReadTokenAndLine() {
- hasReturn--;
- Token t = tReadToken();
- if(tReadInt16(&line)) {
- return t;
- }
- return T_END;
- }
- static void cConsumeToken(Token wanted) {
- Token t = cReadTokenAndLine();
- if(wanted != t) {
- cError("unexpected token on line %d: expected '%s' got '%s'", line,
- tGetName(wanted), tGetName(t));
- }
- }
- static bool cConsumeTokenIf(Token t) {
- if(tPeekToken() == t) {
- cReadTokenAndLine();
- return true;
- }
- return false;
- }
- static void cConstantInt() {
- int value;
- if(!tReadInt(&value)) {
- cError("int token without an int on line %d", line);
- }
- cAddIntOperation(OP_PUSH_INT, value);
- }
- static void cConstantFloat() {
- float value;
- if(!tReadFloat(&value)) {
- cError("float token without a float on line %d", line);
- }
- cAddOperation(OP_PUSH_FLOAT);
- bcAddBytes(code, &value, sizeof(float));
- }
- static const char* cReadString() {
- int length;
- const char* literal = tReadString(&length);
- if(literal == NULL) {
- cError("literal without string on line %d", line);
- }
- return literal;
- }
- static DataType cExpression();
- static void cLoadRef(DataType type) {
- if(dtIsPointer(type)) {
- cAddOperation(OP_REFERENCE);
- return;
- }
- switch(type.type) {
- DT_OPERATION(LOAD);
- case DT_STRUCT:
- {
- Struct* st = dtGetStruct(&structs, type);
- if(st == NULL) {
- cError("compiler struct error");
- }
- cAddIntOperation(OP_LOAD, dtGetSize(type, &structs));
- break;
- }
- default: cError("cannot load type %s", cGetName(type));
- }
- }
- static DataType cUnpack(DataType dt) {
- if(dtRemoveVariable(&dt)) {
- cLoadRef(dt);
- }
- return dt;
- }
- static DataType cUnpackedExpression() {
- return cUnpack(cExpression());
- }
- static void cCallFunctionArguments(Function* f) {
- while(!cConsumeTokenIf(T_CLOSE_BRACKET)) {
- DataType dt = cUnpackedExpression();
- if(fAddArgument(f, dt, &structs)) {
- cTooMuchArguments();
- }
- if(cConsumeTokenIf(T_COMMA) && tPeekToken() == T_CLOSE_BRACKET) {
- cUnexpectedToken(tPeekToken());
- }
- }
- }
- static DataType cCallFunction(const char* name) {
- cAddIntOperation(OP_PUSH_INT, 0);
- Function f;
- fInit(&f, name, line);
- cCallFunctionArguments(&f);
- cAddOperation(OP_GOSUB);
- Function* found = fsSearch(&functions, &f);
- if(found == NULL) {
- cError("unknown function");
- }
- if(found->address == -1) {
- f.returnType = found->returnType;
- f.address = cReserveInt();
- fsAdd(&functionQueue, &f);
- } else {
- cAddInt(found->address);
- }
- cAddInt(found->size);
- return found->returnType;
- }
- static void cStore(DataType left, DataType right, const char* name) {
- if(!dtCompare(left, right)) {
- cInvalidOperation(left, right, name);
- }
- if(dtIsPointer(left)) {
- cAddOperation(OP_STORE_POINTER);
- return;
- }
- switch(left.type) {
- DT_OPERATION(STORE);
- default: cError("cannot store type %s", cGetName(left));
- }
- }
- static DataType cLiteral() {
- const char* literal = cReadString();
- if(cConsumeTokenIf(T_OPEN_BRACKET)) {
- return cCallFunction(literal);
- }
- Variable v;
- if(vsSearch(&vars, &v, literal)) {
- cNotDeclared(literal);
- }
- cAddIntOperation(OP_DEREFERENCE_VAR, v.address);
- return dtToVariable(v.type);
- }
- static DataType cBracketPrimary() {
- DataType result = cExpression();
- cConsumeToken(T_CLOSE_BRACKET);
- return result;
- }
- static DataType cExtendType(DataType dt) {
- while(cConsumeTokenIf(T_MUL)) {
- dt = dtDereference(dt);
- }
- return dt;
- }
- static DataType cReadType() {
- DataType dt = dtVoid();
- Token t = cReadTokenAndLine();
- switch(t) {
- case T_INT: dt = dtInt(); break;
- case T_BOOL: dt = dtBool(); break;
- case T_FLOAT: dt = dtFloat(); break;
- case T_LITERAL:
- {
- const char* name = cReadString();
- Struct* st = stsSearch(&structs, name);
- if(st == NULL) {
- cError("struct %s does not exist");
- }
- dt = dtStruct(st);
- break;
- }
- default: cUnexpectedToken(t);
- }
- return cExtendType(dt);
- }
- static DataType cAllocArray() {
- DataType dt = cReadType();
- cConsumeToken(T_OPEN_SQUARE_BRACKET);
- DataType index = cUnpackedExpression();
- if(!dtCompare(index, dtInt())) {
- cError("array size must be an int");
- }
- cConsumeToken(T_CLOSE_SQUARE_BRACKET);
- cAddIntOperation(OP_NEW, dtGetSize(dt, &structs));
- return dtDereference(dt);
- }
- static DataType cLength() {
- DataType pointer = cUnpackedExpression();
- if(!dtIsPointer(pointer)) {
- cError("length expects a pointer");
- }
- cAddOperation(OP_LENGTH);
- return dtInt();
- }
- static DataType cPrimary() {
- Token t = cReadTokenAndLine();
- switch(t) {
- case T_CONST_INT: cConstantInt(); return dtInt();
- case T_CONST_FLOAT: cConstantFloat(); return dtFloat();
- case T_TRUE: cAddOperation(OP_PUSH_TRUE); return dtBool();
- case T_FALSE: cAddOperation(OP_PUSH_FALSE); return dtBool();
- 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 cPostChange(DataType* dt, int change, const char* name) {
- if(!dtRemoveVariable(dt) || !dtCompare(*dt, dtInt())) {
- cError("%s needs an int reference", name);
- } else if(onLine) {
- cAddByteOperation(OP_INT_CHANGE, change);
- *dt = dtVoid();
- } else {
- cAddByteOperation(OP_PUSH_POST_INT_CHANGE, change);
- }
- }
- static DataType cStructAccess(DataType dt, int pointers) {
- Struct* st = dtGetStruct(&structs, dt);
- if(st == NULL || dt.pointers != pointers) {
- cError(pointers == 0 ? ". expects a struct" : "-> expects a struct*");
- }
- cConsumeToken(T_LITERAL);
- const char* name = cReadString();
- Variable inner;
- if(vSearchStruct(&inner, &structs, st, name)) {
- cError("%s has no member %s", st->name, name);
- }
- if(inner.address > 0) {
- cAddIntOperation(OP_PUSH_INT, inner.address);
- cAddOperation(OP_ADD_REFERENCE);
- }
- return dtToVariable(inner.type);
- }
- static DataType cAccess() {
- 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)) {
- if(!dtRemoveVariable(&dt)) {
- cError(". expects a reference");
- }
- dt = cStructAccess(dt, 0);
- } else if(cConsumeTokenIf(T_ARROW)) {
- dt = cStructAccess(cUnpack(dt), 1);
- } else if(cConsumeTokenIf(T_OPEN_SQUARE_BRACKET)) {
- dt = cUnpack(dt);
- if(!dtIsPointer(dt)) {
- cError("[] needs a pointer");
- }
- DataType index = cUnpackedExpression();
- if(!dtCompare(index, dtInt())) {
- cError("array index must be an int");
- }
- cConsumeToken(T_CLOSE_SQUARE_BRACKET);
- cAddOperation(OP_ADD_REFERENCE);
- dt = dtToVariable(dtReference(dt));
- } else {
- break;
- }
- }
- return dt;
- }
- static DataType cPreChange(DataType dt, int change, const char* name) {
- if(!dtRemoveVariable(&dt) || !dtCompare(dt, dtInt())) {
- cError("%s needs an int reference", name);
- }
- if(onLine) {
- cAddByteOperation(OP_INT_CHANGE, change);
- return dtVoid();
- }
- cAddByteOperation(OP_PUSH_PRE_INT_CHANGE, change);
- return dt;
- }
- static DataType cPreUnary() {
- if(cConsumeTokenIf(T_INCREMENT)) {
- return cPreChange(cPreUnary(), 1, "++");
- } else if(cConsumeTokenIf(T_DECREMENT)) {
- return cPreChange(cPreUnary(), -1, "--");
- } else if(cConsumeTokenIf(T_SUB)) {
- DataType dt = cUnpack(cPreUnary());
- if(dtCompare(dt, dtInt())) {
- cAddOperation(OP_INVERT_SIGN_INT);
- } else if(dtCompare(dt, dtFloat())) {
- cAddOperation(OP_INVERT_SIGN_FLOAT);
- } else {
- cError("cannot invert sign of %s", cGetName(dt));
- }
- return dt;
- } else if(cConsumeTokenIf(T_NOT)) {
- DataType dt = cPreUnary();
- if(!dtCompare(dt, dtBool())) {
- cError("! needs a bool not %s", cGetName(dt));
- }
- cAddOperation(OP_NOT);
- return dt;
- } else if(cConsumeTokenIf(T_BIT_NOT)) {
- DataType dt = cPreUnary();
- if(!dtCompare(dt, dtInt())) {
- cError("~ needs an int not %s", cGetName(dt));
- }
- cAddOperation(OP_BIT_NOT);
- return dt;
- } else if(cConsumeTokenIf(T_BIT_AND)) {
- DataType dt = cPreUnary();
- if(!dtRemoveVariable(&dt)) {
- cError("& needs a reference");
- }
- return dtDereference(dt);
- } else if(cConsumeTokenIf(T_MUL)) {
- DataType dt = cPreUnary();
- if(!dtIsPointer(dt)) {
- cError("* expects a pointer");
- }
- dt = dtReference(dt);
- if(!dtIsPointer(dt) && !dtIsVariable(dt)) {
- dt = dtToVariable(dt);
- } else {
- cAddOperation(OP_REFERENCE);
- }
- return dt;
- }
- return cAccess();
- }
- static void cAddTypeOperation(DataType a, DataType b, const TypedOp* op) {
- if(dtCompare(a, dtInt()) && dtCompare(b, dtInt()) &&
- op->intOp != OP_NOTHING) {
- cAddOperation(op->intOp);
- } else if(dtCompare(a, dtFloat()) && dtCompare(b, dtFloat()) &&
- op->floatOp != OP_NOTHING) {
- cAddOperation(op->floatOp);
- } else if(dtCompare(a, dtBool()) && dtCompare(b, dtBool()) &&
- op->boolOp != OP_NOTHING) {
- cAddOperation(op->boolOp);
- } else if(dtCompare(a, b) && dtIsPointer(a) &&
- op->pointerOp != OP_NOTHING) {
- cAddOperation(op->pointerOp);
- } else {
- cInvalidOperation(a, b, op->name);
- }
- }
- static DataType cMul() {
- DataType a = cPreUnary();
- while(true) {
- if(cConsumeTokenIf(T_MUL)) {
- a = cUnpack(a);
- cAddTypeOperation(a, cUnpack(cPreUnary()), &TYPED_MUL);
- } else if(cConsumeTokenIf(T_DIV)) {
- a = cUnpack(a);
- cAddTypeOperation(a, cUnpack(cPreUnary()), &TYPED_DIV);
- } else if(cConsumeTokenIf(T_MOD)) {
- a = cUnpack(a);
- cAddTypeOperation(a, cUnpack(cPreUnary()), &TYPED_MOD);
- } else {
- break;
- }
- }
- return a;
- }
- static DataType cAdd() {
- DataType a = cMul();
- while(true) {
- if(cConsumeTokenIf(T_ADD)) {
- a = cUnpack(a);
- cAddTypeOperation(a, cUnpack(cMul()), &TYPED_ADD);
- } else if(cConsumeTokenIf(T_SUB)) {
- a = cUnpack(a);
- cAddTypeOperation(a, cUnpack(cMul()), &TYPED_SUB);
- } else {
- break;
- }
- }
- return a;
- }
- static DataType cShift() {
- DataType a = cAdd();
- while(true) {
- if(cConsumeTokenIf(T_LEFT_SHIFT)) {
- a = cUnpack(a);
- cAddTypeOperation(a, cUnpack(cAdd()), &TYPED_LEFT_SHIFT);
- } else if(cConsumeTokenIf(T_RIGHT_SHIFT)) {
- a = cUnpack(a);
- cAddTypeOperation(a, cUnpack(cAdd()), &TYPED_RIGHT_SHIFT);
- } else {
- break;
- }
- }
- return a;
- }
- static DataType cComparison() {
- DataType a = cShift();
- while(true) {
- if(cConsumeTokenIf(T_LESS)) {
- a = cUnpack(a);
- cAddTypeOperation(a, cUnpack(cShift()), &TYPED_LESS);
- a = dtBool();
- } else if(cConsumeTokenIf(T_LESS_EQUAL)) {
- a = cUnpack(a);
- cAddTypeOperation(a, cUnpack(cShift()), &TYPED_LESS_EQUAL);
- cAddOperation(OP_NOT);
- a = dtBool();
- } else if(cConsumeTokenIf(T_GREATER)) {
- a = cUnpack(a);
- cAddTypeOperation(a, cUnpack(cShift()), &TYPED_GREATER);
- a = dtBool();
- } else if(cConsumeTokenIf(T_GREATER_EQUAL)) {
- a = cUnpack(a);
- cAddTypeOperation(a, cUnpack(cShift()), &TYPED_GREATER_EQUAL);
- cAddOperation(OP_NOT);
- a = dtBool();
- } else {
- break;
- }
- }
- return a;
- }
- static DataType cEqual() {
- DataType a = cComparison();
- while(true) {
- if(cConsumeTokenIf(T_EQUAL)) {
- a = cUnpack(a);
- cAddTypeOperation(a, cUnpack(cComparison()), &TYPED_EQUAL);
- a = dtBool();
- } else if(cConsumeTokenIf(T_NOT_EQUAL)) {
- a = cUnpack(a);
- cAddTypeOperation(a, cUnpack(cComparison()), &TYPED_NOT_EQUAL);
- cAddOperation(OP_NOT);
- a = dtBool();
- } else {
- break;
- }
- }
- return a;
- }
- static DataType cBitAnd() {
- DataType a = cEqual();
- while(cConsumeTokenIf(T_BIT_AND)) {
- a = cUnpack(a);
- cAddTypeOperation(a, cUnpack(cEqual()), &TYPED_BIT_AND);
- }
- return a;
- }
- static DataType cBitXor() {
- DataType a = cBitAnd();
- while(cConsumeTokenIf(T_BIT_XOR)) {
- a = cUnpack(a);
- cAddTypeOperation(a, cUnpack(cBitAnd()), &TYPED_BIT_XOR);
- }
- return a;
- }
- static DataType cBitOr() {
- DataType a = cBitXor();
- while(cConsumeTokenIf(T_BIT_OR)) {
- a = cUnpack(a);
- cAddTypeOperation(a, cUnpack(cBitXor()), &TYPED_BIT_OR);
- }
- return a;
- }
- static DataType cAnd() {
- DataType a = cBitOr();
- while(cConsumeTokenIf(T_AND)) {
- a = cUnpack(a);
- cAddOperation(OP_PEEK_FALSE_GOTO);
- int p = cReserveInt();
- DataType b = cUnpack(cBitOr());
- if(!dtCompare(a, dtBool()) || !dtCompare(b, dtBool())) {
- cInvalidOperation(a, b, "&&");
- }
- cAddOperation(OP_AND);
- cSetInt(p, code->length);
- }
- return a;
- }
- static DataType cOr() {
- DataType a = cAnd();
- while(cConsumeTokenIf(T_OR)) {
- a = cUnpack(a);
- cAddOperation(OP_PEEK_TRUE_GOTO);
- int p = cReserveInt();
- DataType b = cUnpack(cAnd());
- if(!dtCompare(a, dtBool()) || !dtCompare(b, dtBool())) {
- cInvalidOperation(a, b, "||");
- }
- cAddOperation(OP_OR);
- cSetInt(p, code->length);
- }
- return a;
- }
- static DataType cExpression() {
- return cOr();
- }
- static void cOperationSet(DataType left, const TypedOp* op) {
- cAddOperation(OP_DUPLICATE_REFERENCE);
- cLoadRef(left);
- DataType right = cUnpackedExpression();
- cAddTypeOperation(left, right, op);
- cStore(left, right, "=");
- }
- static void cAddPostLineChange(DataType dt, int change, const char* name) {
- if(!dtCompare(dt, dtInt())) {
- cError("%s needs an int", name);
- }
- cAddByteOperation(OP_INT_CHANGE, change);
- }
- static void cDeclareStruct(Struct* st) {
- DataType dt = cExtendType(dtStruct(st));
- cConsumeToken(T_LITERAL);
- const char* var = cReadString();
- if(vsInScope(&vars, var)) {
- cDeclared(var);
- }
- Variable* v = vsAdd(&vars, var, dt, &structs);
- if(dtIsPointer(dt)) {
- cConsumeToken(T_SET);
- cAddIntOperation(OP_DEREFERENCE_VAR, v->address);
- cStore(v->type, cUnpackedExpression(), "=");
- }
- }
- static void cLine();
- static void cConsumeBody() {
- int oldLine = line;
- while(!cConsumeTokenIf(T_CLOSE_CURVED_BRACKET)) {
- if(tPeekToken() == T_END) {
- line = oldLine;
- cError("unexpected end of file: non closed curved bracket");
- }
- cLine();
- }
- }
- static void cConsumeScope() {
- Scope scope;
- vsEnterScope(&vars, &scope);
- cConsumeBody();
- vsLeaveScope(&vars, &scope);
- }
- static void cAddReturn(Operation op) {
- cAddOperation(op);
- returns[returnIndex++] = cReserveInt();
- }
- static void cReturn() {
- if(returnIndex >= RETURN_BUFFER) {
- cError("too much returns in function");
- }
- if(dtCompare(returnType, dtVoid())) {
- cConsumeToken(T_SEMICOLON);
- cAddReturn(OP_RETURN);
- hasReturn = 2;
- return;
- }
- DataType dt = cUnpackedExpression();
- if(!dtCompare(dt, returnType)) {
- cError("wrong return type, should be %s", cGetName(returnType));
- }
- if(dtCompare(dt, dtInt())) {
- cAddReturn(OP_RETURN_INT);
- } else if(dtCompare(dt, dtBool())) {
- cAddReturn(OP_RETURN_BOOL);
- } else if(dtCompare(dt, dtFloat())) {
- cAddReturn(OP_RETURN_FLOAT);
- } else {
- cError("cannot return %s", cGetName(dt));
- }
- cConsumeToken(T_SEMICOLON);
- hasReturn = 2;
- }
- static void cPrint() {
- DataType dt = cUnpackedExpression();
- if(dtIsPointer(dt)) {
- cAddOperation(OP_PRINT_POINTER);
- cConsumeToken(T_SEMICOLON);
- return;
- }
- switch(dt.type) {
- DT_OPERATION(PRINT);
- default: cError("cannot print type %s", cGetName(dt));
- }
- cConsumeToken(T_SEMICOLON);
- }
- static void cIf() {
- cConsumeToken(T_OPEN_BRACKET);
- DataType dt = cUnpackedExpression();
- if(!dtCompare(dt, dtBool())) {
- cError("if expects a bool not %s", cGetName(dt));
- }
- cConsumeToken(T_CLOSE_BRACKET);
- cAddOperation(OP_IF_GOTO);
- int ifP = cReserveInt();
- cConsumeToken(T_OPEN_CURVED_BRACKET);
- cConsumeScope();
- cSetInt(ifP, code->length);
- if(cConsumeTokenIf(T_ELSE)) {
- cAddOperation(OP_GOTO);
- int elseP = cReserveInt();
- cSetInt(ifP, code->length);
- if(cConsumeTokenIf(T_IF)) {
- cIf();
- } else {
- cConsumeToken(T_OPEN_CURVED_BRACKET);
- cConsumeScope();
- }
- cSetInt(elseP, code->length);
- }
- }
- static void cConsumeBreaks(int start, int address) {
- for(int i = start; i < breakIndex; i++) {
- cSetInt(breaks[i], address);
- }
- breakIndex = start;
- }
- static void cWhile() {
- int start = code->length;
- cConsumeToken(T_OPEN_BRACKET);
- DataType dt = cUnpackedExpression();
- if(!dtCompare(dt, dtBool())) {
- cError("while expects a bool not %s", cGetName(dt));
- }
- cConsumeToken(T_CLOSE_BRACKET);
- cAddOperation(OP_IF_GOTO);
- int ifP = cReserveInt();
- int breakStart = breakIndex;
- forWhileStack++;
- int oldContinue = continueAt;
- continueAt = start;
- cConsumeToken(T_OPEN_CURVED_BRACKET);
- cConsumeScope();
- continueAt = oldContinue;
- forWhileStack--;
- cAddIntOperation(OP_GOTO, start);
- cSetInt(ifP, code->length);
- cConsumeBreaks(breakStart, code->length);
- }
- static void cDeclare(DataType dt) {
- dt = cExtendType(dt);
- cConsumeToken(T_LITERAL);
- const char* var = cReadString();
- if(vsInScope(&vars, var)) {
- cDeclared(var);
- }
- Variable* v = vsAdd(&vars, var, dt, &structs);
- cConsumeToken(T_SET);
- cAddIntOperation(OP_DEREFERENCE_VAR, v->address);
- cStore(v->type, cUnpackedExpression(), "=");
- }
- static void cDelete() {
- DataType pointer = cUnpackedExpression();
- if(!dtIsPointer(pointer)) {
- cError("delete expects a pointer");
- }
- cAddOperation(OP_DELETE);
- }
- static void cSetVariable() {
- onLine = true;
- DataType dt = cPreUnary();
- onLine = false;
- if(dtCompare(dt, dtVoid())) {
- return;
- }
- if(!dtRemoveVariable(&dt)) {
- cError("return value not used: %s", cGetName(dt));
- }
- 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;
- case T_INCREMENT: cAddPostLineChange(dt, 1, "++"); break;
- case T_DECREMENT: cAddPostLineChange(dt, -1, "--"); break;
- default: cUnexpectedToken(t);
- }
- }
- static void cLineExpression() {
- int marker = tGetMarker();
- Token t = cReadTokenAndLine();
- if(t == T_LITERAL) {
- const char* literal = cReadString();
- Struct* st = stsSearch(&structs, literal);
- if(st != NULL) {
- cDeclareStruct(st);
- return;
- }
- }
- switch(t) {
- case T_INT: cDeclare(dtInt()); break;
- case T_BOOL: cDeclare(dtBool()); break;
- case T_FLOAT: cDeclare(dtFloat()); break;
- case T_DELETE: cDelete(); break;
- default: tReset(marker); cSetVariable();
- }
- }
- static void cFor() {
- Scope scope;
- vsEnterScope(&vars, &scope);
- cConsumeToken(T_OPEN_BRACKET);
- cLineExpression();
- cConsumeToken(T_SEMICOLON);
- int startCheck = code->length;
- DataType dt = cUnpackedExpression();
- if(!dtCompare(dt, dtBool())) {
- cError("for expects a bool not %s", cGetName(dt));
- }
- cConsumeToken(T_SEMICOLON);
- cAddOperation(OP_IF_GOTO);
- int end = cReserveInt();
- cAddOperation(OP_GOTO);
- int beginBody = cReserveInt();
- int startPerLoop = code->length;
- cLineExpression();
- cAddIntOperation(OP_GOTO, startCheck);
- cConsumeToken(T_CLOSE_BRACKET);
- cSetInt(beginBody, code->length);
- int breakStart = breakIndex;
- forWhileStack++;
- int oldContinue = continueAt;
- continueAt = startPerLoop;
- cConsumeToken(T_OPEN_CURVED_BRACKET);
- cConsumeBody();
- continueAt = oldContinue;
- forWhileStack--;
- cAddIntOperation(OP_GOTO, startPerLoop);
- cSetInt(end, code->length);
- cConsumeBreaks(breakStart, code->length);
- vsLeaveScope(&vars, &scope);
- }
- static void cBreak() {
- if(forWhileStack == 0) {
- cError("break without for or while on line %d", line);
- } else if(breakIndex >= BREAK_BUFFER) {
- cError("too much breaks around line %d", line);
- }
- cAddOperation(OP_GOTO);
- breaks[breakIndex++] = cReserveInt();
- cConsumeToken(T_SEMICOLON);
- }
- static void cContinue() {
- if(forWhileStack == 0) {
- cError("continue without for or while on line %d", line);
- }
- cAddIntOperation(OP_GOTO, continueAt);
- cConsumeToken(T_SEMICOLON);
- }
- static void cLine() {
- int marker = tGetMarker();
- Token t = cReadTokenAndLine();
- cAddOperation(OP_LINE);
- cAddInt16(line);
- switch(t) {
- case T_OPEN_CURVED_BRACKET: cConsumeScope(); break;
- case T_PRINT: cPrint(); 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 cFunctionArgument(Function* f);
- static void cFunctionCommaOrEnd(Function* f) {
- if(cConsumeTokenIf(T_CLOSE_BRACKET)) {
- return;
- }
- cConsumeToken(T_COMMA);
- cFunctionArgument(f);
- }
- static void cFunctionAddArgument(Function* f, DataType dt) {
- dt = cExtendType(dt);
- cConsumeToken(T_LITERAL);
- const char* name = cReadString();
- if(vsInScope(&vars, name)) {
- cDeclared(name);
- }
- vsAdd(&vars, name, dt, &structs);
- if(fAddArgument(f, dt, &structs)) {
- cTooMuchArguments();
- }
- cFunctionCommaOrEnd(f);
- }
- static void cFunctionArgument(Function* f) {
- Token t = cReadTokenAndLine();
- switch(t) {
- case T_INT: cFunctionAddArgument(f, dtInt()); break;
- case T_FLOAT: cFunctionAddArgument(f, dtFloat()); break;
- case T_BOOL: cFunctionAddArgument(f, dtBool()); break;
- case T_LITERAL:
- {
- const char* structName = cReadString();
- Struct* st = stsSearch(&structs, structName);
- if(st == NULL) {
- cError("struct %s does not exist");
- }
- cFunctionAddArgument(f, dtStruct(st));
- break;
- }
- default: cUnexpectedToken(t);
- }
- }
- static void cFunctionArguments(Function* f) {
- cConsumeToken(T_OPEN_BRACKET);
- if(!cConsumeTokenIf(T_CLOSE_BRACKET)) {
- cFunctionArgument(f);
- }
- }
- static int cReserve(int offset) {
- cAddOperation(OP_RESERVE);
- int p = cReserveInt();
- cAddInt(offset);
- return p;
- }
- static void cFree(int p, int bytes) {
- cAddIntOperation(OP_RETURN, bytes);
- cSetInt(p, bytes);
- }
- static void cLinkReturns(int bytes) {
- for(int i = 0; i < returnIndex; i++) {
- cSetInt(returns[i], bytes);
- }
- returnIndex = 0;
- }
- static void cInnerFunction(Function* f) {
- cConsumeToken(T_OPEN_CURVED_BRACKET);
- int p = cReserve(f->size);
- returnIndex = 0;
- cConsumeScope();
- if(!dtCompare(returnType, dtVoid()) && hasReturn <= 0) {
- cError("missing return");
- }
- cFree(p, vars.maxAddress);
- cLinkReturns(vars.maxAddress);
- }
- static bool cForwardFunction(Function* found, Function* f) {
- if(!cConsumeTokenIf(T_SEMICOLON)) {
- return false;
- } else if(found != NULL) {
- cError("function registered twice");
- }
- f->address = -1;
- fsAdd(&functions, f);
- return true;
- }
- static void cBuildFunction(Function* f, DataType rType) {
- cConsumeToken(T_LITERAL);
- fInit(f, cReadString(), line);
- f->returnType = rType;
- vsReset(&vars);
- cFunctionArguments(f);
- }
- static void cFunction(DataType rType) {
- Function f;
- cBuildFunction(&f, rType);
- Function* found = fsSearch(&functions, &f);
- if(cForwardFunction(found, &f)) {
- return;
- }
- cAddOperation(OP_LINE);
- cAddInt16(line);
- cAddOperation(OP_GOTO);
- int end = cReserveInt();
- f.address = code->length;
- if(found != NULL) {
- if(found->address == -1) {
- found->address = f.address;
- } else {
- cError("function registered twice");
- }
- } else {
- fsAdd(&functions, &f);
- }
- returnType = rType;
- cInnerFunction(&f);
- cSetInt(end, code->length);
- }
- static void cStruct() {
- cConsumeToken(T_LITERAL);
- const char* name = cReadString();
- if(stsSearch(&structs, name) != NULL) {
- cError("struct registered twice");
- }
- Struct* st = stsAdd(&structs, name);
- DataType self = dtStruct(st);
- cConsumeToken(T_OPEN_CURVED_BRACKET);
- while(!cConsumeTokenIf(T_CLOSE_CURVED_BRACKET)) {
- DataType dt = cReadType();
- if(dtCompare(dt, self)) {
- cError("struct %s contains itself", name);
- }
- cConsumeToken(T_LITERAL);
- const char* name = cReadString();
- stAddVariable(st, name, dt);
- cConsumeToken(T_SEMICOLON);
- }
- cConsumeToken(T_SEMICOLON);
- }
- static void cGlobalScope(Token t) {
- switch(t) {
- case T_VOID: cFunction(dtVoid()); break;
- case T_INT: cFunction(dtInt()); break;
- case T_BOOL: cFunction(dtBool()); break;
- case T_FLOAT: cFunction(dtFloat()); break;
- case T_STRUCT: cStruct(); break;
- default: cUnexpectedToken(t);
- }
- }
- static void cCallMain() {
- Function f;
- fInit(&f, "main", line);
- Function* found = fsSearch(&functions, &f);
- if(found != NULL && dtCompare(found->returnType, dtVoid())) {
- cAddIntOperation(OP_PUSH_INT, 0);
- cAddIntOperation(OP_GOSUB, found->address);
- cAddInt(found->size);
- }
- }
- static void cForEachLine() {
- Token t = cReadTokenAndLine();
- while(t != T_END) {
- cGlobalScope(t);
- t = cReadTokenAndLine();
- }
- cCallMain();
- }
- static void cLinkQueuedFunctions() {
- for(int i = 0; i < functionQueue.entries; i++) {
- Function* f = functionQueue.data + i;
- Function* found = fsSearch(&functions, f);
- if(found == NULL) {
- line = f->line;
- cError("unknown function");
- } else if(!dtCompare(f->returnType, found->returnType)) {
- line = f->line;
- cError("function return type is not %s", cGetName(f->returnType));
- }
- cSetInt(f->address, found->address);
- }
- }
- static void cAllocAndCompile() {
- forWhileStack = 0;
- breakIndex = 0;
- returnType = dtVoid();
- onLine = false;
- vsInit(&vars);
- fsInit(&functions);
- fsInit(&functionQueue);
- stsInit(&structs);
- if(!setjmp(errorJump)) {
- cForEachLine();
- cLinkQueuedFunctions();
- }
- stsDelete(&structs);
- fsDelete(&functionQueue);
- fsDelete(&functions);
- vsDelete(&vars);
- }
- ByteCode* cCompile() {
- error[0] = '\0';
- code = bcInit();
- cAllocAndCompile();
- if(error[0] != '\0') {
- bcDelete(code);
- return NULL;
- }
- return code;
- }
- const char* cGetError() {
- return error;
- }
- int cGetLine() {
- return line;
- }
|