You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

parse.c 8.5KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338
  1. #include "parse/parse.h"
  2. #include "trace.h"
  3. #include "gen/gen.h"
  4. static int tok_is_end(struct l2_token *tok) {
  5. return
  6. tok->kind == L2_TOK_CLOSE_BRACE || tok->kind == L2_TOK_CLOSE_BRACKET ||
  7. tok->kind == L2_TOK_CLOSE_PAREN || tok->kind == L2_TOK_EOF ||
  8. tok->kind == L2_TOK_EOL;
  9. }
  10. static int parse_expression(
  11. struct l2_lexer *lexer, struct l2_generator *gen, struct l2_parse_error *err);
  12. static int parse_object_literal(
  13. struct l2_lexer *lexer, struct l2_generator *gen, struct l2_parse_error *err) {
  14. l2_trace_scope("object literal");
  15. // '{' and EOL already skipped by parse_object_or_function_literal
  16. l2_gen_namespace(gen);
  17. while (1) {
  18. struct l2_token *tok = l2_lexer_peek(lexer, 1);
  19. if (tok->kind == L2_TOK_CLOSE_BRACE) {
  20. l2_lexer_consume(lexer); // '}'
  21. break;
  22. } else if (tok->kind != L2_TOK_IDENT) {
  23. l2_parse_err(err, tok, "In object literal: Expected identifier, got %s",
  24. l2_token_kind_name(tok->kind));
  25. return -1;
  26. }
  27. l2_trace("key: '%s'", tok->v.str);
  28. char *key = l2_token_extract_str(tok);
  29. l2_lexer_consume(lexer); // ident
  30. tok = l2_lexer_peek(lexer, 1);
  31. if (tok->kind != L2_TOK_COLON) {
  32. l2_parse_err(err, tok, "In object literal: Expected ':', got %s",
  33. l2_token_kind_name(tok->kind));
  34. return -1;
  35. }
  36. l2_lexer_consume(lexer); // ':'
  37. if (parse_expression(lexer, gen, err) < 0) {
  38. return -1;
  39. }
  40. l2_gen_namespace_set(gen, &key);
  41. l2_gen_pop(gen);
  42. tok = l2_lexer_peek(lexer, 1);
  43. if (tok->kind != L2_TOK_EOL && tok->kind != L2_TOK_CLOSE_BRACE) {
  44. l2_parse_err(err, tok, "In object literal: Expected EOL or '}', got %s",
  45. l2_token_kind_name(tok->kind));
  46. return -1;
  47. }
  48. if (tok->kind == L2_TOK_EOL) {
  49. l2_lexer_consume(lexer); // EOL
  50. }
  51. }
  52. return 0;
  53. }
  54. static int parse_function_literal_impl(
  55. struct l2_lexer *lexer, struct l2_generator *gen, struct l2_parse_error *err) {
  56. l2_trace_scope("function literal");
  57. // '{' and EOL already skipped by parse_object_or_function_literal
  58. int first = 1;
  59. while (1) {
  60. if (l2_lexer_peek(lexer, 1)->kind == L2_TOK_CLOSE_BRACE) {
  61. l2_lexer_consume(lexer); // '}'
  62. break;
  63. }
  64. if (!first) {
  65. l2_gen_pop(gen);
  66. }
  67. l2_trace_scope("function literal expression");
  68. if (parse_expression(lexer, gen, err) < 0) {
  69. return -1;
  70. }
  71. l2_lexer_skip_opt(lexer, L2_TOK_EOL);
  72. first = 0;
  73. }
  74. // All functions must put _something_ on the stack
  75. if (first) {
  76. l2_gen_push(gen, 0);
  77. }
  78. l2_gen_ret(gen);
  79. return 0;
  80. }
  81. static int parse_function_literal(
  82. struct l2_lexer *lexer, struct l2_generator *gen, struct l2_parse_error *err) {
  83. l2_gen_flush(gen);
  84. struct l2_io_writer *prev_writer = gen->writer.w;
  85. // Generate the function to a buffer in memory
  86. struct l2_io_mem_writer w = {0};
  87. w.w.write = l2_io_mem_write;
  88. gen->writer.w = &w.w;
  89. // Generates three words; PUSH, 0, RJMP
  90. l2_gen_rjmp(gen, 0);
  91. l2_word pos = gen->pos;
  92. // Generate the function body itself
  93. int ret = parse_function_literal_impl(lexer, gen, err);
  94. l2_gen_flush(gen);
  95. gen->writer.w = prev_writer;
  96. if (ret < 0) {
  97. free(w.mem);
  98. return -1;
  99. }
  100. l2_word *ops = (l2_word *)w.mem;
  101. l2_word opcount = w.len / sizeof(l2_word);
  102. // Due to the earlier gen_rjmp, the second word will be the argument to RJMP.
  103. // Need to set it properly to skip the function body.
  104. // The '- 3' is because we don't skip the PUSH, <count>, RJMP sequence.
  105. ops[1] = opcount - 3;
  106. l2_bufio_put_n(&gen->writer, ops, opcount * sizeof(l2_word));
  107. free(w.mem);
  108. l2_gen_function(gen, pos);
  109. return 0;
  110. }
  111. static int parse_object_or_function_literal(
  112. struct l2_lexer *lexer, struct l2_generator *gen, struct l2_parse_error *err) {
  113. l2_trace_scope("object or function literal");
  114. l2_lexer_consume(lexer); // '{'
  115. l2_lexer_skip_opt(lexer, L2_TOK_EOL);
  116. struct l2_token *tok = l2_lexer_peek(lexer, 1);
  117. struct l2_token *tok2 = l2_lexer_peek(lexer, 2);
  118. if (tok->kind == L2_TOK_CLOSE_BRACE) {
  119. l2_trace_scope("empty object literal");
  120. l2_lexer_consume(lexer); // '}'
  121. } else if (tok->kind == L2_TOK_IDENT && tok2->kind == L2_TOK_COLON) {
  122. if (parse_object_literal(lexer, gen, err) < 0) {
  123. return -1;
  124. }
  125. } else {
  126. if (parse_function_literal(lexer, gen, err) < 0) {
  127. return -1;
  128. }
  129. }
  130. return 0;
  131. }
  132. static int parse_arg_level_expression_base(
  133. struct l2_lexer *lexer, struct l2_generator *gen, struct l2_parse_error *err) {
  134. l2_trace_scope("arg level expression base");
  135. struct l2_token *tok = l2_lexer_peek(lexer, 1);
  136. struct l2_token *tok2 = l2_lexer_peek(lexer, 2);
  137. if (tok->kind == L2_TOK_OPEN_PAREN) {
  138. l2_trace_scope("group expr");
  139. l2_lexer_consume(lexer); // '('
  140. if (parse_expression(lexer, gen, err) < 0) {
  141. return -1;
  142. }
  143. tok = l2_lexer_peek(lexer, 1);
  144. if (tok->kind != L2_TOK_CLOSE_PAREN) {
  145. l2_parse_err(err, tok, "Expected '(', got %s",
  146. l2_token_kind_name(tok->kind));
  147. return -1;
  148. }
  149. } else if (tok->kind == L2_TOK_IDENT) {
  150. l2_trace_scope("ident");
  151. l2_trace("ident '%s'", tok->v.str);
  152. char *ident = l2_token_extract_str(tok);
  153. l2_lexer_consume(lexer); // ident
  154. l2_gen_stack_frame_lookup(gen, &ident);
  155. } else if (tok->kind == L2_TOK_NUMBER) {
  156. l2_trace_scope("number literal");
  157. l2_trace("number %g", tok->v.num);
  158. double number = tok->v.num;
  159. l2_lexer_consume(lexer); // number
  160. l2_gen_number(gen, number);
  161. } else if (tok->kind == L2_TOK_STRING) {
  162. l2_trace_scope("string literal");
  163. l2_trace("string '%s'", tok->v.str);
  164. char *str = l2_token_extract_str(tok);
  165. l2_lexer_consume(lexer); // string
  166. l2_gen_string(gen, &str);
  167. } else if (tok->kind == L2_TOK_QUOT && tok2->kind == L2_TOK_IDENT) {
  168. l2_trace_scope("atom literal");
  169. l2_trace("atom '%s'", tok->v.str);
  170. char *ident = l2_token_extract_str(tok2);
  171. l2_lexer_consume(lexer); // "'"
  172. l2_lexer_consume(lexer); // ident
  173. l2_gen_atom(gen, &ident);
  174. } else if (tok->kind == L2_TOK_OPEN_BRACE) {
  175. if (parse_object_or_function_literal(lexer, gen, err) < 0) {
  176. return -1;
  177. }
  178. } else {
  179. l2_parse_err(err, tok, "Unexpected token %s",
  180. l2_token_kind_name(tok->kind));
  181. return -1;
  182. }
  183. return 0;
  184. }
  185. static int parse_arg_level_expression(
  186. struct l2_lexer *lexer, struct l2_generator *gen, struct l2_parse_error *err) {
  187. l2_trace_scope("arg level expression");
  188. if (parse_arg_level_expression_base(lexer, gen, err) < 0) {
  189. return -1;
  190. }
  191. while (1) {
  192. struct l2_token *tok = l2_lexer_peek(lexer, 1);
  193. struct l2_token *tok2 = l2_lexer_peek(lexer, 2);
  194. if (tok->kind == L2_TOK_OPEN_PAREN && tok2->kind == L2_TOK_CLOSE_PAREN) {
  195. l2_trace_scope("niladic func call");
  196. l2_lexer_consume(lexer); // '('
  197. l2_lexer_consume(lexer); // ')'
  198. l2_gen_push(gen, 0);
  199. l2_gen_func_call(gen);
  200. } else if (tok->kind == L2_TOK_PERIOD && tok2->kind == L2_TOK_IDENT) {
  201. l2_trace_scope("lookup");
  202. l2_trace("ident '%s'", tok2->v.str);
  203. char *ident = l2_token_extract_str(tok2);
  204. l2_lexer_consume(lexer); // '.'
  205. l2_lexer_consume(lexer); // ident
  206. l2_gen_namespace_lookup(gen, &ident);
  207. } else {
  208. break;
  209. }
  210. }
  211. return 0;
  212. }
  213. static int parse_func_call_after_base(
  214. struct l2_lexer *lexer, struct l2_generator *gen, struct l2_parse_error *err) {
  215. l2_trace_scope("func call after base");
  216. size_t argc = 0;
  217. do {
  218. argc += 1;
  219. l2_trace_scope("func call param");
  220. if (parse_arg_level_expression(lexer, gen, err) < 0) {
  221. return -1;
  222. }
  223. } while (!tok_is_end(l2_lexer_peek(lexer, 1)));
  224. // The 'argc' previous expressions were arguments, the one before that was the function
  225. l2_gen_push(gen, argc);
  226. l2_gen_func_call(gen);
  227. return 0;
  228. }
  229. static int parse_expression(
  230. struct l2_lexer *lexer, struct l2_generator *gen, struct l2_parse_error *err) {
  231. l2_trace_scope("expression");
  232. struct l2_token *tok = l2_lexer_peek(lexer, 1);
  233. struct l2_token *tok2 = l2_lexer_peek(lexer, 2);
  234. if (tok->kind == L2_TOK_IDENT && tok2->kind == L2_TOK_COLON_EQ) {
  235. l2_trace_scope("assign expression");
  236. l2_trace("ident '%s'", tok->v.str);
  237. char *ident = l2_token_extract_str(tok);
  238. l2_lexer_consume(lexer); // ident
  239. l2_lexer_consume(lexer); // :=
  240. if (parse_expression(lexer, gen, err) < 0) {
  241. return -1;
  242. }
  243. l2_gen_assignment(gen, &ident);
  244. } else {
  245. if (parse_arg_level_expression(lexer, gen, err) < 0) {
  246. return -1;
  247. }
  248. if (!tok_is_end(l2_lexer_peek(lexer, 1))) {
  249. if (parse_func_call_after_base(lexer, gen, err) < 0) {
  250. return -1;
  251. }
  252. }
  253. }
  254. return 0;
  255. }
  256. int l2_parse_program(
  257. struct l2_lexer *lexer, struct l2_generator *gen, struct l2_parse_error *err) {
  258. l2_trace_scope("program");
  259. while (1) {
  260. l2_lexer_skip_opt(lexer, L2_TOK_EOL);
  261. if (l2_lexer_peek(lexer, 1)->kind == L2_TOK_EOF) {
  262. break;
  263. }
  264. if (parse_expression(lexer, gen, err) < 0) {
  265. l2_gen_halt(gen);
  266. l2_gen_flush(gen);
  267. return -1;
  268. }
  269. l2_gen_pop(gen);
  270. }
  271. l2_gen_halt(gen);
  272. l2_gen_flush(gen);
  273. return 0;
  274. }