Compiler.c 29 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061
  1. #include <setjmp.h>
  2. #include <stdarg.h>
  3. #include <stdio.h>
  4. #include <stdlib.h>
  5. #include <string.h>
  6. #include "Compiler.h"
  7. #include "DataType.h"
  8. #include "tokenizer/Tokenizer.h"
  9. #include "utils/Functions.h"
  10. #include "utils/Variables.h"
  11. #include "vm/Operation.h"
  12. #define ERROR_LENGTH 256
  13. #define RETURN_BUFFER 16
  14. #define BREAK_BUFFER 32
  15. #define DT_OPERATION(op) \
  16. case DT_INT: cAddOperation(OP_##op##_INT); break; \
  17. case DT_BOOL: cAddOperation(OP_##op##_BOOL); break; \
  18. case DT_FLOAT: cAddOperation(OP_##op##_FLOAT); break;
  19. typedef DataType (*Parser)(void);
  20. static jmp_buf errorJump;
  21. static char error[ERROR_LENGTH] = {'\0'};
  22. static ByteCode* code;
  23. static int16 line = 1;
  24. static bool onLine = false;
  25. static Variables vars;
  26. static Functions functions;
  27. static Functions functionQueue;
  28. static Structs structs;
  29. static int returns[RETURN_BUFFER];
  30. static int returnIndex = 0;
  31. static int hasReturn = 0;
  32. static DataType returnType;
  33. static int breaks[BREAK_BUFFER];
  34. static int breakIndex = 0;
  35. static int forWhileStack = 0;
  36. static int continueAt = 0;
  37. typedef struct {
  38. Operation intOp;
  39. Operation floatOp;
  40. Operation boolOp;
  41. Operation pointerOp;
  42. const char* name;
  43. } TypedOp;
  44. #define TYPE_OP(NAME, INT, FLOAT, BOOL, POINTER, text) \
  45. static const TypedOp TYPED_##NAME = {OP_##INT, OP_##FLOAT, OP_##BOOL, \
  46. OP_##POINTER, text};
  47. TYPE_OP(MUL, MUL_INT, MUL_FLOAT, NOTHING, NOTHING, "*")
  48. TYPE_OP(DIV, DIV_INT, DIV_FLOAT, NOTHING, NOTHING, "/")
  49. TYPE_OP(MOD, MOD_INT, NOTHING, NOTHING, NOTHING, "%")
  50. TYPE_OP(ADD, ADD_INT, ADD_FLOAT, NOTHING, NOTHING, "+")
  51. TYPE_OP(SUB, SUB_INT, SUB_FLOAT, NOTHING, NOTHING, "-")
  52. TYPE_OP(LESS, LESS_INT, LESS_FLOAT, NOTHING, NOTHING, "<")
  53. TYPE_OP(LESS_EQUAL, GREATER_INT, GREATER_FLOAT, NOTHING, NOTHING, "<=")
  54. TYPE_OP(GREATER, GREATER_INT, GREATER_FLOAT, NOTHING, NOTHING, ">")
  55. TYPE_OP(GREATER_EQUAL, LESS_INT, LESS_FLOAT, NOTHING, NOTHING, ">=")
  56. TYPE_OP(EQUAL, EQUAL_INT, EQUAL_FLOAT, EQUAL_BOOL, EQUAL_POINTER, "==")
  57. TYPE_OP(NOT_EQUAL, EQUAL_INT, EQUAL_FLOAT, EQUAL_BOOL, EQUAL_POINTER, "!=")
  58. TYPE_OP(BIT_OR, BIT_OR, NOTHING, NOTHING, NOTHING, "|")
  59. TYPE_OP(BIT_XOR, BIT_XOR, NOTHING, NOTHING, NOTHING, "^")
  60. TYPE_OP(BIT_AND, BIT_AND, NOTHING, NOTHING, NOTHING, "&")
  61. TYPE_OP(LEFT_SHIFT, LEFT_SHIFT, NOTHING, NOTHING, NOTHING, "<<")
  62. TYPE_OP(RIGHT_SHIFT, RIGHT_SHIFT, NOTHING, NOTHING, NOTHING, ">>")
  63. static void cError(const char* format, ...) {
  64. va_list args;
  65. va_start(args, format);
  66. vsnprintf(error, ERROR_LENGTH, format, args);
  67. va_end(args);
  68. longjmp(errorJump, 0);
  69. }
  70. static const char* cGetName(DataType dt) {
  71. return dtGetName(&structs, dt);
  72. }
  73. static void cInvalidOperation(DataType a, DataType b, const char* op) {
  74. cError("invalid operation: %s %s %s", cGetName(a), op, cGetName(b));
  75. }
  76. static void cNotDeclared(const char* name) {
  77. cError("variable %s has not been declared", name);
  78. }
  79. static void cDeclared(const char* name) {
  80. cError("%s has already been declared", name);
  81. }
  82. static void cTooMuchArguments() {
  83. cError("too much function arguments");
  84. }
  85. static void cUnexpectedToken(Token t) {
  86. cError("unexpected token on line %d: %s", line, tGetName(t));
  87. }
  88. static void cAddOperation(Operation token) {
  89. unsigned char c = token;
  90. bcAddBytes(code, &c, 1);
  91. }
  92. static int cReserveInt() {
  93. return bcReserveBytes(code, sizeof(int));
  94. }
  95. static void cSetInt(int p, int i) {
  96. bcSetBytes(code, p, &i, sizeof(int));
  97. }
  98. static void cAddInt(int i) {
  99. bcAddBytes(code, &i, sizeof(int));
  100. }
  101. static void cAddIntOperation(Operation token, int i) {
  102. cAddOperation(token);
  103. cAddInt(i);
  104. }
  105. static void cAddByteOperation(Operation token, char c) {
  106. cAddOperation(token);
  107. bcAddBytes(code, &c, sizeof(char));
  108. }
  109. static void cAddLine(int16 i) {
  110. cAddOperation(OP_LINE);
  111. bcAddBytes(code, &i, sizeof(int16));
  112. }
  113. static Token cReadTokenAndLine() {
  114. hasReturn--;
  115. Token t = tReadToken();
  116. if(tReadInt16(&line)) {
  117. return t;
  118. }
  119. return T_END;
  120. }
  121. static void cConsumeToken(Token wanted) {
  122. Token t = cReadTokenAndLine();
  123. if(wanted != t) {
  124. cError("expected '%s' got '%s'", tGetName(wanted), tGetName(t));
  125. }
  126. }
  127. static bool cConsumeTokenIf(Token t) {
  128. return tPeekToken() == t && cReadTokenAndLine() == t;
  129. }
  130. static void cConstantInt() {
  131. int value;
  132. if(!tReadInt(&value)) {
  133. cError("int token without an int");
  134. }
  135. cAddIntOperation(OP_PUSH_INT, value);
  136. }
  137. static void cConstantFloat() {
  138. float value;
  139. if(!tReadFloat(&value)) {
  140. cError("float token without a float");
  141. }
  142. cAddOperation(OP_PUSH_FLOAT);
  143. bcAddBytes(code, &value, sizeof(float));
  144. }
  145. static const char* cReadString() {
  146. const char* literal = tReadString();
  147. if(literal == NULL) {
  148. cError("literal without string on line %d", line);
  149. }
  150. return literal;
  151. }
  152. static int cGetSize(DataType dt) {
  153. return dtGetSize(dt, &structs);
  154. }
  155. static DataType cDereference(DataType dt) {
  156. if(dtDereference(&dt)) {
  157. cError("%s dereferenced too often", cGetName(dt));
  158. }
  159. return dt;
  160. }
  161. static DataType cExtendType(DataType dt) {
  162. while(cConsumeTokenIf(T_MUL)) {
  163. dt = cDereference(dt);
  164. }
  165. return dt;
  166. }
  167. static DataType cReadType(Token t) {
  168. switch(t) {
  169. case T_INT: return cExtendType(dtInt());
  170. case T_BOOL: return cExtendType(dtBool());
  171. case T_FLOAT: return cExtendType(dtFloat());
  172. case T_LITERAL:
  173. {
  174. Struct* st = stsSearch(&structs, cReadString());
  175. if(st == NULL) {
  176. cError("struct %s does not exist");
  177. }
  178. return cExtendType(dtStruct(st));
  179. }
  180. default: cUnexpectedToken(t); return dtVoid();
  181. }
  182. }
  183. static DataType cExpression();
  184. static void cLoadRef(DataType type) {
  185. if(dtIsPointer(type)) {
  186. cAddOperation(OP_REFERENCE);
  187. return;
  188. }
  189. switch(type.type) {
  190. DT_OPERATION(LOAD);
  191. case DT_STRUCT: cAddIntOperation(OP_LOAD, cGetSize(type)); break;
  192. default: cError("cannot load type %s", cGetName(type));
  193. }
  194. }
  195. static DataType cUnpack(DataType dt) {
  196. if(dtRemoveVariable(&dt)) {
  197. cLoadRef(dt);
  198. }
  199. return dt;
  200. }
  201. static DataType cUnpackedExpression() {
  202. return cUnpack(cExpression());
  203. }
  204. static void cCallFunctionArguments(Function* f) {
  205. if(cConsumeTokenIf(T_CLOSE_BRACKET)) {
  206. return;
  207. }
  208. while(true) {
  209. DataType dt = cUnpackedExpression();
  210. if(fAddArgument(f, dt, &structs)) {
  211. cTooMuchArguments();
  212. } else if(cConsumeTokenIf(T_CLOSE_BRACKET)) {
  213. return;
  214. }
  215. cConsumeToken(T_COMMA);
  216. }
  217. }
  218. static DataType cCallFunction(const char* name) {
  219. cAddIntOperation(OP_PUSH_INT, 0);
  220. Function f;
  221. fInit(&f, name, line);
  222. int oldOnLine = onLine;
  223. onLine = false;
  224. cCallFunctionArguments(&f);
  225. onLine = oldOnLine;
  226. cAddOperation(OP_GOSUB);
  227. Function* found = fsSearch(&functions, &f);
  228. if(found == NULL) {
  229. cError("unknown function");
  230. } else if(found->address == -1) {
  231. f.returnType = found->returnType;
  232. f.address = cReserveInt();
  233. fsAdd(&functionQueue, &f);
  234. } else {
  235. cAddInt(found->address);
  236. }
  237. cAddInt(found->size);
  238. return found->returnType;
  239. }
  240. static void cStore(DataType left, DataType right, const char* name) {
  241. if(!dtCompare(left, right)) {
  242. cInvalidOperation(left, right, name);
  243. } else if(dtIsPointer(left)) {
  244. cAddOperation(OP_STORE_POINTER);
  245. return;
  246. }
  247. switch(left.type) {
  248. DT_OPERATION(STORE);
  249. default: cError("cannot store type %s", cGetName(left));
  250. }
  251. }
  252. static DataType cLiteral() {
  253. const char* literal = cReadString();
  254. if(cConsumeTokenIf(T_OPEN_BRACKET)) {
  255. return cCallFunction(literal);
  256. }
  257. Variable v;
  258. if(vsSearch(&vars, &v, literal)) {
  259. cNotDeclared(literal);
  260. }
  261. cAddIntOperation(OP_DEREFERENCE_VAR, v.address);
  262. return dtToVariable(v.type);
  263. }
  264. static DataType cBracketPrimary() {
  265. DataType result = cExpression();
  266. cConsumeToken(T_CLOSE_BRACKET);
  267. return result;
  268. }
  269. static void cArrayIndex(const char* name) {
  270. if(!dtIsInt(cUnpackedExpression())) {
  271. cError("array %s must be an int", name);
  272. }
  273. }
  274. static DataType cAllocArray() {
  275. DataType dt = cReadType(cReadTokenAndLine());
  276. cConsumeToken(T_OPEN_SQUARE_BRACKET);
  277. cArrayIndex("size");
  278. cConsumeToken(T_CLOSE_SQUARE_BRACKET);
  279. cAddIntOperation(OP_NEW, cGetSize(dt));
  280. return cDereference(dt);
  281. }
  282. static DataType cLength() {
  283. DataType pointer = cUnpackedExpression();
  284. if(!dtIsPointer(pointer)) {
  285. cError("length expects a pointer");
  286. }
  287. cAddOperation(OP_LENGTH);
  288. return dtInt();
  289. }
  290. static DataType cPrimary() {
  291. Token t = cReadTokenAndLine();
  292. switch(t) {
  293. case T_CONST_INT: cConstantInt(); return dtInt();
  294. case T_CONST_FLOAT: cConstantFloat(); return dtFloat();
  295. case T_TRUE: cAddOperation(OP_PUSH_TRUE); return dtBool();
  296. case T_FALSE: cAddOperation(OP_PUSH_FALSE); return dtBool();
  297. case T_OPEN_BRACKET: return cBracketPrimary();
  298. case T_LITERAL: return cLiteral();
  299. case T_NEW: return cAllocArray();
  300. case T_LENGTH: return cLength();
  301. default: cUnexpectedToken(t); return dtVoid();
  302. }
  303. }
  304. static void cRemoveReference(DataType* dt, const char* name) {
  305. if(!dtRemoveVariable(dt)) {
  306. cError("%s needs a reference not %s", name, cGetName(*dt));
  307. }
  308. }
  309. static void cExpectType(DataType actual, DataType wanted, const char* name) {
  310. if(!dtCompare(actual, wanted)) {
  311. cError("%s needs %s not %s", name, cGetName(wanted), cGetName(actual));
  312. }
  313. }
  314. static void cPostChange(DataType* dt, int change, const char* name) {
  315. cRemoveReference(dt, name);
  316. cExpectType(*dt, dtInt(), name);
  317. if(onLine) {
  318. cAddByteOperation(OP_INT_CHANGE, change);
  319. *dt = dtVoid();
  320. } else {
  321. cAddByteOperation(OP_PUSH_POST_INT_CHANGE, change);
  322. }
  323. }
  324. static DataType cStructAccess(DataType dt, int pointers) {
  325. Struct* st = dtGetStruct(&structs, dt);
  326. if(st == NULL || dt.pointers != pointers) {
  327. cError(pointers == 0 ? ". expects a struct" : "-> expects a struct*");
  328. }
  329. cConsumeToken(T_LITERAL);
  330. const char* name = cReadString();
  331. Variable inner;
  332. if(vSearchStruct(&inner, &structs, st, name)) {
  333. cError("%s has no member %s", st->name, name);
  334. } else if(inner.address > 0) {
  335. cAddIntOperation(OP_PUSH_INT, inner.address);
  336. cAddOperation(OP_ADD_REFERENCE);
  337. }
  338. return dtToVariable(inner.type);
  339. }
  340. static DataType cAccess() {
  341. DataType dt = cPrimary();
  342. while(true) {
  343. if(cConsumeTokenIf(T_INCREMENT)) {
  344. cPostChange(&dt, 1, "++");
  345. } else if(cConsumeTokenIf(T_DECREMENT)) {
  346. cPostChange(&dt, -1, "--");
  347. } else if(cConsumeTokenIf(T_POINT)) {
  348. cRemoveReference(&dt, ".");
  349. dt = cStructAccess(dt, 0);
  350. } else if(cConsumeTokenIf(T_ARROW)) {
  351. dt = cStructAccess(cUnpack(dt), 1);
  352. } else if(cConsumeTokenIf(T_OPEN_SQUARE_BRACKET)) {
  353. dt = cUnpack(dt);
  354. if(!dtIsPointer(dt)) {
  355. cError("[] needs a pointer");
  356. }
  357. cArrayIndex("index");
  358. cConsumeToken(T_CLOSE_SQUARE_BRACKET);
  359. cAddOperation(OP_ADD_REFERENCE);
  360. dt = dtToVariable(dtReference(dt));
  361. } else {
  362. return dt;
  363. }
  364. }
  365. }
  366. static DataType cPreChange(DataType dt, int change, const char* name) {
  367. cRemoveReference(&dt, name);
  368. cExpectType(dt, dtInt(), name);
  369. if(onLine) {
  370. cAddByteOperation(OP_INT_CHANGE, change);
  371. return dtVoid();
  372. }
  373. cAddByteOperation(OP_PUSH_PRE_INT_CHANGE, change);
  374. return dt;
  375. }
  376. static DataType cInvertSign(DataType dt) {
  377. if(dtIsInt(dt)) {
  378. cAddOperation(OP_INVERT_SIGN_INT);
  379. } else if(dtIsFloat(dt)) {
  380. cAddOperation(OP_INVERT_SIGN_FLOAT);
  381. } else {
  382. cError("cannot invert sign of %s", cGetName(dt));
  383. }
  384. return dt;
  385. }
  386. static DataType cPreUnary() {
  387. if(cConsumeTokenIf(T_INCREMENT)) {
  388. return cPreChange(cPreUnary(), 1, "++");
  389. } else if(cConsumeTokenIf(T_DECREMENT)) {
  390. return cPreChange(cPreUnary(), -1, "--");
  391. } else if(cConsumeTokenIf(T_SUB)) {
  392. return cInvertSign(cUnpack(cPreUnary()));
  393. } else if(cConsumeTokenIf(T_NOT)) {
  394. DataType dt = cPreUnary();
  395. cExpectType(dt, dtBool(), "!");
  396. cAddOperation(OP_NOT);
  397. return dt;
  398. } else if(cConsumeTokenIf(T_BIT_NOT)) {
  399. DataType dt = cPreUnary();
  400. cExpectType(dt, dtInt(), "!");
  401. cAddOperation(OP_BIT_NOT);
  402. return dt;
  403. } else if(cConsumeTokenIf(T_BIT_AND)) {
  404. DataType dt = cPreUnary();
  405. cRemoveReference(&dt, "&");
  406. return cDereference(dt);
  407. } else if(cConsumeTokenIf(T_MUL)) {
  408. DataType dt = cPreUnary();
  409. if(!dtIsPointer(dt)) {
  410. cError("* expects a pointer");
  411. }
  412. dt = dtReference(dt);
  413. if(!dtIsPointer(dt) && !dtIsVariable(dt)) {
  414. dt = dtToVariable(dt);
  415. } else {
  416. cAddOperation(OP_REFERENCE);
  417. }
  418. return dt;
  419. }
  420. return cAccess();
  421. }
  422. static void cAddTypeOperation(DataType* a, Parser bf, const TypedOp* op) {
  423. *a = cUnpack(*a);
  424. DataType b = cUnpack(bf());
  425. if(!dtCompare(*a, b)) {
  426. cInvalidOperation(*a, b, op->name);
  427. } else if(dtIsInt(*a) && op->intOp != OP_NOTHING) {
  428. cAddOperation(op->intOp);
  429. } else if(dtIsFloat(*a) && op->floatOp != OP_NOTHING) {
  430. cAddOperation(op->floatOp);
  431. } else if(dtIsBool(*a) && op->boolOp != OP_NOTHING) {
  432. cAddOperation(op->boolOp);
  433. } else if(dtIsPointer(*a) && op->pointerOp != OP_NOTHING) {
  434. cAddOperation(op->pointerOp);
  435. } else {
  436. cInvalidOperation(*a, b, op->name);
  437. }
  438. }
  439. static DataType cMul() {
  440. DataType a = cPreUnary();
  441. while(true) {
  442. if(cConsumeTokenIf(T_MUL)) {
  443. cAddTypeOperation(&a, cPreUnary, &TYPED_MUL);
  444. } else if(cConsumeTokenIf(T_DIV)) {
  445. cAddTypeOperation(&a, cPreUnary, &TYPED_DIV);
  446. } else if(cConsumeTokenIf(T_MOD)) {
  447. cAddTypeOperation(&a, cPreUnary, &TYPED_MOD);
  448. } else {
  449. return a;
  450. }
  451. }
  452. }
  453. static DataType cAdd() {
  454. DataType a = cMul();
  455. while(true) {
  456. if(cConsumeTokenIf(T_ADD)) {
  457. cAddTypeOperation(&a, cMul, &TYPED_ADD);
  458. } else if(cConsumeTokenIf(T_SUB)) {
  459. cAddTypeOperation(&a, cMul, &TYPED_SUB);
  460. } else {
  461. return a;
  462. }
  463. }
  464. }
  465. static DataType cShift() {
  466. DataType a = cAdd();
  467. while(true) {
  468. if(cConsumeTokenIf(T_LEFT_SHIFT)) {
  469. cAddTypeOperation(&a, cAdd, &TYPED_LEFT_SHIFT);
  470. } else if(cConsumeTokenIf(T_RIGHT_SHIFT)) {
  471. cAddTypeOperation(&a, cAdd, &TYPED_RIGHT_SHIFT);
  472. } else {
  473. return a;
  474. }
  475. }
  476. }
  477. static DataType cComparison() {
  478. DataType a = cShift();
  479. while(true) {
  480. if(cConsumeTokenIf(T_LESS)) {
  481. cAddTypeOperation(&a, cShift, &TYPED_LESS);
  482. a = dtBool();
  483. } else if(cConsumeTokenIf(T_LESS_EQUAL)) {
  484. cAddTypeOperation(&a, cShift, &TYPED_LESS_EQUAL);
  485. cAddOperation(OP_NOT);
  486. a = dtBool();
  487. } else if(cConsumeTokenIf(T_GREATER)) {
  488. cAddTypeOperation(&a, cShift, &TYPED_GREATER);
  489. a = dtBool();
  490. } else if(cConsumeTokenIf(T_GREATER_EQUAL)) {
  491. cAddTypeOperation(&a, cShift, &TYPED_GREATER_EQUAL);
  492. cAddOperation(OP_NOT);
  493. a = dtBool();
  494. } else {
  495. return a;
  496. }
  497. }
  498. }
  499. static DataType cEqual() {
  500. DataType a = cComparison();
  501. while(true) {
  502. if(cConsumeTokenIf(T_EQUAL)) {
  503. cAddTypeOperation(&a, cComparison, &TYPED_EQUAL);
  504. a = dtBool();
  505. } else if(cConsumeTokenIf(T_NOT_EQUAL)) {
  506. cAddTypeOperation(&a, cComparison, &TYPED_NOT_EQUAL);
  507. cAddOperation(OP_NOT);
  508. a = dtBool();
  509. } else {
  510. return a;
  511. }
  512. }
  513. }
  514. static DataType cRepeat(Token t, Parser f, const TypedOp* op) {
  515. DataType a = f();
  516. while(cConsumeTokenIf(t)) {
  517. cAddTypeOperation(&a, f, op);
  518. }
  519. return a;
  520. }
  521. static DataType cBitAnd() {
  522. return cRepeat(T_BIT_AND, cEqual, &TYPED_BIT_AND);
  523. }
  524. static DataType cBitXor() {
  525. return cRepeat(T_BIT_XOR, cBitAnd, &TYPED_BIT_XOR);
  526. }
  527. static DataType cBitOr() {
  528. return cRepeat(T_BIT_OR, cBitXor, &TYPED_BIT_OR);
  529. }
  530. static DataType cLogical(Parser f, Token t, Operation jump, Operation op) {
  531. DataType a = f();
  532. while(cConsumeTokenIf(t)) {
  533. a = cUnpack(a);
  534. cAddOperation(jump);
  535. int p = cReserveInt();
  536. DataType b = cUnpack(f());
  537. if(!dtIsBool(a) || !dtIsBool(b)) {
  538. cInvalidOperation(a, b, tGetName(t));
  539. }
  540. cAddOperation(op);
  541. cSetInt(p, code->length);
  542. }
  543. return a;
  544. }
  545. static DataType cAnd() {
  546. return cLogical(cBitOr, T_AND, OP_PEEK_FALSE_GOTO, OP_AND);
  547. }
  548. static DataType cExpression() {
  549. return cLogical(cAnd, T_OR, OP_PEEK_TRUE_GOTO, OP_OR);
  550. }
  551. static void cLine();
  552. static void cConsumeBody() {
  553. int oldLine = line;
  554. while(!cConsumeTokenIf(T_CLOSE_CURVED_BRACKET)) {
  555. if(tPeekToken() == T_END) {
  556. line = oldLine;
  557. cError("non closed curved bracket");
  558. }
  559. cLine();
  560. }
  561. }
  562. static void cConsumeScope() {
  563. Scope scope;
  564. vsEnterScope(&vars, &scope);
  565. cConsumeBody();
  566. vsLeaveScope(&vars, &scope);
  567. }
  568. static void cAddReturn(Operation op) {
  569. if(returnIndex >= RETURN_BUFFER) {
  570. cError("too much returns in function");
  571. }
  572. cAddOperation(op);
  573. returns[returnIndex++] = cReserveInt();
  574. }
  575. static void cReturn() {
  576. if(dtIsVoid(returnType)) {
  577. cConsumeToken(T_SEMICOLON);
  578. cAddReturn(OP_RETURN);
  579. hasReturn = 2;
  580. return;
  581. }
  582. DataType dt = cUnpackedExpression();
  583. if(!dtCompare(dt, returnType)) {
  584. cError("wrong return type, should be %s", cGetName(returnType));
  585. } else if(dtIsInt(dt)) {
  586. cAddReturn(OP_RETURN_INT);
  587. } else if(dtIsBool(dt)) {
  588. cAddReturn(OP_RETURN_BOOL);
  589. } else if(dtIsFloat(dt)) {
  590. cAddReturn(OP_RETURN_FLOAT);
  591. } else if(dtIsPointer(dt)) {
  592. cAddReturn(OP_RETURN_POINTER);
  593. } else {
  594. cError("cannot return %s", cGetName(dt));
  595. }
  596. cConsumeToken(T_SEMICOLON);
  597. hasReturn = 2;
  598. }
  599. static void cPrint() {
  600. DataType dt = cUnpackedExpression();
  601. if(dtIsPointer(dt)) {
  602. cAddOperation(OP_PRINT_POINTER);
  603. cConsumeToken(T_SEMICOLON);
  604. return;
  605. }
  606. switch(dt.type) {
  607. DT_OPERATION(PRINT);
  608. default: cError("cannot print type %s", cGetName(dt));
  609. }
  610. cConsumeToken(T_SEMICOLON);
  611. }
  612. static void cIf() {
  613. cConsumeToken(T_OPEN_BRACKET);
  614. cExpectType(cUnpackedExpression(), dtBool(), "if");
  615. cConsumeToken(T_CLOSE_BRACKET);
  616. cAddOperation(OP_IF_GOTO);
  617. int ifP = cReserveInt();
  618. cConsumeToken(T_OPEN_CURVED_BRACKET);
  619. cConsumeScope();
  620. cSetInt(ifP, code->length);
  621. if(cConsumeTokenIf(T_ELSE)) {
  622. cAddOperation(OP_GOTO);
  623. int elseP = cReserveInt();
  624. cSetInt(ifP, code->length);
  625. if(cConsumeTokenIf(T_IF)) {
  626. cIf();
  627. } else {
  628. cConsumeToken(T_OPEN_CURVED_BRACKET);
  629. cConsumeScope();
  630. }
  631. cSetInt(elseP, code->length);
  632. }
  633. }
  634. static void cConsumeBreaks(int start, int address) {
  635. for(int i = start; i < breakIndex; i++) {
  636. cSetInt(breaks[i], address);
  637. }
  638. breakIndex = start;
  639. }
  640. static void cWhile() {
  641. int start = code->length;
  642. cConsumeToken(T_OPEN_BRACKET);
  643. cExpectType(cUnpackedExpression(), dtBool(), "while");
  644. cConsumeToken(T_CLOSE_BRACKET);
  645. cAddOperation(OP_IF_GOTO);
  646. int ifP = cReserveInt();
  647. int breakStart = breakIndex;
  648. forWhileStack++;
  649. int oldContinue = continueAt;
  650. continueAt = start;
  651. cConsumeToken(T_OPEN_CURVED_BRACKET);
  652. cConsumeScope();
  653. continueAt = oldContinue;
  654. forWhileStack--;
  655. cAddIntOperation(OP_GOTO, start);
  656. cSetInt(ifP, code->length);
  657. cConsumeBreaks(breakStart, code->length);
  658. }
  659. static void cDelete() {
  660. DataType pointer = cUnpackedExpression();
  661. if(!dtIsPointer(pointer)) {
  662. cError("delete expects a pointer");
  663. }
  664. cAddOperation(OP_DELETE);
  665. }
  666. static void cOperationSet(DataType left, const TypedOp* op) {
  667. cAddOperation(OP_DUPLICATE_REFERENCE);
  668. cLoadRef(left);
  669. cAddTypeOperation(&left, cUnpackedExpression, op);
  670. cStore(left, left, "=");
  671. }
  672. static void cSetVariable() {
  673. onLine = true;
  674. DataType dt = cPreUnary();
  675. onLine = false;
  676. if(dtIsVoid(dt)) {
  677. return;
  678. }
  679. cRemoveReference(&dt, "setter");
  680. Token t = cReadTokenAndLine();
  681. switch(t) {
  682. case T_SET: cStore(dt, cUnpackedExpression(), "="); break;
  683. case T_ADD_SET: cOperationSet(dt, &TYPED_ADD); break;
  684. case T_SUB_SET: cOperationSet(dt, &TYPED_SUB); break;
  685. case T_MUL_SET: cOperationSet(dt, &TYPED_MUL); break;
  686. case T_DIV_SET: cOperationSet(dt, &TYPED_DIV); break;
  687. case T_MOD_SET: cOperationSet(dt, &TYPED_MOD); break;
  688. case T_BIT_AND_SET: cOperationSet(dt, &TYPED_BIT_AND); break;
  689. case T_BIT_OR_SET: cOperationSet(dt, &TYPED_BIT_OR); break;
  690. case T_BIT_XOR_SET: cOperationSet(dt, &TYPED_BIT_XOR); break;
  691. case T_LEFT_SHIFT_SET: cOperationSet(dt, &TYPED_LEFT_SHIFT); break;
  692. case T_RIGHT_SHIFT_SET: cOperationSet(dt, &TYPED_RIGHT_SHIFT); break;
  693. default: cUnexpectedToken(t);
  694. }
  695. }
  696. static void cDeclare(DataType dt) {
  697. dt = cExtendType(dt);
  698. cConsumeToken(T_LITERAL);
  699. const char* var = cReadString();
  700. if(vsInScope(&vars, var)) {
  701. cDeclared(var);
  702. }
  703. Variable* v = vsAdd(&vars, var, dt, &structs);
  704. if(dt.type != DT_STRUCT || dtIsPointer(dt)) {
  705. cConsumeToken(T_SET);
  706. cAddIntOperation(OP_DEREFERENCE_VAR, v->address);
  707. cStore(v->type, cUnpackedExpression(), "=");
  708. }
  709. }
  710. static void cLineExpression() {
  711. int marker = tGetMarker();
  712. Token t = cReadTokenAndLine();
  713. if(t == T_LITERAL) {
  714. const char* literal = cReadString();
  715. Struct* st = stsSearch(&structs, literal);
  716. if(st != NULL) {
  717. cDeclare(dtStruct(st));
  718. return;
  719. }
  720. }
  721. switch(t) {
  722. case T_INT: cDeclare(dtInt()); break;
  723. case T_BOOL: cDeclare(dtBool()); break;
  724. case T_FLOAT: cDeclare(dtFloat()); break;
  725. case T_DELETE: cDelete(); break;
  726. default: tReset(marker); cSetVariable();
  727. }
  728. }
  729. static void cFor() {
  730. Scope scope;
  731. vsEnterScope(&vars, &scope);
  732. cConsumeToken(T_OPEN_BRACKET);
  733. cLineExpression();
  734. cConsumeToken(T_SEMICOLON);
  735. int startCheck = code->length;
  736. cExpectType(cUnpackedExpression(), dtBool(), "for");
  737. cConsumeToken(T_SEMICOLON);
  738. cAddOperation(OP_IF_GOTO);
  739. int end = cReserveInt();
  740. cAddOperation(OP_GOTO);
  741. int beginBody = cReserveInt();
  742. int startPerLoop = code->length;
  743. cLineExpression();
  744. cAddIntOperation(OP_GOTO, startCheck);
  745. cConsumeToken(T_CLOSE_BRACKET);
  746. cSetInt(beginBody, code->length);
  747. int breakStart = breakIndex;
  748. forWhileStack++;
  749. int oldContinue = continueAt;
  750. continueAt = startPerLoop;
  751. cConsumeToken(T_OPEN_CURVED_BRACKET);
  752. cConsumeBody();
  753. continueAt = oldContinue;
  754. forWhileStack--;
  755. cAddIntOperation(OP_GOTO, startPerLoop);
  756. cSetInt(end, code->length);
  757. cConsumeBreaks(breakStart, code->length);
  758. vsLeaveScope(&vars, &scope);
  759. }
  760. static void cBreak() {
  761. if(forWhileStack == 0) {
  762. cError("break without for or while");
  763. } else if(breakIndex >= BREAK_BUFFER) {
  764. cError("too much breaks");
  765. }
  766. cAddOperation(OP_GOTO);
  767. breaks[breakIndex++] = cReserveInt();
  768. cConsumeToken(T_SEMICOLON);
  769. }
  770. static void cContinue() {
  771. if(forWhileStack == 0) {
  772. cError("continue without for or while");
  773. }
  774. cAddIntOperation(OP_GOTO, continueAt);
  775. cConsumeToken(T_SEMICOLON);
  776. }
  777. static void cLine() {
  778. int marker = tGetMarker();
  779. Token t = cReadTokenAndLine();
  780. cAddLine(line);
  781. switch(t) {
  782. case T_OPEN_CURVED_BRACKET: cConsumeScope(); break;
  783. case T_PRINT: cPrint(); break;
  784. case T_RETURN: cReturn(); break;
  785. case T_IF: cIf(); break;
  786. case T_WHILE: cWhile(); break;
  787. case T_FOR: cFor(); break;
  788. case T_BREAK: cBreak(); break;
  789. case T_CONTINUE: cContinue(); break;
  790. default:
  791. tReset(marker);
  792. cLineExpression();
  793. cConsumeToken(T_SEMICOLON);
  794. }
  795. }
  796. static void cBuildFunction(Function* f, DataType rType) {
  797. cConsumeToken(T_LITERAL);
  798. fInit(f, cReadString(), line);
  799. f->returnType = rType;
  800. vsReset(&vars);
  801. cConsumeToken(T_OPEN_BRACKET);
  802. if(cConsumeTokenIf(T_CLOSE_BRACKET)) {
  803. return;
  804. }
  805. while(true) {
  806. DataType dt = cReadType(cReadTokenAndLine());
  807. cConsumeToken(T_LITERAL);
  808. const char* name = cReadString();
  809. if(vsInScope(&vars, name)) {
  810. cDeclared(name);
  811. }
  812. vsAdd(&vars, name, dt, &structs);
  813. if(fAddArgument(f, dt, &structs)) {
  814. cTooMuchArguments();
  815. } else if(cConsumeTokenIf(T_CLOSE_BRACKET)) {
  816. return;
  817. }
  818. cConsumeToken(T_COMMA);
  819. }
  820. }
  821. static void cAddFunction(Function* found, Function* f) {
  822. if(found == NULL) {
  823. fsAdd(&functions, f);
  824. } else if(found->address != -1 || f->address == -1) {
  825. cError("function registered twice");
  826. } else if(!dtCompare(found->returnType, f->returnType)) {
  827. cError("function redeclared with different return type");
  828. } else {
  829. found->address = f->address;
  830. }
  831. }
  832. static void cInnerFunction(Function* f) {
  833. cConsumeToken(T_OPEN_CURVED_BRACKET);
  834. cAddOperation(OP_RESERVE);
  835. int p = cReserveInt();
  836. cAddInt(f->size);
  837. returnIndex = 0;
  838. cConsumeScope();
  839. if(!dtIsVoid(returnType) && hasReturn <= 0) {
  840. cError("missing return");
  841. }
  842. cAddIntOperation(OP_RETURN, vars.maxAddress);
  843. cSetInt(p, vars.maxAddress);
  844. for(int i = 0; i < returnIndex; i++) {
  845. cSetInt(returns[i], vars.maxAddress);
  846. }
  847. returnIndex = 0;
  848. }
  849. static void cFunction(DataType rType) {
  850. rType = cExtendType(rType);
  851. Function f;
  852. cBuildFunction(&f, rType);
  853. Function* found = fsSearch(&functions, &f);
  854. if(cConsumeTokenIf(T_SEMICOLON)) {
  855. cAddFunction(found, &f);
  856. return;
  857. }
  858. cAddLine(line);
  859. cAddOperation(OP_GOTO);
  860. int end = cReserveInt();
  861. f.address = code->length;
  862. cAddFunction(found, &f);
  863. returnType = rType;
  864. cInnerFunction(&f);
  865. cSetInt(end, code->length);
  866. }
  867. static void cStruct() {
  868. cConsumeToken(T_LITERAL);
  869. const char* name = cReadString();
  870. if(stsSearch(&structs, name) != NULL) {
  871. cError("struct registered twice");
  872. }
  873. Struct* st = stsAdd(&structs, name);
  874. DataType self = dtStruct(st);
  875. cConsumeToken(T_OPEN_CURVED_BRACKET);
  876. while(!cConsumeTokenIf(T_CLOSE_CURVED_BRACKET)) {
  877. DataType dt = cReadType(cReadTokenAndLine());
  878. if(dtCompare(dt, self)) {
  879. cError("struct %s contains itself", name);
  880. }
  881. cConsumeToken(T_LITERAL);
  882. stAddVariable(st, cReadString(), dt);
  883. cConsumeToken(T_SEMICOLON);
  884. }
  885. cConsumeToken(T_SEMICOLON);
  886. }
  887. static void cGlobalScope(Token t) {
  888. switch(t) {
  889. case T_VOID: cFunction(dtVoid()); break;
  890. case T_STRUCT: cStruct(); break;
  891. default: cFunction(cReadType(t));
  892. }
  893. }
  894. static void cCallMain() {
  895. Function f;
  896. fInit(&f, "main", line);
  897. Function* found = fsSearch(&functions, &f);
  898. if(found != NULL && dtIsVoid(found->returnType)) {
  899. cAddIntOperation(OP_PUSH_INT, 0);
  900. cAddIntOperation(OP_GOSUB, found->address);
  901. cAddInt(found->size);
  902. }
  903. }
  904. static void cForEachLine() {
  905. while(true) {
  906. Token t = cReadTokenAndLine();
  907. if(t == T_END) {
  908. break;
  909. }
  910. cGlobalScope(t);
  911. }
  912. cCallMain();
  913. }
  914. static void cLinkQueuedFunctions() {
  915. for(int i = 0; i < functionQueue.entries; i++) {
  916. Function* f = functionQueue.data + i;
  917. Function* found = fsSearch(&functions, f);
  918. if(found == NULL || found->address == -1) {
  919. line = f->line;
  920. cError("unknown function");
  921. }
  922. cSetInt(f->address, found->address);
  923. }
  924. }
  925. static void cAllocAndCompile() {
  926. forWhileStack = 0;
  927. breakIndex = 0;
  928. returnType = dtVoid();
  929. onLine = false;
  930. vsInit(&vars);
  931. fsInit(&functions);
  932. fsInit(&functionQueue);
  933. stsInit(&structs);
  934. if(!setjmp(errorJump)) {
  935. cForEachLine();
  936. cLinkQueuedFunctions();
  937. }
  938. stsDelete(&structs);
  939. fsDelete(&functionQueue);
  940. fsDelete(&functions);
  941. vsDelete(&vars);
  942. }
  943. ByteCode* cCompile() {
  944. error[0] = '\0';
  945. code = bcInit();
  946. cAllocAndCompile();
  947. if(error[0] != '\0') {
  948. bcDelete(code);
  949. return NULL;
  950. }
  951. return code;
  952. }
  953. const char* cGetError() {
  954. return error;
  955. }
  956. int cGetLine() {
  957. return line;
  958. }