?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
first impl of builtin member methods (thus far, string.size implemented. more to...
[aqualang.git] / include / jtc.h
blob504247d6e7bb043b07ba6dd5b116efee092a7fcf
1
2 #include <iostream>
3 #include <fstream>
4 #include <cctype>
5 #include <cmath>
6 #include <string>
7 #include <vector>
8 #include <array>
9 #include <functional>
10 #include <unordered_map>
11 #include <stdexcept>
12 #include <memory>
13
14 // utility
15 template<class T>
16 bool isint(T x)
17 {
18 return x == std::trunc(x);
19 }
20 std::string unescape(const std::string &str);
21
22 class Interpreter;
23
24 namespace Internal
25 {
26 enum TokenType
27 {
28 Tok_Number, Tok_Identifier, Tok_String,
29 Tok_LeftParen, Tok_RightParen, Tok_LeftBracket,
30 Tok_RightBracket, Tok_LeftBrace, Tok_RightBrace,
31 Tok_Plus, Tok_Dash, Tok_Star,
32 Tok_Percent, Tok_Slash, Tok_PlusEqual,
33 Tok_DashEqual, Tok_StarEqual, Tok_PercentEqual,
34 Tok_SlashEqual, Tok_Not, Tok_Comma,
35 Tok_Semicolon, Tok_Dot, Tok_Colon,
36 Tok_Equal, Tok_EqOp, Tok_NotEqual,
37 Tok_Greater, Tok_GreaterEqual, Tok_Less,
38 Tok_LessEqual, Tok_LogicalAnd, Tok_LogicalOr,
39 Tok_If, Tok_Else, Tok_While,
40 Tok_For, Tok_Return, Tok_Break,
41 Tok_Continue, Tok_Function, Tok_Expression,
42 Tok_Statement, Tok_Root, Tok_Nil,
43 Tok_Eval, Tok_ParseStatement, Tok_ParseExpression,
44 Tok_Global, Tok_Local, Tok_Print,
45 Tok_Type, Tok_Size, Tok_Switch,
46 Tok_Case, Tok_Import,
47 };
48
49 static const std::unordered_map<std::string, TokenType> keywords =
50 {
51 {"if", Tok_If},
52 {"else", Tok_Else},
53 {"while", Tok_While},
54 {"for", Tok_For},
55 {"return", Tok_Return},
56 {"break", Tok_Break},
57 {"continue", Tok_Continue},
58 {"func", Tok_Function},
59 {"nil", Tok_Nil},
60 {"expression", Tok_Expression},
61 {"statement", Tok_Statement},
62 {"eval", Tok_Eval},
63 {"parse_statement", Tok_ParseStatement},
64 {"parse_expression", Tok_ParseExpression},
65 {"global", Tok_Global},
66 {"local", Tok_Local},
67 {"root", Tok_Root},
68 {"type", Tok_Type},
69 {"size", Tok_Size},
70 // these aren't implemented yet
71 {"switch", Tok_Switch},
72 {"case", Tok_Case},
73 {"import", Tok_Import},
74 };
75
76 template<class Iter>
77 struct Token
78 {
79 const TokenType type;
80 const Iter begin;
81 const Iter end;
82
83 Token(TokenType type_, Iter begin_, Iter end_):
84 type(type_),
85 begin(begin_),
86 end(end_)
87 {
88 }
89 };
90
91 // helper to find line & column position on demand
92 template<class Iter>
93 std::pair<int, int> line_column(Iter begin, Iter pos)
94 {
95 int line = 1, column = 0;
96 for(Iter i = begin; i!=pos; ++i)
97 {
98 if(*i == '\n')
99 {
100 ++line;
101 column = 0;
102 }
103 ++column;
104 }
105 return std::make_pair(line, column);
106 }
107
108 template<class Iter>
109 std::shared_ptr<std::vector<Token<Iter>>> tokenize(Iter begin, Iter end)
110 {
111 auto tokens_ptr = std::make_shared<std::vector<Token<Iter>>>();
112 std::vector<Token<Iter>> &tokens = *tokens_ptr;
113 Iter i = begin;
114 while(i!=end)
115 {
116 Iter start = i;
117 switch(*i)
118 {
119 case ' ':
120 case '\t':
121 case '\n': // ignore whitespaces
122 ++i;
123 break;
124 case '(':
125 tokens.emplace_back(Tok_LeftParen, i, i+1);
126 ++i;
127 break;
128 case ')':
129 tokens.emplace_back(Tok_RightParen, i, i+1);
130 ++i;
131 break;
132 case '[':
133 tokens.emplace_back(Tok_LeftBracket, i, i+1);
134 ++i;
135 break;
136 case ']':
137 tokens.emplace_back(Tok_RightBracket, i, i+1);
138 ++i;
139 break;
140 case '{':
141 tokens.emplace_back(Tok_LeftBrace, i, i+1);
142 ++i;
143 break;
144 case '}':
145 tokens.emplace_back(Tok_RightBrace, i, i+1);
146 ++i;
147 break;
148 case ',':
149 tokens.emplace_back(Tok_Comma, i, i+1);
150 ++i;
151 break;
152 case '.':
153 tokens.emplace_back(Tok_Dot, i, i+1);
154 ++i;
155 break;
156 case ';':
157 tokens.emplace_back(Tok_Semicolon, i, i+1);
158 ++i;
159 break;
160 case ':':
161 tokens.emplace_back(Tok_Colon, i, i+1);
162 ++i;
163 break;
164 case '+':
165 if(i+1 != end && *(i+1) == '=')
166 {
167 tokens.emplace_back(Tok_PlusEqual, i, i+2);
168 i+=2;
169 }
170 else
171 {
172 tokens.emplace_back(Tok_Plus, i, i+1);
173 ++i;
174 }
175 break;
176 case '-':
177 if(i+1 != end && *(i+1) == '=')
178 {
179 tokens.emplace_back(Tok_DashEqual, i, i+2);
180 i+=2;
181 }
182 else
183 {
184 tokens.emplace_back(Tok_Dash, i, i+1);
185 ++i;
186 }
187 break;
188 case '*':
189 if(i+1 != end && *(i+1) == '=')
190 {
191 tokens.emplace_back(Tok_StarEqual, i, i+2);
192 i+=2;
193 }
194 else
195 {
196 tokens.emplace_back(Tok_Star, i, i+1);
197 ++i;
198 }
199 break;
200 case '%':
201 if(i+1 != end && *(i+1) == '=')
202 {
203 tokens.emplace_back(Tok_PercentEqual, i, i+2);
204 i+=2;
205 }
206 else
207 {
208 tokens.emplace_back(Tok_Percent, i, i+1);
209 ++i;
210 }
211 break;
212 case '/':
213 if(i+1 != end && *(i+1) == '/')
214 {
215 ++i;
216 while(i!=end && *i != '\n')
217 {
218 ++i;
219 } ++i;
220 }
221 else if(i+1 != end && *(i+1) == '=')
222 {
223 tokens.emplace_back(Tok_SlashEqual, i, i+2);
224 i+=2;
225 }
226 else
227 {
228 tokens.emplace_back(Tok_Slash, i, i+1);
229 ++i;
230 }
231 break;
232 case '<':
233 if(i+1 != end && *(i+1) == '=')
234 {
235 tokens.emplace_back(Tok_LessEqual, i, i+2);
236 i+=2;
237 }
238 else
239 {
240 tokens.emplace_back(Tok_Less, i, i+1);
241 ++i;
242 }
243 break;
244 case '>':
245 if(i+1 != end && *(i+1) == '=')
246 {
247 tokens.emplace_back(Tok_GreaterEqual, i, i+2);
248 i+=2;
249 }
250 else
251 {
252 tokens.emplace_back(Tok_Greater, i, i+1);
253 ++i;
254 }
255 break;
256 case '=':
257 if(i+1 != end && *(i+1) == '=')
258 {
259 tokens.emplace_back(Tok_EqOp, i, i+2);
260 i+=2;
261 }
262 else
263 {
264 tokens.emplace_back(Tok_Equal, i, i+1);
265 ++i;
266 }
267 break;
268 case '!':
269 if(i+1 != end && *(i+1) == '=')
270 {
271 tokens.emplace_back(Tok_NotEqual, i, i+2);
272 i+=2;
273 }
274 else
275 {
276 tokens.emplace_back(Tok_Not, i, i+1);
277 i+=2;
278 }
279 break;
280 case '&':
281 if(i+1 != end && *(i+1) == '&')
282 {
283 tokens.emplace_back(Tok_LogicalAnd, i, i+2);
284 i+=2;
285 }
286 else
287 {
288 auto lc = line_column(begin, i);
289 throw std::runtime_error(
290 std::to_string(lc.first) + ":" +
291 std::to_string(lc.second) + ": unrecognized symbol: '" + *i + "'"
292 );
293 }
294 break;
295 case '|':
296 if(i+1 != end && *(i+1) == '|')
297 {
298 tokens.emplace_back(Tok_LogicalOr, i, i+2);
299 i+=2;
300 }
301 else
302 {
303 auto lc = line_column(begin, i);
304 throw std::runtime_error(
305 std::to_string(lc.first) + ":" +
306 std::to_string(lc.second) + ": unrecognized symbol: '" + *i + "'"
307 );
308 }
309 break;
310 case '"':
311 ++i;
312 while(i!=end && !(*i == '"' && *(i-1) != '\\'))
313 {
314 ++i;
315 }
316 ++i;
317 tokens.emplace_back(Tok_String, start, i);
318 break;
319 default:
320 if(std::isdigit(*i))
321 {
322 while(i!=end && std::isdigit(*i))
323 {
324 ++i;
325 }
326 if(i!=end && *i=='.')
327 {
328 ++i;
329 while(i!=end && std::isdigit(*i))
330 {
331 ++i;
332 }
333 }
334 if(i!=end && *i=='e')
335 {
336 ++i;
337 if(i!=end && *i=='-')
338 {
339 ++i;
340 }
341 while(i!=end && std::isdigit(*i))
342 {
343 ++i;
344 }
345 }
346 tokens.emplace_back(Tok_Number, start, i);
347 break;
348 }
349 else if(std::isalpha(*i) || *i == '_')
350 {
351 ++i;
352 while(i!=end && (std::isalnum(*i) || *i == '_'))
353 {
354 ++i;
355 }
356 auto kw = keywords.find(std::string(start, i));
357 if(kw == keywords.end())
358 {
359 tokens.emplace_back(Tok_Identifier, start, i);
360 }
361 else
362 {
363 tokens.emplace_back(kw->second, start, i);
364 }
365 break;
366 }
367 else
368 {
369 auto lc = line_column(begin, i);
370 throw std::runtime_error(
371 std::to_string(lc.first) + ":" +
372 std::to_string(lc.second) + ": unrecognized symbol: '" + *i + "'"
373 );
374 }
375 }
376 }
377 return tokens_ptr;
378 }
379
380 // Abstract Syntax Tree node types
381 template<typename Iter, typename Value, typename FuncType>
382 struct ASTNode: public std::enable_shared_from_this<ASTNode<Iter,Value,FuncType>>
383 {
384 Iter begin;
385 Iter end;
386 std::shared_ptr<std::string> source;
387 std::shared_ptr<std::vector<Token<std::string::iterator>>> tokens;
388 std::weak_ptr<ASTNode<Iter,Value,FuncType>> root;
389
390 virtual Value accept(FuncType&) = 0;
391
392 virtual std::shared_ptr<ASTNode<Iter,Value,FuncType>>& operator[](size_t) = 0;
393
394 virtual size_t size() const = 0;
395
396 virtual void inject_dependencies() = 0;
397 };
398
399 template<class Iter, class Value, class FuncType>
400 struct Variadic : public ASTNode<Iter,Value,FuncType>
401 {
402 std::vector<std::shared_ptr<ASTNode<Iter,Value,FuncType>>> children;
403
404 virtual Value accept(FuncType &f)
405 {
406 return f(*this);
407 }
408
409 virtual std::shared_ptr<ASTNode<Iter,Value,FuncType>>& operator[](size_t i)
410 {
411 return children[i];
412 }
413
414 virtual size_t size() const
415 {
416 return children.size();
417 }
418
419 virtual void inject_dependencies()
420 {
421 for(auto& child : children)
422 {
423 child->root = this->root;
424 child->source = this->source;
425 child->tokens = this->tokens;
426 child->inject_dependencies();
427 }
428 }
429 };
430
431 template<class Iter, class Value, class FuncType>
432 struct Ternary : public ASTNode<Iter,Value,FuncType>
433 {
434 std::array<std::shared_ptr<ASTNode<Iter,Value,FuncType>>, 3> children;
435
436 virtual Value accept(FuncType &f)
437 {
438 return f(*this);
439 }
440
441 virtual std::shared_ptr<ASTNode<Iter,Value,FuncType>>& operator[](size_t i)
442 {
443 return children[i];
444 }
445
446 virtual size_t size() const
447 {
448 return children.size();
449 }
450
451 virtual void inject_dependencies()
452 {
453 for(auto& child : children)
454 {
455 child->root = this->root;
456 child->source = this->source;
457 child->tokens = this->tokens;
458 child->inject_dependencies();
459 }
460 }
461 };
462
463 template<class Iter, class Value, class FuncType>
464 struct Binary : public ASTNode<Iter,Value,FuncType>
465 {
466 std::array<std::shared_ptr<ASTNode<Iter,Value,FuncType>>, 2> children;
467
468 virtual Value accept(FuncType &f)
469 {
470 return f(*this);
471 }
472
473 virtual std::shared_ptr<ASTNode<Iter,Value,FuncType>>& operator[](size_t i)
474 {
475 return children[i];
476 }
477
478 virtual size_t size() const
479 {
480 return children.size();
481 }
482
483 virtual void inject_dependencies()
484 {
485 for(auto& child : children)
486 {
487 child->root = this->root;
488 child->source = this->source;
489 child->tokens = this->tokens;
490 child->inject_dependencies();
491 }
492 }
493 };
494
495 template<class Iter, class Value, class FuncType>
496 struct Unary : public ASTNode<Iter,Value,FuncType>
497 {
498 std::array<std::shared_ptr<ASTNode<Iter,Value,FuncType>>, 1> children;
499
500 virtual Value accept(FuncType &f)
501 {
502 return f(*this);
503 }
504
505 virtual std::shared_ptr<ASTNode<Iter,Value,FuncType>>& operator[](size_t i)
506 {
507 return children[i];
508 }
509
510 virtual size_t size() const
511 {
512 return children.size();
513 }
514
515 virtual void inject_dependencies()
516 {
517 for(auto& child : children)
518 {
519 child->root = this->root;
520 child->source = this->source;
521 child->tokens = this->tokens;
522 child->inject_dependencies();
523 }
524 }
525 };
526
527 template<class Iter, class Value, class FuncType>
528 struct Nullary : public ASTNode<Iter,Value,FuncType>
529 {
530 std::array<std::shared_ptr<ASTNode<Iter,Value,FuncType>>, 0> children;
531
532 virtual Value accept(FuncType &f)
533 {
534 return f(*this);
535 }
536
537 virtual std::shared_ptr<ASTNode<Iter,Value,FuncType>>& operator[](size_t i)
538 {
539 return children[i];
540 }
541
542 virtual size_t size() const
543 {
544 return children.size();
545 }
546
547 virtual void inject_dependencies()
548 {
549 for(auto& child : children)
550 {
551 child->root = this->root;
552 child->source = this->source;
553 child->tokens = this->tokens;
554 child->inject_dependencies();
555 }
556 }
557 };
558
559 template<class Iter, class Value, class FuncType>
560 struct Variable : public Nullary<Iter,Value,FuncType>
561 {
562 Value name;
563
564 virtual Value accept(FuncType &f)
565 {
566 return f(*this);
567 }
568 };
569
570 template<class Iter, class Value, class FuncType>
571 struct GlobalVariable : public Variable<Iter,Value,FuncType>
572 {
573 virtual Value accept(FuncType &f)
574 {
575 return f(*this);
576 }
577 };
578
579 template<class Iter, class Value, class FuncType>
580 struct LocalVariable : public Variable<Iter,Value,FuncType>
581 {
582 virtual Value accept(FuncType &f)
583 {
584 return f(*this);
585 }
586 };
587
588 template<class Iter, class Value, class FuncType>
589 struct FieldName : public Nullary<Iter,Value,FuncType>
590 {
591 Value name;
592 virtual Value accept(FuncType &f)
593 {
594 return f(*this);
595 }
596 };
597
598 template<class Iter, class Value, class FuncType>
599 struct Nop : public Nullary<Iter,Value,FuncType>
600 {
601 double value;
602 virtual Value accept(FuncType &f)
603 {
604 return f(*this);
605 }
606 };
607
608 template<class Iter, class Value, class FuncType>
609 struct Constant : public Nullary<Iter,Value,FuncType>
610 {
611 Value value;
612
613 virtual Value accept(FuncType &f)
614 {
615 return f(*this);
616 }
617 };
618
619 template<class Iter, class Value, class FuncType>
620 struct Nil : public Nullary<Iter,Value,FuncType>
621 {
622 virtual Value accept(FuncType &f)
623 {
624 return f(*this);
625 }
626 };
627
628 template<class Iter, class Value, class FuncType>
629 struct String : public Nullary<Iter,Value,FuncType>
630 {
631 Value value;
632
633 virtual Value accept(FuncType &f)
634 {
635 return f(*this);
636 }
637 };
638
639 template<class Iter, class Value, class FuncType>
640 struct FieldAccess : public Binary<Iter,Value,FuncType>
641 {
642 virtual Value accept(FuncType &f)
643 {
644 return f(*this);
645 }
646 };
647
648 template<class Iter, class Value, class FuncType>
649 struct FieldAssignment : public Ternary<Iter,Value,FuncType>
650 {
651 virtual Value accept(FuncType &f)
652 {
653 return f(*this);
654 }
655 };
656
657 template<class Iter, class Value, class FuncType>
658 struct AddFieldAssignment : public FieldAssignment<Iter,Value,FuncType>
659 {
660 virtual Value accept(FuncType &f)
661 {
662 return f(*this);
663 }
664 };
665
666 template<class Iter, class Value, class FuncType>
667 struct SubFieldAssignment : public FieldAssignment<Iter,Value,FuncType>
668 {
669 virtual Value accept(FuncType &f)
670 {
671 return f(*this);
672 }
673 };
674
675 template<class Iter, class Value, class FuncType>
676 struct MulFieldAssignment : public FieldAssignment<Iter,Value,FuncType>
677 {
678 virtual Value accept(FuncType &f)
679 {
680 return f(*this);
681 }
682 };
683
684 template<class Iter, class Value, class FuncType>
685 struct DivFieldAssignment : public FieldAssignment<Iter,Value,FuncType>
686 {
687 virtual Value accept(FuncType &f)
688 {
689 return f(*this);
690 }
691 };
692
693 template<class Iter, class Value, class FuncType>
694 struct ModFieldAssignment : public FieldAssignment<Iter,Value,FuncType>
695 {
696 virtual Value accept(FuncType &f)
697 {
698 return f(*this);
699 }
700 };
701
702 template<class Iter, class Value, class FuncType>
703 struct Call : public Variadic<Iter,Value,FuncType>
704 {
705 virtual Value accept(FuncType &f)
706 {
707 return f(*this);
708 }
709 };
710
711 template<class Iter, class Value, class FuncType>
712 struct MemberCall : public Variadic<Iter,Value,FuncType>
713 {
714 virtual Value accept(FuncType &f)
715 {
716 return f(*this);
717 }
718 };
719
720 template<class Iter, class Value, class FuncType>
721 struct EvalStatement : public Unary<Iter,Value,FuncType>
722 {
723 virtual Value accept(FuncType &f)
724 {
725 return f(*this);
726 }
727 };
728
729 template<class Iter, class Value, class FuncType>
730 struct Eval : public Unary<Iter,Value,FuncType>
731 {
732 virtual Value accept(FuncType &f)
733 {
734 return f(*this);
735 }
736 };
737
738 template<class Iter, class Value, class FuncType>
739 struct ParseStatement : public Unary<Iter,Value,FuncType>
740 {
741 virtual Value accept(FuncType &f)
742 {
743 return f(*this);
744 }
745 };
746
747 template<class Iter, class Value, class FuncType>
748 struct ParseExpression : public Unary<Iter,Value,FuncType>
749 {
750 virtual Value accept(FuncType &f)
751 {
752 return f(*this);
753 }
754 };
755
756 template<class Iter, class Value, class FuncType>
757 struct UnaryExpression : public Unary<Iter,Value,FuncType>
758 {
759 virtual Value accept(FuncType &f)
760 {
761 return f(*this);
762 }
763 };
764
765 template<class Iter, class Value, class FuncType>
766 struct UnaryPlusExpression : public UnaryExpression<Iter,Value,FuncType>
767 {
768 virtual Value accept(FuncType &f)
769 {
770 return f(*this);
771 }
772 };
773
774 template<class Iter, class Value, class FuncType>
775 struct UnaryMinusExpression : public UnaryExpression<Iter,Value,FuncType>
776 {
777 virtual Value accept(FuncType &f)
778 {
779 return f(*this);
780 }
781 };
782
783 template<class Iter, class Value, class FuncType>
784 struct UnaryNotExpression : public UnaryExpression<Iter,Value,FuncType>
785 {
786 virtual Value accept(FuncType &f)
787 {
788 return f(*this);
789 }
790 };
791
792 template<class Iter, class Value, class FuncType>
793 struct MultiplicativeExpression : public Binary<Iter,Value,FuncType>
794 {
795 virtual Value accept(FuncType &f)
796 {
797 return f(*this);
798 }
799 };
800
801 template<class Iter, class Value, class FuncType>
802 struct MultiplyExpression : public MultiplicativeExpression<Iter,Value,FuncType>
803 {
804 virtual Value accept(FuncType &f)
805 {
806 return f(*this);
807 }
808 };
809
810 template<class Iter, class Value, class FuncType>
811 struct DivideExpression : public MultiplicativeExpression<Iter,Value,FuncType>
812 {
813 virtual Value accept(FuncType &f)
814 {
815 return f(*this);
816 }
817 };
818
819 template<class Iter, class Value, class FuncType>
820 struct ModuloExpression : public MultiplicativeExpression<Iter,Value,FuncType>
821 {
822 virtual Value accept(FuncType &f)
823 {
824 return f(*this);
825 }
826 };
827
828 template<class Iter, class Value, class FuncType>
829 struct AdditiveExpression : public Binary<Iter,Value,FuncType>
830 {
831 virtual Value accept(FuncType &f)
832 {
833 return f(*this);
834 }
835 };
836
837 template<class Iter, class Value, class FuncType>
838 struct AddExpression : public AdditiveExpression<Iter,Value,FuncType>
839 {
840 virtual Value accept(FuncType &f)
841 {
842 return f(*this);
843 }
844 };
845
846 template<class Iter, class Value, class FuncType>
847 struct SubtractExpression : public AdditiveExpression<Iter,Value,FuncType>
848 {
849 virtual Value accept(FuncType &f)
850 {
851 return f(*this);
852 }
853 };
854
855 template<class Iter, class Value, class FuncType>
856 struct RelationalExpression : public Binary<Iter,Value,FuncType>
857 {
858 virtual Value accept(FuncType &f)
859 {
860 return f(*this);
861 }
862 };
863
864 template<class Iter, class Value, class FuncType>
865 struct LessExpression : public RelationalExpression<Iter,Value,FuncType>
866 {
867 virtual Value accept(FuncType &f)
868 {
869 return f(*this);
870 }
871 };
872
873 template<class Iter, class Value, class FuncType>
874 struct LessEqualExpression : public RelationalExpression<Iter,Value,FuncType>
875 {
876 virtual Value accept(FuncType &f)
877 {
878 return f(*this);
879 }
880 };
881
882 template<class Iter, class Value, class FuncType>
883 struct GreaterExpression : public RelationalExpression<Iter,Value,FuncType>
884 {
885 virtual Value accept(FuncType &f)
886 {
887 return f(*this);
888 }
889 };
890
891 template<class Iter, class Value, class FuncType>
892 struct GreaterEqualExpression : public RelationalExpression<Iter,Value,FuncType>
893 {
894 virtual Value accept(FuncType &f)
895 {
896 return f(*this);
897 }
898 };
899
900 template<class Iter, class Value, class FuncType>
901 struct EqualityExpression : public Binary<Iter,Value,FuncType>
902 {
903 virtual Value accept(FuncType &f)
904 {
905 return f(*this);
906 }
907 };
908
909 template<class Iter, class Value, class FuncType>
910 struct EqualExpression : public EqualityExpression<Iter,Value,FuncType>
911 {
912 virtual Value accept(FuncType &f)
913 {
914 return f(*this);
915 }
916 };
917
918 template<class Iter, class Value, class FuncType>
919 struct NotEqualExpression : public EqualityExpression<Iter,Value,FuncType>
920 {
921 virtual Value accept(FuncType &f)
922 {
923 return f(*this);
924 }
925 };
926
927 template<class Iter, class Value, class FuncType>
928 struct LogicalAndExpression : public Binary<Iter,Value,FuncType>
929 {
930 virtual Value accept(FuncType &f)
931 {
932 return f(*this);
933 }
934 };
935
936 template<class Iter, class Value, class FuncType>
937 struct LogicalOrExpression : public Binary<Iter,Value,FuncType>
938 {
939 virtual Value accept(FuncType &f)
940 {
941 return f(*this);
942 }
943 };
944
945 template<class Iter, class Value, class FuncType>
946 struct AssignmentExpression : public Binary<Iter,Value,FuncType>
947 {
948 virtual Value accept(FuncType &f)
949 {
950 return f(*this);
951 }
952 };
953
954 template<class Iter, class Value, class FuncType>
955 struct GlobalAssignmentExpression : public AssignmentExpression<Iter,Value,FuncType>
956 {
957 virtual Value accept(FuncType &f)
958 {
959 return f(*this);
960 }
961 };
962
963 template<class Iter, class Value, class FuncType>
964 struct LocalAssignmentExpression : public AssignmentExpression<Iter,Value,FuncType>
965 {
966 virtual Value accept(FuncType &f)
967 {
968 return f(*this);
969 }
970 };
971
972 template<class Iter, class Value, class FuncType>
973 struct AddAssignmentExpression : public AssignmentExpression<Iter,Value,FuncType>
974 {
975 virtual Value accept(FuncType &f)
976 {
977 return f(*this);
978 }
979 };
980
981 template<class Iter, class Value, class FuncType>
982 struct SubAssignmentExpression : public AssignmentExpression<Iter,Value,FuncType>
983 {
984 virtual Value accept(FuncType &f)
985 {
986 return f(*this);
987 }
988 };
989
990 template<class Iter, class Value, class FuncType>
991 struct MulAssignmentExpression : public AssignmentExpression<Iter,Value,FuncType>
992 {
993 virtual Value accept(FuncType &f)
994 {
995 return f(*this);
996 }
997 };
998
999 template<class Iter, class Value, class FuncType>
1000 struct DivAssignmentExpression : public AssignmentExpression<Iter,Value,FuncType>
1001 {
1002 virtual Value accept(FuncType &f)
1003 {
1004 return f(*this);
1005 }
1006 };
1007
1008 template<class Iter, class Value, class FuncType>
1009 struct ModAssignmentExpression : public AssignmentExpression<Iter,Value,FuncType>
1010 {
1011 virtual Value accept(FuncType &f)
1012 {
1013 return f(*this);
1014 }
1015 };
1016
1017 template<class Iter, class Value, class FuncType>
1018 struct InitializerAssignmentExpression : public Variadic<Iter,Value,FuncType>
1019 {
1020 virtual Value accept(FuncType &f)
1021 {
1022 return f(*this);
1023 }
1024 };
1025
1026 template<class Iter, class Value, class FuncType>
1027 struct Block : public Unary<Iter,Value,FuncType>
1028 {
1029 virtual Value accept(FuncType &f)
1030 {
1031 return f(*this);
1032 }
1033 };
1034
1035 template<class Iter, class Value, class FuncType>
1036 struct TableInitializer : public Variadic<Iter,Value,FuncType>
1037 {
1038 virtual Value accept(FuncType &f)
1039 {
1040 return f(*this);
1041 }
1042 };
1043
1044 template<class Iter, class Value, class FuncType>
1045 struct ArrayInitializer : public Variadic<Iter,Value,FuncType>
1046 {
1047 virtual Value accept(FuncType &f)
1048 {
1049 return f(*this);
1050 }
1051 };
1052
1053 template<class Iter, class Value, class FuncType>
1054 struct IdentifierList : public Variadic<Iter,Value,FuncType>
1055 {
1056 virtual Value accept(FuncType &f)
1057 {
1058 return f(*this);
1059 }
1060 };
1061
1062 template<class Iter, class Value, class FuncType>
1063 struct Function : public Binary<Iter,Value,FuncType>
1064 {
1065 virtual Value accept(FuncType &f)
1066 {
1067 return f(*this);
1068 }
1069 };
1070
1071 template<class Iter, class Value, class FuncType>
1072 struct Tree : public Unary<Iter,Value,FuncType>
1073 {
1074 virtual Value accept(FuncType &f)
1075 {
1076 return f(*this);
1077 }
1078 };
1079
1080 template<class Iter, class Value, class FuncType>
1081 struct Root : public Variadic<Iter,Value,FuncType>
1082 {
1083 virtual Value accept(FuncType &f)
1084 {
1085 return f(*this);
1086 }
1087 };
1088
1089 template<class Iter, class Value, class FuncType>
1090 struct Type : public Unary<Iter,Value,FuncType>
1091 {
1092 virtual Value accept(FuncType &f)
1093 {
1094 return f(*this);
1095 }
1096 };
1097
1098 template<class Iter, class Value, class FuncType>
1099 struct Size : public Unary<Iter,Value,FuncType>
1100 {
1101 virtual Value accept(FuncType &f)
1102 {
1103 return f(*this);
1104 }
1105 };
1106
1107 template<class Iter, class Value, class FuncType>
1108 struct StatementList : public Variadic<Iter,Value,FuncType>
1109 {
1110 virtual Value accept(FuncType &f)
1111 {
1112 return f(*this);
1113 }
1114 };
1115
1116 template<class Iter, class Value, class FuncType>
1117 struct IfStatement : public Variadic<Iter,Value,FuncType>
1118 {
1119 virtual Value accept(FuncType &f)
1120 {
1121 return f(*this);
1122 }
1123 };
1124
1125 template<class Iter, class Value, class FuncType>
1126 struct WhileStatement : public Binary<Iter,Value,FuncType>
1127 {
1128 virtual Value accept(FuncType &f)
1129 {
1130 return f(*this);
1131 }
1132 };
1133
1134 template<class Iter, class Value, class FuncType>
1135 struct ForStatement : public Variadic<Iter,Value,FuncType>
1136 {
1137 virtual Value accept(FuncType &f)
1138 {
1139 return f(*this);
1140 }
1141 };
1142
1143 template<class Iter, class Value, class FuncType>
1144 struct ForEachStatement : public Variadic<Iter,Value,FuncType>
1145 {
1146 virtual Value accept(FuncType &f)
1147 {
1148 return f(*this);
1149 }
1150 };
1151
1152 template<class Iter, class Value, class FuncType>
1153 struct ReturnStatement : public Variadic<Iter,Value,FuncType>
1154 {
1155 virtual Value accept(FuncType &f)
1156 {
1157 return f(*this);
1158 }
1159 };
1160
1161 template<class Iter, class Value, class FuncType>
1162 struct ContinueStatement : public Nullary<Iter,Value,FuncType>
1163 {
1164 virtual Value accept(FuncType &f)
1165 {
1166 return f(*this);
1167 }
1168 };
1169
1170 template<class Iter, class Value, class FuncType>
1171 struct BreakStatement : public Nullary<Iter,Value,FuncType>
1172 {
1173 virtual Value accept(FuncType &f)
1174 {
1175 return f(*this);
1176 }
1177 };
1178
1179 template<class Iter, class Value, class FuncType>
1180 struct ExpressionStatement : public Unary<Iter,Value,FuncType>
1181 {
1182 virtual Value accept(FuncType &f)
1183 {
1184 return f(*this);
1185 }
1186 };
1187
1188 template<class Iter, class Value, class FuncType>
1189 struct BuiltinFunction : public Nullary<Iter,Value,FuncType>
1190 {
1191 virtual Value accept(FuncType &f)
1192 {
1193 return f(*this);
1194 }
1195 std::function<void(Interpreter&, std::vector<Value>&)> function;
1196 };
1197
1198 template<class Iter, class Value, class FuncType>
1199 struct Parens : public Unary<Iter,Value,FuncType>
1200 {
1201 virtual Value accept(FuncType &f)
1202 {
1203 return f(*this);
1204 }
1205 };
1206
1207 template<class Value, class FuncType>
1208 class Parser
1209 {
1210 public:
1211 using Iter = std::vector<Token<std::string::iterator>>::iterator;
1212 using return_t = std::shared_ptr<ASTNode<Iter,Value,FuncType>>;
1213
1214 template<typename StrIter>
1215 return_t operator()(StrIter sbegin, StrIter send)
1216 {
1217 auto source = std::make_shared<std::string>(sbegin, send);
1218 auto tokens = tokenize(source->begin(), source->end());
1219 this->begin = tokens->begin();
1220 this->end = tokens->end();
1221 i = this->begin;
1222 accepted = this->end;
1223 auto node = statement_list();
1224 node->source = source;
1225 node->tokens = tokens;
1226 node->root = node;
1227 node->inject_dependencies();
1228 return node;
1229 }
1230
1231 template<class StrIter>
1232 return_t parse_expression(StrIter sbegin, StrIter send)
1233 {
1234 auto source = std::make_shared<std::string>(sbegin, send);
1235 auto tokens = tokenize(source->begin(), source->end());
1236 this->begin = tokens->begin();
1237 this->end = tokens->end();
1238 i = this->begin;
1239 accepted = this->end;
1240 auto node = expression();
1241 node->source = source;
1242 node->tokens = tokens;
1243 node->root = node;
1244 node->inject_dependencies();
1245 return node;
1246 }
1247
1248 private:
1249 Iter i;
1250 Iter accepted;
1251 Iter begin;
1252 Iter end;
1253
1254 void advance()
1255 {
1256 if(i==end)
1257 {
1258 Iter last = end-1;
1259 auto lc = line_column(begin->begin, last->end);
1260 throw std::runtime_error(
1261 std::to_string(lc.first) + ":" +
1262 std::to_string(lc.second) + ": unexpected end of input at");
1263 }
1264 else
1265 {
1266 ++i;
1267 }
1268 }
1269
1270 void rewind(Iter pos)
1271 {
1272 i = pos;
1273 }
1274
1275 bool peek(TokenType t, int amount = 0)
1276 {
1277 return (((i+amount) != end) && (((i+amount)->type) == t));
1278 }
1279
1280 bool accept(TokenType t)
1281 {
1282 if(i != end && i->type == t)
1283 {
1284 accepted = i;
1285 advance();
1286 return true;
1287 }
1288 else
1289 {
1290 return false;
1291 }
1292 }
1293
1294 bool end_of_input()
1295 {
1296 return (i == end);
1297 }
1298
1299 bool expect(TokenType t)
1300 {
1301 if(accept(t))
1302 {
1303 return true;
1304 }
1305 else
1306 {
1307 i = std::min(i, end-1);
1308 auto lc = line_column(begin->begin, i->begin);
1309 throw std::runtime_error(
1310 std::to_string(lc.first) + ":" +
1311 std::to_string(lc.second) + ": unexpected token '" +
1312 std::string(i->begin, i->end) + "'"
1313 );
1314 return false;
1315 }
1316 }
1317
1318 void expect(const std::string &expected)
1319 {
1320 i = std::min(i, end-1);
1321 auto lc = line_column(begin->begin, i->begin);
1322 throw std::runtime_error(
1323 std::to_string(lc.first) + ":" +
1324 std::to_string(lc.second) + ": expected " +
1325 expected+ " but got '" + std::string(i->begin, i->end) + "'"
1326 );
1327 }
1328
1329 return_t variable()
1330 {
1331 expect(Tok_Identifier);
1332 auto node = std::make_shared<Variable<Iter,Value,FuncType>>();
1333 node->begin = accepted;
1334 node->end = accepted+1;
1335 node->name = Value(accepted->begin, accepted->end);
1336 return std::move(node);
1337 }
1338
1339 return_t field_name()
1340 {
1341 expect(Tok_Identifier);
1342 auto node = std::make_shared<FieldName<Iter,Value,FuncType>>();
1343 node->begin = accepted;
1344 node->end = accepted+1;
1345 node->name = Value(accepted->begin, accepted->end);
1346 return std::move(node);
1347 }
1348
1349 return_t identifier_list()
1350 {
1351 auto node = std::make_shared<IdentifierList<Iter,Value,FuncType>>();
1352 node->begin = i;
1353 expect(Tok_LeftParen);
1354 while(!accept(Tok_RightParen))
1355 {
1356 node->children.push_back(field_name());
1357 if(!peek(Tok_RightParen))
1358 {
1359 accept(Tok_Comma);
1360 }
1361 }
1362 node->end = accepted+1;
1363 return std::move(node);
1364 }
1365
1366 return_t function()
1367 {
1368 auto node = std::make_shared<Function<Iter,Value,FuncType>>();
1369 node->begin = i;
1370 expect(Tok_Function);
1371 node->children[0] = identifier_list();
1372 node->children[1] = statement();
1373 node->end = accepted+1;
1374 return std::move(node);
1375 }
1376
1377 return_t parse_expression()
1378 {
1379 auto node = std::make_shared<ParseExpression<Iter,Value,FuncType>>();
1380 node->begin = i;
1381 expect(Tok_ParseExpression);
1382 expect(Tok_LeftParen);
1383 node->children[0] = expression();
1384 expect(Tok_RightParen);
1385 node->end = accepted+1;
1386 return std::move(node);
1387 }
1388
1389 return_t parse_statement()
1390 {
1391 auto node = std::make_shared<ParseStatement<Iter,Value,FuncType>>();
1392 node->begin = i;
1393 expect(Tok_ParseStatement);
1394 expect(Tok_LeftParen);
1395 node->children[0] = expression();
1396 expect(Tok_RightParen);
1397 node->end = accepted+1;
1398 return std::move(node);
1399 }
1400
1401 return_t tree()
1402 {
1403 auto node = std::make_shared<Tree<Iter,Value,FuncType>>();
1404 node->begin = i;
1405 if(accept(Tok_Expression))
1406 {
1407 expect(Tok_LeftParen);
1408 node->children[0] = expression();
1409 expect(Tok_RightParen);
1410 }
1411 else
1412 {
1413 expect(Tok_Statement);
1414 expect(Tok_LeftParen);
1415 node->children[0] = statement();
1416 expect(Tok_RightParen);
1417 }
1418 node->end = accepted+1;
1419 return std::move(node);
1420 }
1421
1422 return_t root()
1423 {
1424 auto node = std::make_shared<Root<Iter,Value,FuncType>>();
1425 node->begin = i;
1426 expect(Tok_Root);
1427 if(accept(Tok_LeftParen))
1428 {
1429 node->children.push_back(expression());
1430 expect(Tok_RightParen);
1431 }
1432 node->end = accepted+1;
1433 return std::move(node);
1434 }
1435
1436 return_t eval()
1437 {
1438 auto node = std::make_shared<Eval<Iter,Value,FuncType>>();
1439 node->begin = i;
1440 expect(Tok_Eval);
1441 expect(Tok_LeftParen);
1442 node->children[0] = unary_expression();
1443 expect(Tok_RightParen);
1444 node->end = accepted+1;
1445 return std::move(node);
1446 }
1447
1448 return_t type()
1449 {
1450 auto node = std::make_shared<Type<Iter,Value,FuncType>>();
1451 node->begin = i;
1452 expect(Tok_Type);
1453 if(accept(Tok_LeftParen))
1454 {
1455 node->children[0] = expression();
1456 expect(Tok_RightParen);
1457 }
1458 node->end = accepted+1;
1459 return std::move(node);
1460 }
1461
1462 return_t size()
1463 {
1464 auto node = std::make_shared<Size<Iter,Value,FuncType>>();
1465 node->begin = i;
1466 expect(Tok_Size);
1467 if(accept(Tok_LeftParen))
1468 {
1469 node->children[0] = expression();
1470 expect(Tok_RightParen);
1471 }
1472 node->end = accepted+1;
1473 return std::move(node);
1474 }
1475
1476 return_t table_initializer()
1477 {
1478 auto node = std::make_shared<TableInitializer<Iter,Value,FuncType>>();
1479 node->begin = i;
1480 expect(Tok_LeftBrace);
1481 while(!accept(Tok_RightBrace))
1482 {
1483 node->children.push_back(initializer_assignment_expression());
1484 if(!peek(Tok_RightBrace))
1485 {
1486 accept(Tok_Comma);
1487 }
1488 }
1489 node->end = accepted+1;
1490 return std::move(node);
1491 }
1492
1493 return_t array_initializer()
1494 {
1495 auto node = std::make_shared<ArrayInitializer<Iter,Value,FuncType>>();
1496 node->begin = i;
1497 expect(Tok_LeftBracket);
1498 while(!accept(Tok_RightBracket))
1499 {
1500 node->children.push_back(logical_or_expression());
1501 if(!peek(Tok_RightBracket))
1502 {
1503 accept(Tok_Comma);
1504 }
1505 }
1506 node->end = accepted+1;
1507 return std::move(node);
1508 }
1509
1510 return_t primary_expression()
1511 {
1512 if (peek(Tok_Identifier) || peek(Tok_Global) || peek(Tok_Local))
1513 {
1514 return variable();
1515 }
1516 else if (accept(Tok_Number))
1517 {
1518 auto node = std::make_shared<Constant<Iter,Value,FuncType>>();
1519 node->begin = accepted;
1520 node->end = accepted+1;
1521 node->value = std::stod(std::string(accepted->begin, accepted->end));
1522 return std::move(node);
1523 }
1524 else if (accept(Tok_Nil))
1525 {
1526 auto node = std::make_shared<Nil<Iter,Value,FuncType>>();
1527 node->begin = accepted;
1528 node->end = accepted+1;
1529 return std::move(node);
1530 }
1531 else if (accept(Tok_String))
1532 {
1533 auto node = std::make_shared<String<Iter,Value,FuncType>>();
1534 node->begin = accepted;
1535 node->end = accepted+1;
1536 node->value = Value(unescape(std::string(accepted->begin+1, accepted->end-1)));
1537 return std::move(node);
1538 }
1539 else if (accept(Tok_LeftParen))
1540 {
1541 auto node = std::make_shared<Parens<Iter,Value,FuncType>>();
1542 node->begin = accepted;
1543 node->children[0] = expression();
1544 expect(Tok_RightParen);
1545 node->end = accepted+1;
1546 return std::move(node);
1547 }
1548 else if (peek(Tok_LeftBrace))
1549 {
1550 return table_initializer();
1551 }
1552 else if (peek(Tok_LeftBracket))
1553 {
1554 return array_initializer();
1555 }
1556 else if (peek(Tok_Expression) || peek(Tok_Statement))
1557 {
1558 return tree();
1559 }
1560 else if (peek(Tok_Root))
1561 {
1562 return root();
1563 }
1564 else if (peek(Tok_Type))
1565 {
1566 return type();
1567 }
1568 else if (peek(Tok_Eval))
1569 {
1570 return eval();
1571 }
1572 else if (peek(Tok_Size))
1573 {
1574 return size();
1575 }
1576 else if (peek(Tok_ParseExpression))
1577 {
1578 return parse_expression();
1579 }
1580 else if (peek(Tok_ParseStatement))
1581 {
1582 return parse_statement();
1583 }
1584 else if (peek(Tok_Function))
1585 {
1586 return function();
1587 }
1588 else
1589 {
1590 expect("primary expression");
1591 return nullptr;
1592 }
1593 }
1594
1595 return_t postfix_expression()
1596 {
1597 Iter from = i;
1598 return_t left = primary_expression();
1599 while(true)
1600 {
1601 if(accept(Tok_LeftBracket))
1602 {
1603 return_t right = expression();
1604 expect(Tok_RightBracket);
1605 if(peek(Tok_Equal) || peek(Tok_PlusEqual) || peek(Tok_DashEqual) ||
1606 peek(Tok_StarEqual) || peek(Tok_SlashEqual) || peek(Tok_PercentEqual))
1607 {
1608 std::shared_ptr<FieldAssignment<Iter,Value,FuncType>> node;
1609 if(accept(Tok_Equal))
1610 {
1611 node = std::make_shared<FieldAssignment<Iter,Value,FuncType>>();
1612 }
1613 else if(accept(Tok_PlusEqual))
1614 {
1615 node = std::make_shared<AddFieldAssignment<Iter,Value,FuncType>>();
1616 }
1617 else if(accept(Tok_DashEqual))
1618 {
1619 node = std::make_shared<SubFieldAssignment<Iter,Value,FuncType>>();
1620 }
1621 else if(accept(Tok_StarEqual))
1622 {
1623 node = std::make_shared<MulFieldAssignment<Iter,Value,FuncType>>();
1624 }
1625 else if(accept(Tok_SlashEqual))
1626 {
1627 node = std::make_shared<DivFieldAssignment<Iter,Value,FuncType>>();
1628 }
1629 else if(accept(Tok_PercentEqual))
1630 {
1631 node = std::make_shared<ModFieldAssignment<Iter,Value,FuncType>>();
1632 }
1633 node->begin = from;
1634 node->children[0] = std::move(left);
1635 node->children[1] = std::move(right);
1636 node->children[2] = expression();
1637 node->end = accepted+1;
1638 left = std::move(node);
1639 }
1640 else
1641 {
1642 auto node = std::make_shared<FieldAccess<Iter,Value,FuncType>>();
1643 node->begin = from;
1644 node->children[0] = std::move(left);
1645 node->children[1] = std::move(right);
1646 node->end = accepted+1;
1647 left = std::move(node);
1648 }
1649 }
1650 else if(accept(Tok_Dot))
1651 {
1652 return_t right = field_name();
1653 if(peek(Tok_Equal) || peek(Tok_PlusEqual) || peek(Tok_DashEqual) ||
1654 peek(Tok_StarEqual) || peek(Tok_SlashEqual) || peek(Tok_PercentEqual))
1655 {
1656 std::shared_ptr<FieldAssignment<Iter,Value,FuncType>> node;
1657 if(accept(Tok_Equal))
1658 {
1659 node = std::make_shared<FieldAssignment<Iter,Value,FuncType>>();
1660 }
1661 else if(accept(Tok_PlusEqual))
1662 {
1663 node = std::make_shared<AddFieldAssignment<Iter,Value,FuncType>>();
1664 }
1665 else if(accept(Tok_DashEqual))
1666 {
1667 node = std::make_shared<SubFieldAssignment<Iter,Value,FuncType>>();
1668 }
1669 else if(accept(Tok_StarEqual))
1670 {
1671 node = std::make_shared<MulFieldAssignment<Iter,Value,FuncType>>();
1672 }
1673 else if(accept(Tok_SlashEqual))
1674 {
1675 node = std::make_shared<DivFieldAssignment<Iter,Value,FuncType>>();
1676 }
1677 else if(accept(Tok_PercentEqual))
1678 {
1679 node = std::make_shared<ModFieldAssignment<Iter,Value,FuncType>>();
1680 }
1681 node->begin = from;
1682 node->children[0] = std::move(left);
1683 node->children[1] = std::move(right);
1684 node->children[2] = expression();
1685 node->end = accepted+1;
1686 left = std::move(node);
1687 }
1688 else if(accept(Tok_LeftParen))
1689 {
1690 auto node = std::make_shared<MemberCall<Iter,Value,FuncType>>();
1691 node->begin = from;
1692 node->children.push_back(std::move(left));
1693 node->children.push_back(std::move(right));
1694 while(!accept(Tok_RightParen))
1695 {
1696 node->children.push_back(expression());
1697 if(!peek(Tok_RightParen))
1698 {
1699 accept(Tok_Comma);
1700 }
1701 }
1702 node->end = accepted+1;
1703 left = std::move(node);
1704 }
1705 else
1706 {
1707 auto node = std::make_shared<FieldAccess<Iter,Value,FuncType>>();
1708 node->begin = from;
1709 node->children[0] = std::move(left);
1710 node->children[1] = std::move(right);
1711 node->end = accepted+1;
1712 left = std::move(node);
1713 }
1714 }
1715 else if(accept(Tok_LeftParen))
1716 {
1717 auto node = std::make_shared<Call<Iter,Value,FuncType>>();
1718 node->begin = from;
1719 node->children.push_back(std::move(left));
1720 while(!accept(Tok_RightParen))
1721 {
1722 node->children.push_back(expression());
1723 if(!peek(Tok_RightParen))
1724 {
1725 accept(Tok_Comma);
1726 }
1727 }
1728 node->end = accepted+1;
1729 left = std::move(node);
1730 }
1731 else
1732 {
1733 return std::move(left);
1734 }
1735 }
1736 }
1737
1738 return_t unary_expression()
1739 {
1740 if(accept(Tok_Plus) || accept(Tok_Dash) || accept(Tok_Not))
1741 {
1742 using node_t = std::shared_ptr<UnaryExpression<Iter,Value,FuncType>>;
1743 node_t node;
1744 switch(accepted->type)
1745 {
1746 case Tok_Plus:
1747 node = node_t(new UnaryPlusExpression<Iter,Value,FuncType>);
1748 break;
1749 case Tok_Dash:
1750 node = node_t(new UnaryMinusExpression<Iter,Value,FuncType>);
1751 break;
1752 case Tok_Not:
1753 node = node_t(new UnaryNotExpression<Iter,Value,FuncType>);
1754 break;
1755 default:
1756 break;
1757 }
1758 node->begin = accepted;
1759 node->children[0] = postfix_expression();
1760 node->end = accepted+1;
1761 return std::move(node);
1762 }
1763 else
1764 {
1765 return postfix_expression();
1766 }
1767 }
1768
1769 return_t multiplicative_expression()
1770 {
1771 Iter from = i;
1772 return_t left = unary_expression();
1773 if(accept(Tok_Star) || accept(Tok_Slash) || accept(Tok_Percent))
1774 {
1775 using node_t = std::shared_ptr<MultiplicativeExpression<Iter,Value,FuncType>>;
1776 node_t node;
1777 switch(accepted->type)
1778 {
1779 case Tok_Star:
1780 node = node_t(new MultiplyExpression<Iter,Value,FuncType>);
1781 break;
1782 case Tok_Slash:
1783 node = node_t(new DivideExpression<Iter,Value,FuncType>);
1784 break;
1785 case Tok_Percent:
1786 node = node_t(new ModuloExpression<Iter,Value,FuncType>);
1787 break;
1788 default:
1789 break;
1790 }
1791 node->begin = from;
1792 node->children[0] = std::move(left);
1793 node->children[1] = multiplicative_expression();
1794 node->end = accepted+1;
1795 return std::move(node);
1796 }
1797 else
1798 {
1799 return std::move(left);
1800 }
1801 }
1802
1803 return_t additive_expression()
1804 {
1805 Iter from = i;
1806 return_t left = multiplicative_expression();
1807 if(accept(Tok_Plus) || accept(Tok_Dash))
1808 {
1809 using node_t = std::shared_ptr<AdditiveExpression<Iter,Value,FuncType>>;
1810 node_t node;
1811 switch(accepted->type)
1812 {
1813 case Tok_Plus:
1814 node = node_t(new AddExpression<Iter,Value,FuncType>);
1815 break;
1816 case Tok_Dash:
1817 node = node_t(new SubtractExpression<Iter,Value,FuncType>);
1818 break;
1819 default:
1820 break;
1821 }
1822 node->begin = from;
1823 node->children[0] = std::move(left);
1824 node->children[1] = additive_expression();
1825 node->end = accepted+1;
1826 return std::move(node);
1827 }
1828 else
1829 {
1830 return std::move(left);
1831 }
1832 }
1833
1834 return_t relational_expression()
1835 {
1836 Iter from = i;
1837 return_t left = additive_expression();
1838 if(accept(Tok_Less) || accept(Tok_LessEqual) || accept(Tok_Greater) || accept(Tok_GreaterEqual))
1839 {
1840 using node_t = std::shared_ptr<RelationalExpression<Iter,Value,FuncType>>;
1841 node_t node;
1842 switch(accepted->type)
1843 {
1844 case Tok_Less:
1845 node = node_t(new LessExpression<Iter,Value,FuncType>);
1846 break;
1847 case Tok_LessEqual:
1848 node = node_t(new LessEqualExpression<Iter,Value,FuncType>);
1849 break;
1850 case Tok_Greater:
1851 node = node_t(new GreaterExpression<Iter,Value,FuncType>);
1852 break;
1853 case Tok_GreaterEqual:
1854 node = node_t(new GreaterEqualExpression<Iter,Value,FuncType>);
1855 break;
1856 default:
1857 break;
1858 }
1859 node->begin = from;
1860 node->children[0] = std::move(left);
1861 node->children[1] = relational_expression();
1862 node->end = accepted+1;
1863 return std::move(node);
1864 }
1865 else
1866 {
1867 return std::move(left);
1868 }
1869 }
1870
1871 return_t equality_expression()
1872 {
1873 Iter from = i;
1874 return_t left = relational_expression();
1875 if(accept(Tok_EqOp) || accept(Tok_NotEqual))
1876 {
1877 using node_t = std::shared_ptr<EqualityExpression<Iter,Value,FuncType>>;
1878 node_t node;
1879 switch(accepted->type)
1880 {
1881 case Tok_EqOp:
1882 node = node_t(new EqualExpression<Iter,Value,FuncType>);
1883 break;
1884 case Tok_NotEqual:
1885 node = node_t(new NotEqualExpression<Iter,Value,FuncType>);
1886 break;
1887 default:
1888 break;
1889 }
1890 node->begin = from;
1891 node->children[0] = std::move(left);
1892 node->children[1] = relational_expression();
1893 node->end = accepted+1;
1894 return std::move(node);
1895 }
1896 else
1897 {
1898 return std::move(left);
1899 }
1900 }
1901
1902 return_t logical_and_expression()
1903 {
1904 Iter from = i;
1905 return_t left = equality_expression();
1906 if(accept(Tok_LogicalAnd))
1907 {
1908 auto node = std::make_shared<LogicalAndExpression<Iter,Value,FuncType>>();
1909 node->begin = from;
1910 node->children[0] = std::move(left);
1911 node->children[1] = equality_expression();
1912 node->end = accepted+1;
1913 return std::move(node);
1914 }
1915 else
1916 {
1917 return std::move(left);
1918 }
1919 }
1920
1921 return_t logical_or_expression()
1922 {
1923 Iter from = i;
1924 return_t left = logical_and_expression();
1925 if(accept(Tok_LogicalOr))
1926 {
1927 auto node = std::make_shared<LogicalOrExpression<Iter,Value,FuncType>>();
1928 node->begin = from;
1929 node->children[0] = std::move(left);
1930 node->children[1] = logical_and_expression();
1931 node->end = accepted+1;
1932 return std::move(node);
1933 }
1934 else
1935 {
1936 return std::move(left);
1937 }
1938 }
1939
1940 return_t assignment_expression()
1941 {
1942 Iter from = i;
1943 if(peek(Tok_Global) || peek(Tok_Local))
1944 {
1945 bool global = accept(Tok_Global);
1946 bool local = accept(Tok_Local);
1947 return_t left = field_name();
1948 if(accept(Tok_Equal))
1949 {
1950 std::shared_ptr<AssignmentExpression<Iter,Value,FuncType>> node;
1951 node =
1952 global ?
1953 std::make_shared<GlobalAssignmentExpression<Iter,Value,FuncType>>()
1954 :
1955 local ?
1956 std::make_shared<LocalAssignmentExpression<Iter,Value,FuncType>>()
1957 :
1958 std::make_shared<AssignmentExpression<Iter,Value,FuncType>>();
1959 node->begin = from;
1960 node->children[0] = std::move(left);
1961 node->children[1] = assignment_expression();
1962 node->end = accepted+1;
1963 return std::move(node);
1964 }
1965 }
1966 else if(peek(Tok_Identifier))
1967 {
1968 return_t left = field_name();
1969 std::shared_ptr<AssignmentExpression<Iter,Value,FuncType>> node;
1970 if(accept(Tok_Equal))
1971 {
1972 node = std::make_shared<AssignmentExpression<Iter,Value,FuncType>>();
1973 }
1974 else if(accept(Tok_PlusEqual))
1975 {
1976 node = std::make_shared<AddAssignmentExpression<Iter,Value,FuncType>>();
1977 }
1978 else if(accept(Tok_DashEqual))
1979 {
1980 node = std::make_shared<SubAssignmentExpression<Iter,Value,FuncType>>();
1981 }
1982 else if(accept(Tok_StarEqual))
1983 {
1984 node = std::make_shared<MulAssignmentExpression<Iter,Value,FuncType>>();
1985 }
1986 else if(accept(Tok_SlashEqual))
1987 {
1988 node = std::make_shared<DivAssignmentExpression<Iter,Value,FuncType>>();
1989 }
1990 else if(accept(Tok_PercentEqual))
1991 {
1992 node = std::make_shared<ModAssignmentExpression<Iter,Value,FuncType>>();
1993 }
1994 else
1995 {
1996 rewind(from);
1997 return logical_or_expression();
1998 }
1999 node->begin = from;
2000 node->children[0] = std::move(left);
2001 node->children[1] = assignment_expression();
2002 node->end = accepted+1;
2003 return std::move(node);
2004 }
2005 rewind(from);
2006 return logical_or_expression();
2007 }
2008
2009 return_t initializer_assignment_expression()
2010 {
2011 auto node = std::make_shared<InitializerAssignmentExpression<Iter,Value,FuncType>>();
2012 node->begin = i;
2013 node->children.push_back(logical_or_expression());
2014 if(accept(Tok_Equal))
2015 {
2016 node->children.push_back(logical_or_expression());
2017 }
2018 node->end = accepted+1;
2019 return std::move(node);
2020 }
2021
2022 return_t expression()
2023 {
2024 return assignment_expression();
2025 }
2026
2027 return_t block()
2028 {
2029 auto node = std::make_shared<Block<Iter,Value,FuncType>>();
2030 node->begin = i;
2031 expect(Tok_LeftBrace);
2032 node->children[0] = statement_list();
2033 expect(Tok_RightBrace);
2034 node->end = accepted+1;
2035 return std::move(node);
2036 }
2037
2038 return_t if_statement()
2039 {
2040 auto node = std::make_shared<IfStatement<Iter,Value,FuncType>>();
2041 node->begin = i;
2042 expect(Tok_If);
2043 expect(Tok_LeftParen);
2044 node->children.push_back(expression());
2045 expect(Tok_RightParen);
2046 node->children.push_back(statement());
2047 if(accept(Tok_Else))
2048 {
2049 node->children.push_back(statement());
2050 }
2051 node->end = accepted+1;
2052 return std::move(node);
2053 }
2054
2055 return_t while_statement()
2056 {
2057 auto node = std::make_shared<WhileStatement<Iter,Value,FuncType>>();
2058 node->begin = i;
2059 expect(Tok_While);
2060 expect(Tok_LeftParen);
2061 node->children[0] = expression();
2062 expect(Tok_RightParen);
2063 node->children[1] = statement();
2064 node->end = accepted+1;
2065 return std::move(node);
2066 }
2067
2068 return_t nop()
2069 {
2070 auto node = std::make_shared<Nop<Iter,Value,FuncType>>();
2071 node->begin = i;
2072 node->end = i;
2073 return std::move(node);
2074 }
2075
2076 return_t for_statement()
2077 {
2078 Iter from = i;
2079 expect(Tok_For);
2080 expect(Tok_LeftParen);
2081 if(peek(Tok_Identifier) && (peek(Tok_Comma, 1) || peek(Tok_Colon, 1)))
2082 {
2083 auto node = std::make_shared<ForEachStatement<Iter,Value,FuncType>>();
2084 node->begin = from;
2085 node->children.push_back(field_name());
2086 if(accept(Tok_Comma))
2087 {
2088 node->children.push_back(field_name());
2089 }
2090 expect(Tok_Colon);
2091 node->children.push_back(expression());
2092 expect(Tok_RightParen);
2093 node->children.push_back(statement());
2094 node->end = accepted+1;
2095 return std::move(node);
2096 }
2097 else
2098 {
2099 auto node = std::make_shared<ForStatement<Iter,Value,FuncType>>();
2100 node->begin = from;
2101 if(accept(Tok_Semicolon))
2102 {
2103 node->children.push_back(nop());
2104 }
2105 else
2106 {
2107 node->children.push_back(expression());
2108 expect(Tok_Semicolon);
2109 }
2110 if(accept(Tok_Semicolon))
2111 {
2112 node->children.push_back(nop());
2113 }
2114 else
2115 {
2116 node->children.push_back(expression());
2117 expect(Tok_Semicolon);
2118 }
2119 if(accept(Tok_RightParen))
2120 {
2121 node->children.push_back(nop());
2122 }
2123 else
2124 {
2125 node->children.push_back(expression());
2126 expect(Tok_RightParen);
2127 }
2128 node->children.push_back(statement());
2129 node->end = accepted+1;
2130 return std::move(node);
2131 }
2132 }
2133
2134 return_t break_statement()
2135 {
2136 auto node = std::make_shared<BreakStatement<Iter,Value,FuncType>>();
2137 node->begin = i;
2138 expect(Tok_Break);
2139 accept(Tok_Semicolon);
2140 node->end = accepted+1;
2141 return std::move(node);
2142 }
2143
2144 return_t continue_statement()
2145 {
2146 auto node = std::make_shared<ContinueStatement<Iter,Value,FuncType>>();
2147 node->begin = i;
2148 expect(Tok_Continue);
2149 accept(Tok_Semicolon);
2150 node->end = accepted+1;
2151 return std::move(node);
2152 }
2153
2154 return_t return_statement()
2155 {
2156 auto node = std::make_shared<ReturnStatement<Iter,Value,FuncType>>();
2157 node->begin = i;
2158 expect(Tok_Return);
2159 if(accept(Tok_Semicolon))
2160 {
2161 node->end = accepted+1;
2162 return std::move(node);
2163 }
2164 node->children.push_back(expression());
2165 accept(Tok_Semicolon);
2166 node->end = accepted+1;
2167 return std::move(node);
2168 }
2169
2170 return_t statement()
2171 {
2172 if(peek(Tok_LeftBrace))
2173 {
2174 return block();
2175 }
2176 else if (peek(Tok_If))
2177 {
2178 return if_statement();
2179 }
2180 else if (peek(Tok_While))
2181 {
2182 return while_statement();
2183 }
2184 else if (peek(Tok_For))
2185 {
2186 return for_statement();
2187 }
2188 else if (peek(Tok_Return))
2189 {
2190 return return_statement();
2191 }
2192 else if (peek(Tok_Continue))
2193 {
2194 return continue_statement();
2195 }
2196 else if (peek(Tok_Break))
2197 {
2198 return break_statement();
2199 }
2200 else
2201 {
2202 auto node = std::make_shared<ExpressionStatement<Iter,Value,FuncType>>();
2203 node->begin = i;
2204 node->children[0] = expression();
2205 accept(Tok_Semicolon);
2206 node->end = accepted+1;
2207 return std::move(node);
2208 }
2209 }
2210 return_t statement_list()
2211 {
2212 auto node = std::make_shared<StatementList<Iter,Value,FuncType>>();
2213 node->begin = i;
2214 while(!end_of_input() && !peek(Tok_RightBrace))
2215 {
2216 node->children.push_back(statement());
2217 }
2218 node->end = accepted+1;
2219 return std::move(node);
2220 }
2221 };
2222 }
2223
2224 template<typename T> class Table;
2225
2226 template<typename T> class Array;
2227
2228 template<typename Iter, typename FuncType>
2229 struct BaseValue
2230 {
2231 using NumberType = double;
2232 using StringContainer = std::string;
2233 using StringIterator = StringContainer::iterator;
2234 using NumberContainer = NumberType;
2235 using PointerContainer = std::shared_ptr<Internal::ASTNode<Iter, BaseValue, FuncType>>;
2236 using FunctionContainer = std::shared_ptr<Internal::Function<Iter,BaseValue,FuncType>>;
2237 using TreeContainer = PointerContainer;
2238 using ArrayContainer = std::shared_ptr<Array<BaseValue>>;
2239 using TableContainer = std::shared_ptr<Table<BaseValue>>;
2240
2241 struct ProtoStringContainer
2242 {
2243 StringIterator begin;
2244 StringIterator end;
2245 size_t hash;
2246
2247 ProtoStringContainer(StringIterator begin_, StringIterator end_):
2248 begin(begin_),
2249 end(end_),
2250 hash(std::hash<StringContainer>()(StringContainer(begin_, end_)))
2251 {
2252 }
2253 };
2254
2255 struct UserPtrContainer
2256 {
2257 void* realptr;
2258
2259 UserPtrContainer(void* ptr): realptr(ptr)
2260 {
2261 }
2262 };
2263
2264 class TagReturn
2265 {
2266 };
2267
2268 class TagBreak
2269 {
2270 };
2271
2272 class TagContinue
2273 {
2274 };
2275
2276 enum class Type
2277 {
2278 Nil, Number, String, ProtoString,
2279 Tree, Function, Table, Array,
2280 Return, Break, Continue, UserPtr,
2281 };
2282
2283 private:
2284 Type m_type;
2285 union
2286 {
2287 NumberContainer m_number;
2288 PointerContainer m_pointer;
2289 UserPtrContainer m_userptr;
2290 TableContainer m_table;
2291 ArrayContainer m_array;
2292 StringContainer m_strval;
2293 ProtoStringContainer m_protostr;
2294 };
2295
2296 public:
2297 Type type() const
2298 {
2299 if(m_type == Type::ProtoString)
2300 {
2301 return Type::String;
2302 }
2303 else if((m_type >= Type::Return) && (m_type <= Type::Continue))
2304 {
2305 return Type::Nil;
2306 }
2307 return m_type;
2308 }
2309
2310 const char* typeName() const
2311 {
2312 switch(type())
2313 {
2314 case Type::Nil:
2315 return "nil";
2316 case Type::Number:
2317 return "number";
2318 case Type::String:
2319 return "string";
2320 case Type::ProtoString:
2321 return "protostring";
2322 case Type::Tree:
2323 return "tree";
2324 case Type::Function:
2325 return "function";
2326 case Type::Table:
2327 return "table";
2328 case Type::Array:
2329 return "array";
2330 case Type::Return:
2331 return "return";
2332 case Type::Break:
2333 return "break";
2334 case Type::Continue:
2335 return "continue";
2336 case Type::UserPtr:
2337 return "userptr";
2338 default:
2339 ;
2340 }
2341 return "invalid";
2342 }
2343
2344 Type internal_type() const
2345 {
2346 return m_type;
2347 }
2348
2349 const NumberType& number() const
2350 {
2351 return m_number;
2352 }
2353
2354 NumberType& number()
2355 {
2356 return m_number;
2357 }
2358
2359 const PointerContainer& pointer() const
2360 {
2361 return m_pointer;
2362 }
2363
2364 PointerContainer& pointer()
2365 {
2366 return m_pointer;
2367 }
2368
2369 void*& userptr()
2370 {
2371 return m_userptr.realptr;
2372 }
2373
2374 const void* userptr() const
2375 {
2376 return m_userptr.realptr;
2377 }
2378
2379 const FunctionContainer function() const
2380 {
2381 return std::static_pointer_cast<Internal::Function<Iter,BaseValue,FuncType>>(m_pointer);
2382 }
2383
2384 FunctionContainer function()
2385 {
2386 return std::static_pointer_cast<Internal::Function<Iter,BaseValue,FuncType>>(m_pointer);
2387 }
2388
2389 const TreeContainer tree() const
2390 {
2391 return m_pointer;
2392 }
2393
2394 TreeContainer tree()
2395 {
2396 return m_pointer;
2397 }
2398
2399 const TableContainer& table() const
2400 {
2401 return m_table;
2402 }
2403
2404 TableContainer& table()
2405 {
2406 return m_table;
2407 }
2408
2409 const StringContainer string() const
2410 {
2411 if(m_type == Type::ProtoString)
2412 {
2413 return std::string(m_protostr.begin, m_protostr.end);
2414 }
2415 return m_strval;
2416 }
2417
2418 StringContainer& string()
2419 {
2420 decay();
2421 return m_strval;
2422 }
2423
2424 const ArrayContainer& array() const
2425 {
2426 return m_array;
2427 }
2428
2429 ArrayContainer& array()
2430 {
2431 return m_array;
2432 }
2433
2434 void decay()
2435 {
2436 if(m_type == Type::ProtoString)
2437 {
2438 StringIterator tmpbegin = m_protostr.begin;
2439 StringIterator tmpend = m_protostr.end;
2440 m_type = Type::String;
2441 new (&m_strval) StringContainer(tmpbegin, tmpend);
2442 }
2443 else if((m_type >= Type::Return) && (m_type <= Type::Continue))
2444 {
2445 m_type = Type::Nil;
2446 }
2447 }
2448
2449 BaseValue() : m_type(Type::Nil), m_number(0)
2450 {
2451 }
2452
2453 BaseValue(const TagReturn&) : m_type(Type::Return), m_number(0)
2454 {
2455 }
2456
2457 BaseValue(const TagBreak&) : m_type(Type::Break), m_number(0)
2458 {
2459 }
2460
2461 BaseValue(const TagContinue&) : m_type(Type::Continue), m_number(0)
2462 {
2463 }
2464
2465 BaseValue(NumberType value) : m_type(Type::Number), m_number(value)
2466 {
2467 }
2468
2469 BaseValue(Type t, const PointerContainer &ptr) : m_type(t), m_pointer(ptr)
2470 {
2471 }
2472
2473 BaseValue(UserPtrContainer ptr): m_type(Type::UserPtr), m_userptr(ptr.realptr)
2474 {
2475 //fprintf(stderr, "BaseValue/userpointer: ptr=%p\n", ptr.realptr);
2476 }
2477
2478 BaseValue(const TableContainer &ptr) : m_type(Type::Table), m_table(ptr)
2479 {
2480 }
2481
2482 BaseValue(const ArrayContainer &ptr) : m_type(Type::Array), m_array(ptr)
2483 {
2484 }
2485
2486 BaseValue(const StringContainer &value) : m_type(Type::String), m_strval(value)
2487 {
2488 }
2489
2490 BaseValue(StringIterator begin, StringIterator end) : m_type(Type::ProtoString), m_protostr(begin, end)
2491 {
2492 }
2493
2494 BaseValue(const BaseValue &that) : m_type(that.m_type)
2495 {
2496 switch(m_type)
2497 {
2498 case Type::Return:
2499 case Type::Break:
2500 case Type::Continue:
2501 case Type::Nil:
2502 new (&m_number) NumberContainer(0);
2503 break;
2504 case Type::Number:
2505 new (&m_number) NumberContainer(that.m_number);
2506 break;
2507 case Type::String:
2508 new (&m_strval) StringContainer(that.m_strval);
2509 break;
2510 case Type::ProtoString:
2511 new (&m_protostr) ProtoStringContainer(that.m_protostr);
2512 break;
2513 case Type::Tree:
2514 case Type::Function:
2515 new (&m_pointer) PointerContainer(that.m_pointer);
2516 break;
2517 case Type::Table:
2518 new (&m_table) TableContainer(that.m_table);
2519 break;
2520 case Type::Array:
2521 new (&m_array) ArrayContainer(that.m_array);
2522 break;
2523 case Type::UserPtr:
2524 #if 0
2525 fprintf(stderr, "BaseValue(BaseValue&): this.userptr=%p, that.userptr=%p\n",
2526 m_userptr.realptr, that.m_userptr.realptr
2527 );
2528 #endif
2529 new (&m_userptr) UserPtrContainer(that.m_userptr);
2530 break;
2531 default:
2532 break;
2533 }
2534 }
2535
2536 BaseValue& operator=(const BaseValue &that)
2537 {
2538 switch(m_type)
2539 {
2540 case Type::String:
2541 m_strval.~StringContainer();
2542 break;
2543 case Type::Tree:
2544 case Type::Function:
2545 m_pointer.~PointerContainer();
2546 break;
2547 case Type::Table:
2548 m_table.~TableContainer();
2549 break;
2550 case Type::Array:
2551 m_array.~ArrayContainer();
2552 break;
2553 default:
2554 break;
2555 }
2556 m_type = that.m_type;
2557 switch(m_type)
2558 {
2559 case Type::Return:
2560 case Type::Break:
2561 case Type::Continue:
2562 case Type::Nil:
2563 new (&m_number) NumberContainer(0);
2564 break;
2565 case Type::Number:
2566 new (&m_number) NumberContainer(that.m_number);
2567 break;
2568 case Type::String:
2569 new (&m_strval) StringContainer(that.m_strval);
2570 break;
2571 case Type::ProtoString:
2572 new (&m_protostr) ProtoStringContainer(that.m_protostr);
2573 break;
2574 case Type::Tree:
2575 case Type::Function:
2576 new (&m_pointer) PointerContainer(that.m_pointer);
2577 break;
2578 case Type::UserPtr:
2579 #if 0
2580 fprintf(stderr, "BaseValue::operator=(BaseValue&): this.userptr=%p, that.userptr=%p\n",
2581 m_userptr.realptr, that.m_userptr.realptr
2582 );
2583 #endif
2584 new(&m_userptr) UserPtrContainer(that.m_userptr);
2585 break;
2586 case Type::Table:
2587 new (&m_table) TableContainer(that.m_table);
2588 break;
2589 case Type::Array:
2590 new (&m_array) ArrayContainer(that.m_array);
2591 break;
2592 default:
2593 break;
2594 }
2595 return *this;
2596 }
2597
2598 ~BaseValue()
2599 {
2600 switch(m_type)
2601 {
2602 case Type::String:
2603 m_strval.~StringContainer();
2604 break;
2605 case Type::Tree:
2606 case Type::Function:
2607 m_pointer.~PointerContainer();
2608 break;
2609 case Type::Table:
2610 m_table.~TableContainer();
2611 break;
2612 case Type::Array:
2613 m_array.~ArrayContainer();
2614 break;
2615 default:
2616 break;
2617 }
2618 }
2619
2620 bool operator==(const BaseValue &that) const
2621 {
2622 if(type() != that.type())
2623 {
2624 return false;
2625 }
2626 switch(m_type)
2627 {
2628 case Type::Return:
2629 case Type::Break:
2630 case Type::Continue:
2631 case Type::Nil:
2632 case Type::Number:
2633 return number() == that.number();
2634 case Type::Tree:
2635 case Type::Function:
2636 return pointer() == that.pointer();
2637 case Type::Table:
2638 return table() == that.table();
2639 case Type::Array:
2640 return array() == that.array();
2641 case Type::UserPtr:
2642 return (userptr() == that.userptr());
2643 case Type::String:
2644 if(that.m_type == Type::String)
2645 {
2646 return m_strval == that.m_strval;
2647 }
2648 else
2649 {
2650 if(m_strval.end()-m_strval.begin() != that.m_protostr.end - that.m_protostr.begin)
2651 {
2652 return false;
2653 }
2654 return std::equal(m_strval.begin(), m_strval.end(), that.m_protostr.begin);
2655 }
2656 case Type::ProtoString:
2657 if(that.m_type == Type::String)
2658 {
2659 if(m_protostr.end - m_protostr.begin != that.m_strval.end() - that.m_strval.begin())
2660 {
2661 return false;
2662 }
2663 return std::equal(m_protostr.begin, m_protostr.end, that.m_strval.begin());
2664 }
2665 else
2666 {
2667 if(m_protostr.end - m_protostr.begin != that.m_protostr.end - that.m_protostr.begin)
2668 {
2669 return false;
2670 }
2671 return std::equal(m_protostr.begin, m_protostr.end, that.m_protostr.begin);
2672 }
2673 default:
2674 return false;
2675 }
2676 }
2677
2678 friend struct std::hash<BaseValue<Iter, FuncType>>;
2679 };
2680
2681 namespace std
2682 {
2683 template<typename Iter, typename FuncType>
2684 struct hash<BaseValue<Iter, FuncType>>
2685 {
2686 public:
2687 using T = BaseValue<Iter, FuncType>;
2688 std::size_t operator()(BaseValue<Iter, FuncType> const& x) const
2689 {
2690 switch(x.m_type)
2691 {
2692 case T::Type::Nil:
2693 case T::Type::Number:
2694 return std::hash<typename T::NumberContainer>()(x.number());
2695 case T::Type::String:
2696 return std::hash<typename T::StringContainer>()(x.string());
2697 case T::Type::ProtoString:
2698 return x.m_protostr.hash;
2699 case T::Type::UserPtr:
2700 return std::hash<const void*>()(x.userptr());;
2701 case T::Type::Tree:
2702 case T::Type::Function:
2703 return std::hash<typename T::PointerContainer>()(x.pointer());
2704 case T::Type::Table:
2705 return std::hash<typename T::TableContainer>()(x.table());
2706 case T::Type::Array:
2707 return std::hash<typename T::ArrayContainer>()(x.array());
2708 default:
2709 return 0;
2710 }
2711 }
2712 };
2713 }
2714
2715 template<class Iter, class FuncType>
2716 std::ostream& operator<<(std::ostream &out, const BaseValue<Iter,FuncType> &v)
2717 {
2718 using T = BaseValue<Iter,FuncType>;
2719 switch(v.type())
2720 {
2721 case T::Type::Nil:
2722 return out << "nil";
2723 case T::Type::Number:
2724 return out << v.number();
2725 case T::Type::String:
2726 return out << v.string();
2727 case T::Type::Tree:
2728 return out << "tree@" << v.tree();
2729 case T::Type::Function:
2730 return out << "function@" << v.function();
2731 case T::Type::Table:
2732 return out << "table@" << v.table();
2733 case T::Type::Array:
2734 return out << "array@" << v.array();
2735 case T::Type::UserPtr:
2736 return out << "userpointer@" << v.userptr();
2737 default:
2738 return out;
2739 }
2740 }
2741
2742 template<typename Type> class Table
2743 {
2744 public:
2745 using Iterator = typename std::unordered_map<Type, Type>::iterator;
2746
2747 private:
2748 std::unordered_map<Type, Type> m_data;
2749 Type m_nil;
2750
2751 public:
2752 void set(const Type& key, const Type& value)
2753 {
2754 if(key.type() == Type::Type::Nil)
2755 {
2756 return;
2757 }
2758 if(value.type() == Type::Type::Nil)
2759 {
2760 m_data.erase(key);
2761 }
2762 m_data[key] = value;
2763 }
2764
2765 Type get(const Type& key)
2766 {
2767 auto iter = m_data.find(key);
2768 if(iter == m_data.end())
2769 {
2770 return m_nil;
2771 }
2772 else
2773 {
2774 return iter->second;
2775 }
2776 }
2777
2778 void append(const Table& that)
2779 {
2780 m_data.insert(that.m_data.begin(), that.m_data.end());
2781 }
2782
2783 size_t size() const
2784 {
2785 return m_data.size();
2786 }
2787
2788 Iterator begin()
2789 {
2790 return m_data.begin();
2791 }
2792
2793 Iterator end()
2794 {
2795 return m_data.end();
2796 }
2797
2798 };
2799
2800 template<typename Type>
2801 class Array
2802 {
2803 public:
2804 using Iterator = typename std::vector<Type>::iterator;
2805
2806 private:
2807 std::vector<Type> m_data;
2808 Type m_nil;
2809
2810 public:
2811 void set(const Type& key, const Type& value)
2812 {
2813 int index = key.number();
2814 m_data[index] = value;
2815 }
2816
2817 Type get(const Type& key)
2818 {
2819 int index = key.number();
2820 return m_data[index];
2821 }
2822
2823 void append(const Array& that)
2824 {
2825 m_data.insert(m_data.end(), that.m_data.begin(), that.m_data.end());
2826 }
2827
2828 void add(const Type& value)
2829 {
2830 m_data.push_back(value);
2831 }
2832
2833 size_t size() const
2834 {
2835 return m_data.size();
2836 }
2837
2838 Iterator begin()
2839 {
2840 return m_data.begin();
2841 }
2842
2843 Iterator end()
2844 {
2845 return m_data.end();
2846 }
2847 };
2848
2849 class Interpreter
2850 {
2851 public:
2852 using Iter = std::vector<Internal::Token<std::string::iterator>>::iterator;
2853 using FuncType = Interpreter;
2854 using Value = BaseValue<Iter, FuncType>;
2855 using Environment = std::shared_ptr<Table<Value>>;
2856 using EnvStack = std::vector<Environment>;
2857 using FunStack = std::vector<size_t>;
2858 using ParserInstance = Internal::Parser<Value, Interpreter>;
2859
2860 struct FunctionScope
2861 {
2862 Interpreter* m_self;
2863
2864 FunctionScope(Interpreter* self): m_self(self)
2865 {
2866 m_self->beginFunctionScope();
2867 }
2868
2869 ~FunctionScope()
2870 {
2871 m_self->endFunctionScope();
2872 }
2873 };
2874
2875 struct LocalScope
2876 {
2877 Interpreter& m_self;
2878
2879 LocalScope(Interpreter& self): m_self(self)
2880 {
2881 m_self.beginLocalScope();
2882 }
2883
2884 ~LocalScope()
2885 {
2886 m_self.endLocalScope();
2887 }
2888 };
2889
2890 private:
2891 ParserInstance m_parser;
2892 std::vector<Value> m_function_stack;
2893 std::vector<std::unordered_map<std::string, Value>> m_scopes;
2894 EnvStack m_envstack;
2895 FunStack m_funstack;
2896
2897 public:
2898 Value operator()(Internal::Variable<Iter,Value,FuncType> &node);
2899
2900 Value operator()(Internal::FieldName<Iter,Value,FuncType> &node);
2901
2902 Value operator()(Internal::Constant<Iter,Value,FuncType> &node);
2903
2904 Value operator()(Internal::Nop<Iter,Value,FuncType> &);
2905
2906 Value operator()(Internal::Nil<Iter,Value,FuncType> &);
2907
2908 Value operator()(Internal::String<Iter,Value,FuncType> &node);
2909
2910 Value operator()(Internal::Parens<Iter,Value,FuncType> &node);
2911
2912 Value operator()(Internal::ExpressionStatement<Iter,Value,FuncType> &node);
2913
2914 Value operator()(Internal::Type<Iter,Value,FuncType> &node);
2915
2916 Value operator()(Internal::Size<Iter,Value,FuncType> &node);
2917
2918 Value operator()(Internal::FieldAccess<Iter,Value,FuncType> &node);
2919
2920 Value operator()(Internal::FieldAssignment<Iter,Value,FuncType> &node);
2921
2922 Value operator()(Internal::AddFieldAssignment<Iter,Value,FuncType> &node);
2923
2924 Value operator()(Internal::SubFieldAssignment<Iter,Value,FuncType> &node);
2925
2926 Value operator()(Internal::MulFieldAssignment<Iter,Value,FuncType> &node);
2927
2928 Value operator()(Internal::DivFieldAssignment<Iter,Value,FuncType> &node);
2929
2930 Value operator()(Internal::ModFieldAssignment<Iter,Value,FuncType> &node);
2931
2932 Value operator()(Internal::UnaryPlusExpression<Iter,Value,FuncType> &node);
2933
2934 Value operator()(Internal::UnaryMinusExpression<Iter,Value,FuncType> &node);
2935
2936 Value operator()(Internal::UnaryNotExpression<Iter,Value,FuncType> &node);
2937
2938 Value operator()(Internal::MultiplyExpression<Iter,Value,FuncType> &node);
2939
2940 Value operator()(Internal::DivideExpression<Iter,Value,FuncType> &node);
2941
2942 Value operator()(Internal::ModuloExpression<Iter,Value,FuncType> &node);
2943
2944 Value operator()(Internal::AddExpression<Iter,Value,FuncType> &node);
2945
2946 Value operator()(Internal::SubtractExpression<Iter,Value,FuncType> &node);
2947
2948 Value operator()(Internal::LessExpression<Iter,Value,FuncType> &node);
2949
2950 Value operator()(Internal::LessEqualExpression<Iter,Value,FuncType> &node);
2951
2952 Value operator()(Internal::GreaterExpression<Iter,Value,FuncType> &node);
2953
2954 Value operator()(Internal::GreaterEqualExpression<Iter,Value,FuncType> &node);
2955
2956 Value operator()(Internal::EqualExpression<Iter,Value,FuncType> &node);
2957
2958 Value operator()(Internal::NotEqualExpression<Iter,Value,FuncType> &node);
2959
2960 Value operator()(Internal::LogicalAndExpression<Iter,Value,FuncType> &node);
2961
2962 Value operator()(Internal::LogicalOrExpression<Iter,Value,FuncType> &node);
2963
2964 Value operator()(Internal::AssignmentExpression<Iter,Value,FuncType> &node);
2965
2966 Value operator()(Internal::GlobalAssignmentExpression<Iter,Value,FuncType> &node);
2967
2968 Value operator()(Internal::LocalAssignmentExpression<Iter,Value,FuncType> &node);
2969
2970 Value operator()(Internal::AddAssignmentExpression<Iter,Value,FuncType> &node);
2971
2972 Value operator()(Internal::SubAssignmentExpression<Iter,Value,FuncType> &node);
2973
2974 Value operator()(Internal::MulAssignmentExpression<Iter,Value,FuncType> &node);
2975
2976 Value operator()(Internal::DivAssignmentExpression<Iter,Value,FuncType> &node);
2977
2978 Value operator()(Internal::ModAssignmentExpression<Iter,Value,FuncType> &node);
2979
2980 Value operator()(Internal::Block<Iter,Value,FuncType> &node);
2981
2982 Value operator()(Internal::TableInitializer<Iter,Value,FuncType> &node);
2983
2984 Value operator()(Internal::ArrayInitializer<Iter,Value,FuncType> &node);
2985
2986 Value operator()(Internal::Function<Iter,Value,FuncType> &node);
2987
2988 Value operator()(Internal::ReturnStatement<Iter,Value,FuncType> &node);
2989
2990 Value operator()(Internal::IdentifierList<Iter,Value,FuncType> &node);
2991
2992 Value operator()(Internal::BuiltinFunction<Iter,Value,FuncType> &node);
2993
2994 Value operator()(Internal::Call<Iter,Value,FuncType> &node);
2995
2996 Value operator()(Internal::MemberCall<Iter,Value,FuncType> &node);
2997
2998 Value operator()(Internal::EvalStatement<Iter,Value,FuncType> &node);
2999
3000 Value operator()(Internal::Eval<Iter,Value,FuncType> &node);
3001
3002 Value operator()(Internal::Tree<Iter,Value,FuncType> &node);
3003
3004 Value operator()(Internal::Root<Iter,Value,FuncType> &node);
3005
3006 Value operator()(Internal::ParseStatement<Iter,Value,FuncType> &node);
3007
3008 Value operator()(Internal::ParseExpression<Iter,Value,FuncType> &node);
3009
3010 Value operator()(Internal::StatementList<Iter,Value,FuncType> &node);
3011
3012 Value operator()(Internal::IfStatement<Iter,Value,FuncType> &node);
3013
3014 Value operator()(Internal::WhileStatement<Iter,Value,FuncType> &node);
3015
3016 Value operator()(Internal::ForStatement<Iter,Value,FuncType> &node);
3017
3018 Value operator()(Internal::ForEachStatement<Iter,Value,FuncType> &node);
3019
3020 Value operator()(Internal::ContinueStatement<Iter,Value,FuncType> &);
3021
3022 Value operator()(Internal::BreakStatement<Iter,Value,FuncType> &);
3023
3024 template<class Type>
3025 Value operator()(Type& node)
3026 {
3027 error("unimplemented ast node.", node);
3028 return Value();
3029 }
3030
3031 Value makeString(const std::string& src)
3032 {
3033 return Value(src);
3034 }
3035
3036 std::shared_ptr<Array<Value>> makeArray()
3037 {
3038 return std::make_shared<Array<Value>>();
3039 }
3040
3041 std::shared_ptr<Table<Value>> makeTable()
3042 {
3043 return std::make_shared<Table<Value>>();
3044 }
3045
3046 Value makeFunction(std::function<void(Interpreter&, std::vector<Value>&)> fun)
3047 {
3048 auto node = std::make_shared<Internal::Function<Iter,Value,FuncType>>();
3049 node->begin = node->end;
3050 auto nop = std::make_shared<Internal::Nop<Iter,Value,FuncType>>();
3051 nop->begin = nop->end;
3052 node->children[0] = nop;
3053 auto builtin = std::make_shared<Internal::BuiltinFunction<Iter,Value,FuncType>>();
3054 builtin->begin = builtin->end;
3055 builtin->function = fun;
3056 node->children[1] = builtin;
3057 return Value(Value::Type::Function, node);
3058 }
3059
3060 template<typename Type>
3061 Value makeUserPointer(Type* ptr)
3062 {
3063 return Value(Value::UserPtrContainer((void*)ptr));
3064 }
3065
3066 void beginLocalScope()
3067 {
3068 m_envstack.push_back(std::make_shared<Table<Value>>());
3069 }
3070
3071 void endLocalScope()
3072 {
3073 m_envstack.pop_back();
3074 }
3075
3076 void beginFunctionScope()
3077 {
3078 m_funstack.push_back(m_envstack.size());
3079 m_envstack.push_back(std::make_shared<Table<Value>>());
3080 }
3081
3082 void endFunctionScope()
3083 {
3084 m_envstack.pop_back();
3085 m_funstack.pop_back();
3086 }
3087
3088 Value get(Value key)
3089 {
3090 int top = m_envstack.size()-1;
3091 int bottom = m_funstack.back();
3092 for(int i = top; i>=bottom; --i)
3093 {
3094 Value value = m_envstack[i]->get(key);
3095 if(value.type() != Value::Type::Nil)
3096 {
3097 return value;
3098 }
3099 }
3100 return m_envstack[0]->get(key);
3101 }
3102
3103 void set(Value key, Value value)
3104 {
3105 m_envstack[m_funstack.back()]->set(key, value);
3106 }
3107
3108 void setLocal(Value key, Value value)
3109 {
3110 m_envstack.back()->set(key, value);
3111 }
3112
3113 void setGlobal(Value key, Value value)
3114 {
3115 m_envstack[0]->set(key, value);
3116 }
3117
3118 template<class T>
3119 void error(const std::string text, T &node)
3120 {
3121 auto lc = Internal::line_column(node.source->begin(), node.begin->begin);
3122 auto from = node.begin;
3123 auto to = node.end-1;
3124 throw std::runtime_error(
3125 std::to_string(lc.first)+":"+std::to_string(lc.second)+
3126 ": error: " + text + " in: '" + std::string(from->begin, to->end) + "'");
3127 }
3128
3129 void addFunction(const std::string &name, std::function<void(Interpreter&, std::vector<Value>&)> fun)
3130 {
3131 setGlobal(Value(name), makeFunction(fun));
3132 }
3133
3134 Interpreter()
3135 {
3136 beginFunctionScope();
3137 }
3138
3139 ~Interpreter()
3140 {
3141 endFunctionScope();
3142 }
3143
3144 Value run(const std::string &source)
3145 {
3146 auto root = m_parser(source.begin(), source.end());
3147 Value result = root->accept(*this);
3148 return result;
3149 }
3150 };
3151
3152
3153
An Interpreter, based on https://github.com/progschj/jtc