Ви не можете вибрати більше 25 тем Теми мають розпочинатися з літери або цифри, можуть містити дефіси (-) і не повинні перевищувати 35 символів.

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241
  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. while (1) {
  17. struct l2_token *tok = l2_lexer_peek(lexer, 1);
  18. if (tok->kind == L2_TOK_CLOSE_BRACE) {
  19. l2_lexer_consume(lexer); // '}'
  20. break;
  21. } else if (tok->kind != L2_TOK_IDENT) {
  22. l2_parse_err(err, tok, "In object literal: Expected identifier, got %s",
  23. l2_token_kind_name(tok->kind));
  24. return -1;
  25. }
  26. l2_trace("key: '%s'", tok->v.str);
  27. l2_lexer_consume(lexer); // ident
  28. tok = l2_lexer_peek(lexer, 1);
  29. if (tok->kind != L2_TOK_COLON) {
  30. l2_parse_err(err, tok, "In object literal: Expected ':', got %s",
  31. l2_token_kind_name(tok->kind));
  32. return -1;
  33. }
  34. l2_lexer_consume(lexer); // ':'
  35. if (parse_expression(lexer, gen, err) < 0) {
  36. return -1;
  37. }
  38. l2_lexer_skip_opt(lexer, L2_TOK_EOL);
  39. }
  40. return 0;
  41. }
  42. static int parse_function_literal(
  43. struct l2_lexer *lexer, struct l2_generator *gen, struct l2_parse_error *err) {
  44. l2_trace_scope("function literal");
  45. // '{' and EOL already skipped by parse_object_or_function_literal
  46. while (1) {
  47. if (l2_lexer_peek(lexer, 1)->kind == L2_TOK_CLOSE_BRACE) {
  48. l2_lexer_consume(lexer); // '}'
  49. break;
  50. }
  51. l2_trace_scope("function literal expression");
  52. if (parse_expression(lexer, gen, err) < 0) {
  53. return -1;
  54. }
  55. l2_lexer_skip_opt(lexer, L2_TOK_EOL);
  56. }
  57. return 0;
  58. }
  59. static int parse_object_or_function_literal(
  60. struct l2_lexer *lexer, struct l2_generator *gen, struct l2_parse_error *err) {
  61. l2_trace_scope("object or function literal");
  62. l2_lexer_consume(lexer); // '{'
  63. l2_lexer_skip_opt(lexer, L2_TOK_EOL);
  64. struct l2_token *tok = l2_lexer_peek(lexer, 1);
  65. struct l2_token *tok2 = l2_lexer_peek(lexer, 2);
  66. if (tok->kind == L2_TOK_CLOSE_BRACE) {
  67. l2_trace_scope("empty object literal");
  68. l2_lexer_consume(lexer); // '}'
  69. } else if (tok->kind == L2_TOK_IDENT && tok2->kind == L2_TOK_COLON) {
  70. if (parse_object_literal(lexer, gen, err) < 0) {
  71. return -1;
  72. }
  73. } else {
  74. if (parse_function_literal(lexer, gen, err) < 0) {
  75. return -1;
  76. }
  77. }
  78. return 0;
  79. }
  80. static int parse_arg_level_expression_base(
  81. struct l2_lexer *lexer, struct l2_generator *gen, struct l2_parse_error *err) {
  82. l2_trace_scope("arg level expression base");
  83. struct l2_token *tok = l2_lexer_peek(lexer, 1);
  84. struct l2_token *tok2 = l2_lexer_peek(lexer, 2);
  85. if (tok->kind == L2_TOK_OPEN_PAREN) {
  86. l2_trace_scope("group expr");
  87. l2_lexer_consume(lexer); // '('
  88. if (parse_expression(lexer, gen, err) < 0) {
  89. return -1;
  90. }
  91. tok = l2_lexer_peek(lexer, 1);
  92. if (tok->kind != L2_TOK_CLOSE_PAREN) {
  93. l2_parse_err(err, tok, "Expected '(', got %s",
  94. l2_token_kind_name(tok->kind));
  95. return -1;
  96. }
  97. } else if (tok->kind == L2_TOK_IDENT) {
  98. l2_trace_scope("ident");
  99. l2_trace("ident '%s'", tok->v.str);
  100. l2_lexer_consume(lexer); // ident
  101. } else if (tok->kind == L2_TOK_NUMBER) {
  102. l2_trace_scope("number literal");
  103. l2_trace("number %g", tok->v.num);
  104. l2_lexer_consume(lexer); // number
  105. } else if (tok->kind == L2_TOK_STRING) {
  106. l2_trace_scope("string literal");
  107. l2_trace("string '%s'", tok->v.str);
  108. l2_lexer_consume(lexer); // string
  109. } else if (tok->kind == L2_TOK_QUOT && tok2->kind == L2_TOK_IDENT) {
  110. l2_trace_scope("atom literal");
  111. l2_trace("atom '%s'", tok->v.str);
  112. l2_lexer_consume(lexer); // "'"
  113. l2_lexer_consume(lexer); // ident
  114. } else if (tok->kind == L2_TOK_OPEN_BRACE) {
  115. if (parse_object_or_function_literal(lexer, gen, err) < 0) {
  116. return -1;
  117. }
  118. } else {
  119. l2_parse_err(err, tok, "Unexpected token %s",
  120. l2_token_kind_name(tok->kind));
  121. return -1;
  122. }
  123. return 0;
  124. }
  125. static int parse_arg_level_expression(
  126. struct l2_lexer *lexer, struct l2_generator *gen, struct l2_parse_error *err) {
  127. l2_trace_scope("arg level expression");
  128. if (parse_arg_level_expression_base(lexer, gen, err) < 0) {
  129. return -1;
  130. }
  131. while (1) {
  132. struct l2_token *tok = l2_lexer_peek(lexer, 1);
  133. struct l2_token *tok2 = l2_lexer_peek(lexer, 2);
  134. if (tok->kind == L2_TOK_OPEN_PAREN && tok2->kind == L2_TOK_CLOSE_PAREN) {
  135. l2_trace_scope("noadic func call");
  136. l2_lexer_consume(lexer); // '('
  137. l2_lexer_consume(lexer); // ')'
  138. } else if (tok->kind == L2_TOK_PERIOD && tok2->kind == L2_TOK_IDENT) {
  139. l2_trace_scope("lookup");
  140. l2_lexer_consume(lexer); // '.'
  141. l2_lexer_consume(lexer); // ident
  142. } else {
  143. break;
  144. }
  145. }
  146. return 0;
  147. }
  148. static int parse_func_call_after_base(
  149. struct l2_lexer *lexer, struct l2_generator *gen, struct l2_parse_error *err) {
  150. l2_trace_scope("func call after base");
  151. size_t argc = 0;
  152. do {
  153. argc += 1;
  154. l2_trace_scope("func call param");
  155. if (parse_arg_level_expression(lexer, gen, err) < 0) {
  156. return -1;
  157. }
  158. } while (!tok_is_end(l2_lexer_peek(lexer, 1)));
  159. // The 'argc' previous expressions were arguments, the one before that was the function
  160. return 0;
  161. }
  162. static int parse_expression(
  163. struct l2_lexer *lexer, struct l2_generator *gen, struct l2_parse_error *err) {
  164. l2_trace_scope("expression");
  165. struct l2_token *tok = l2_lexer_peek(lexer, 1);
  166. struct l2_token *tok2 = l2_lexer_peek(lexer, 2);
  167. if (tok->kind == L2_TOK_IDENT && tok2->kind == L2_TOK_COLON_EQ) {
  168. l2_trace_scope("assign expression");
  169. l2_trace("ident '%s'", tok->v.str);
  170. l2_lexer_consume(lexer); // ident
  171. l2_lexer_consume(lexer); // :=
  172. if (parse_expression(lexer, gen, err) < 0) {
  173. return -1;
  174. }
  175. } else {
  176. if (parse_arg_level_expression(lexer, gen, err) < 0) {
  177. return -1;
  178. }
  179. if (!tok_is_end(l2_lexer_peek(lexer, 1))) {
  180. if (parse_func_call_after_base(lexer, gen, err) < 0) {
  181. return -1;
  182. }
  183. }
  184. }
  185. return 0;
  186. }
  187. int l2_parse_program(
  188. struct l2_lexer *lexer, struct l2_generator *gen, struct l2_parse_error *err) {
  189. l2_trace_scope("program");
  190. while (1) {
  191. l2_lexer_skip_opt(lexer, L2_TOK_EOL);
  192. if (l2_lexer_peek(lexer, 1)->kind == L2_TOK_EOF) {
  193. return 0;
  194. }
  195. if (parse_expression(lexer, gen, err) < 0) {
  196. return -1;
  197. }
  198. }
  199. return 0;
  200. }