Main.c 1.8 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283
  1. #include <stdint.h>
  2. #include <stdio.h>
  3. #include "Code.h"
  4. #include "Compiler.h"
  5. #include "Memory.h"
  6. #include "Tokenizer.h"
  7. int main(int argCount, const char** args) {
  8. if(argCount < 2) {
  9. return 0;
  10. }
  11. static char heap[1000];
  12. memoryInit(heap, sizeof(heap));
  13. // memoryDump();
  14. // char* c1 = memoryAllocate(16);
  15. // char* c2 = memoryAllocate(22);
  16. // char* c3 = memoryAllocate(32);
  17. // if(c1 == nullptr || c2 == nullptr || c3 == nullptr) {
  18. // return 0;
  19. // }
  20. // memset(c1, 1, 16);
  21. // memset(c2, 2, 22);
  22. // memset(c3, 3, 32);
  23. // memoryDump();
  24. // memoryFree(c2);
  25. // memoryDump();
  26. // memoryFree(c3);
  27. // memoryDump();
  28. // memoryFree(c1);
  29. // memoryDump();
  30. Tokenizer t;
  31. Error e = tokenizerInit(&t, args[1]);
  32. memoryDump();
  33. if(hasError(&e)) {
  34. puts(e.text);
  35. tokenizerDestroy(&t);
  36. return 0;
  37. }
  38. Code code;
  39. codeInit(&code);
  40. e = compileFile(&t, &code);
  41. tokenizerDestroy(&t);
  42. if(hasError(&e)) {
  43. puts(e.text);
  44. } else {
  45. codeRun(&code);
  46. if(codeHasRunError(&code)) {
  47. puts(codeGetRunError(&code));
  48. }
  49. }
  50. codeDestroy(&code);
  51. // while(true) {
  52. // Token token = tokenizerNext(&t);
  53. // if(tokenizerHasError(&t)) {
  54. // puts(tokenizerGetError(&t));
  55. // break;
  56. // }
  57. // char buffer[256];
  58. // tokenizerPrintToken(&token, buffer, sizeof(buffer));
  59. // puts(buffer);
  60. // if(token.type == END) {
  61. // break;
  62. // }
  63. // }
  64. // char line[256];
  65. // while(true) {
  66. // fgets(line, sizeof(line), stdin);
  67. // if(strcmp(line, "quit\n") == 0) {
  68. // break;
  69. // }
  70. // puts(line);
  71. // }
  72. // puts("quit");
  73. return 0;
  74. }