Website Summary Files Commits Branches @commit @diff @stats
path: root / JSImpl / src
diff options
context:
space:
mode:
diff --git a/JSImpl/src/ASTInterpreter.cpp b/JSImpl/src/ASTInterpreter.cpp
new file mode 100644
index 0000000..baf38ae
--- /dev/null
+++ b/JSImpl/src/ASTInterpreter.cpp
@@ -0,0 +1,586 @@
+#include "ASTInterpreter.h"
+#include "Expression.h"
+#include <iostream>
+#include <math.h>
+
+#undef NOT_IMPLEMENTED
+#define NOT_IMPLEMENTED (void)e; assert(0 && "not-implemented")
+
+namespace
+{
+ template <typename T>
+ ASTInterpreter::ValuePtr MakeValue(T&& v)
+ {
+ return IPLMakeSharePtr<ASTInterpreter::Value>(v);
+ }
+
+ template <typename T>
+ ASTInterpreter::ValuePtr MakeValue(const T& v)
+ {
+ return IPLMakeSharePtr<ASTInterpreter::Value>(v);
+ }
+
+ struct ValueToBool
+ {
+ bool operator()(double d) const
+ {
+ return d != 0.0;
+ }
+ bool operator()(const IPLString& s) const
+ {
+ return !s.empty();
+ }
+ };
+
+ struct UnsupportedOpReport
+ {
+ template <typename V>
+ ASTInterpreter::ValuePtr operator()(V) const
+ {
+ throw std::runtime_error("unsupported operation");
+ }
+
+ template <typename L, typename R>
+ ASTInterpreter::ValuePtr operator()(L, R) const
+ {
+ throw std::runtime_error("unsupported operation");
+ }
+ };
+
+ struct ValueAdd : UnsupportedOpReport
+ {
+ using UnsupportedOpReport::operator();
+
+ ASTInterpreter::ValuePtr operator()(double l, double r) const
+ {
+ return MakeValue(l + r);
+ }
+
+ ASTInterpreter::ValuePtr operator()(const IPLString& l, const IPLString& r) const
+ {
+ return MakeValue(l + r);
+ }
+ };
+
+ struct ValueMinus : UnsupportedOpReport
+ {
+ using UnsupportedOpReport::operator();
+
+ ASTInterpreter::ValuePtr operator()(double l, double r) const
+ {
+ return MakeValue(l - r);
+ }
+ };
+
+ struct ValueProduct : UnsupportedOpReport
+ {
+ using UnsupportedOpReport::operator();
+
+ ASTInterpreter::ValuePtr operator()(double l, double r) const
+ {
+ return MakeValue(l * r);
+ }
+ };
+
+ struct ValueDivide : UnsupportedOpReport
+ {
+ using UnsupportedOpReport::operator();
+
+ ASTInterpreter::ValuePtr operator()(double l, double r) const
+ {
+ return MakeValue(l / r);
+ }
+ };
+
+ struct ValueLess : UnsupportedOpReport
+ {
+ using UnsupportedOpReport::operator();
+
+ template <typename V>
+ ASTInterpreter::ValuePtr operator()(const V& l, const V& r) const
+ {
+ return MakeValue(l < r);
+ }
+ };
+ struct ValueLessEqual : UnsupportedOpReport
+ {
+ using UnsupportedOpReport::operator();
+
+ template <typename V>
+ ASTInterpreter::ValuePtr operator()(V l, V r) const
+ {
+ return MakeValue(l <= r);
+ }
+ };
+
+ struct ValueGreater : UnsupportedOpReport
+ {
+ using UnsupportedOpReport::operator();
+
+ template <typename V>
+ ASTInterpreter::ValuePtr operator()(V l, V r) const
+ {
+ return MakeValue(l > r);
+ }
+ };
+
+ struct ValueGreaterEqual : UnsupportedOpReport
+ {
+ using UnsupportedOpReport::operator();
+
+ template <typename V>
+ ASTInterpreter::ValuePtr operator()(V l, V r) const
+ {
+ return MakeValue(l >= r);
+ }
+ };
+
+ struct ValueEqualEqual : UnsupportedOpReport
+ {
+ using UnsupportedOpReport::operator();
+
+ ASTInterpreter::ValuePtr operator()(double left, double right) const
+ {
+ return MakeValue(fabs(left - right) <= 0.0001);
+ }
+
+ ASTInterpreter::ValuePtr operator()(const IPLString& left, const IPLString& right) const
+ {
+ return MakeValue(left == right);
+ }
+ };
+
+ struct ValueBangEqual : UnsupportedOpReport
+ {
+ using UnsupportedOpReport::operator();
+
+ ASTInterpreter::ValuePtr operator()(double left, double right) const
+ {
+ return MakeValue(fabs(left - right) > 0.0001);
+ }
+ ASTInterpreter::ValuePtr operator()(const IPLString& left, const IPLString& right) const
+ {
+ return MakeValue(left != right);
+ }
+ };
+
+ struct ValueUnaryMinus : UnsupportedOpReport
+ {
+ using UnsupportedOpReport::operator();
+
+ ASTInterpreter::ValuePtr operator()(double v) const
+ {
+ return MakeValue(-v);
+ }
+ };
+
+ struct ValueIncrement
+ {
+ void operator()(double& v) const
+ {
+ v += 1;
+ }
+
+ template <typename V>
+ void operator()(V&) const
+ {
+ throw std::runtime_error("unsupported operation");
+ }
+ };
+
+ struct ValueDecrement
+ {
+ void operator()(double& v) const
+ {
+ v -= 1;
+ }
+
+ template <typename V>
+ void operator()(V&) const
+ {
+ throw std::runtime_error("unsupported operation");
+ }
+ };
+
+ struct ValuePrint
+ {
+ ValuePrint(const char* name, ASTInterpreter::Printer* printer)
+ : Name(name)
+ , Printer(printer)
+ {}
+
+ void operator()(double value) const
+ {
+ Printer->PrintVariable(Name, value);
+ }
+
+ void operator()(const IPLString& value) const
+ {
+ Printer->PrintVariable(Name, value);
+ }
+
+ const char* Name;
+ ASTInterpreter::Printer* Printer;
+ };
+}
+
+struct LValueExtractor : public ExpressionVisitor
+{
+public:
+ LValueExtractor(ASTInterpreter* interpreter)
+ : m_Interpreter(interpreter)
+ , m_LValue(nullptr)
+ {}
+ ~LValueExtractor() {}
+
+ ASTInterpreter::ValuePtr Run(Expression* program)
+ {
+ m_LValue = nullptr;
+ program->Accept(*this);
+ return m_LValue;
+ }
+
+ virtual void Visit(IdentifierExpression* e) override { m_LValue = m_Interpreter->ModifyVariable(e->GetName()); }
+ virtual void Visit(Call* e) override { e->GetObjectOrCall()->Accept(*this); }
+
+ ASTInterpreter* m_Interpreter;
+ ASTInterpreter::ValuePtr m_LValue;
+};
+
+
+struct VariableScope
+{
+ VariableScope(ASTInterpreter* interpreter)
+ : m_Interpreter(interpreter)
+ {
+ m_Interpreter->EnterScope();
+ }
+
+ ~VariableScope() {
+ m_Interpreter->LeaveScope();
+ }
+
+ VariableScope(VariableScope&) = delete;
+ VariableScope(VariableScope&&) = delete;
+ VariableScope& operator=(VariableScope&) = delete;
+ VariableScope& operator=(VariableScope&&) = delete;
+
+ ASTInterpreter* m_Interpreter;
+};
+
+struct StackScope
+{
+ StackScope(ASTInterpreter* interpreter)
+ : m_Interpreter(interpreter)
+ , m_StackSize(m_Interpreter->m_Evaluation.size())
+ {
+ }
+
+ ~StackScope() {
+ m_Interpreter->m_Evaluation.resize(m_StackSize);
+ }
+
+ StackScope(StackScope&) = delete;
+ StackScope(StackScope&&) = delete;
+ StackScope& operator=(StackScope&) = delete;
+ StackScope& operator=(StackScope&&) = delete;
+
+ ASTInterpreter* m_Interpreter;
+ size_t m_StackSize;
+};
+
+ASTInterpreter::ASTInterpreter()
+{
+ // Allow globals
+ EnterScope();
+}
+
+ASTInterpreter::~ASTInterpreter()
+{}
+
+ASTInterpreter::ValueStack ASTInterpreter::Run(Expression* program)
+{
+ program->Accept(*this);
+ ValueStack result;
+ m_Evaluation.swap(result);
+ return result;
+}
+
+void ASTInterpreter::RunExpression(const ExpressionPtr& e)
+{
+ if (e) {
+ e->Accept(*this);
+ }
+}
+
+bool ASTInterpreter::EvalToBool(const ExpressionPtr& e)
+{
+ e->Accept(*this);
+ auto result = m_Evaluation.back();
+ m_Evaluation.pop_back();
+ return std::visit(ValueToBool(), *result);
+}
+
+void ASTInterpreter::EnterScope()
+{
+ m_Scopes.push(Scope{});
+}
+
+void ASTInterpreter::LeaveScope()
+{
+ const auto& scope = m_Scopes.top();
+ for (auto& var : scope) {
+ auto values = m_Variables.find(var);
+ values->second.pop_back();
+ if (values->second.empty()) {
+ m_Variables.erase(values);
+ }
+ }
+ m_Scopes.pop();
+}
+
+ASTInterpreter::ValuePtr& ASTInterpreter::ModifyVariable(const IPLString& name)
+{
+ auto values = m_Variables.find(name);
+ if (values != m_Variables.end()) {
+ return values->second.back();
+ }
+ else {
+ assert(0 && "not-defined");
+ }
+ static ValuePtr undefined;
+ return undefined;
+}
+
+bool ASTInterpreter::HasVariable(const IPLString& name)
+{
+ return m_Variables.find(name) != m_Variables.end();
+}
+
+void ASTInterpreter::Visit(LiteralNull* e) {
+ NOT_IMPLEMENTED;
+}
+
+void ASTInterpreter::Visit(LiteralUndefined* e) {
+ NOT_IMPLEMENTED;
+}
+void ASTInterpreter::Visit(LiteralString* e) {
+ m_Evaluation.push_back(MakeValue(e->GetValue()));
+}
+
+void ASTInterpreter::Visit(LiteralObject* e)
+{
+ NOT_IMPLEMENTED;
+}
+
+void ASTInterpreter::Visit(LiteralNumber* e) {
+ m_Evaluation.push_back(MakeValue(e->GetValue()));
+}
+void ASTInterpreter::Visit(LiteralBoolean* e) {
+ m_Evaluation.push_back(MakeValue(e->GetValue()));
+}
+
+void ASTInterpreter::Visit(BinaryExpression* e) {
+ e->GetLeft()->Accept(*this);
+ e->GetRight()->Accept(*this);
+ auto right = *m_Evaluation.back();
+ m_Evaluation.pop_back();
+
+ auto left = *m_Evaluation.back();
+ m_Evaluation.pop_back();
+
+ switch (e->GetOperator()) {
+ case TokenType::Plus:
+ m_Evaluation.push_back(std::visit(ValueAdd(), left, right));
+ break;
+ case TokenType::Minus:
+ m_Evaluation.push_back(std::visit(ValueMinus(), left, right));
+ break;
+ case TokenType::Star:
+ m_Evaluation.push_back(std::visit(ValueProduct(), left, right));
+ break;
+ case TokenType::Division:
+ m_Evaluation.push_back(std::visit(ValueDivide(), left, right));
+ break;
+ case TokenType::Less:
+ m_Evaluation.push_back(std::visit(ValueLess(), left, right));
+ break;
+ case TokenType::LessEqual:
+ m_Evaluation.push_back(std::visit(ValueLessEqual(), left, right));
+ break;
+ case TokenType::Greater:
+ m_Evaluation.push_back(std::visit(ValueGreater(), left, right));
+ break;
+ case TokenType::GreaterEqual:
+ m_Evaluation.push_back(std::visit(ValueGreaterEqual(), left, right));
+ break;
+ case TokenType::Comma:
+ m_Evaluation.push_back(MakeValue(std::move(right)));
+ break;
+ case TokenType::EqualEqual:
+ m_Evaluation.push_back(std::visit(ValueEqualEqual(), left, right));
+ break;
+ case TokenType::BangEqual:
+ m_Evaluation.push_back(std::visit(ValueBangEqual(), left, right));
+ break;
+ case TokenType::Equal:
+ {
+ LValueExtractor extractor(this);
+ auto lvalue = extractor.Run(e->GetLeft().get());
+ *lvalue = right;
+ }
+ break;
+ default:
+ NOT_IMPLEMENTED;
+ }
+}
+
+void ASTInterpreter::Visit(UnaryExpression* e) {
+ switch (e->GetOperator())
+ {
+ case TokenType::Minus:
+ {
+ e->GetExpr()->Accept(*this);
+ auto v = m_Evaluation.back();
+ m_Evaluation.pop_back();
+ m_Evaluation.push_back(std::visit(ValueUnaryMinus(), *v));
+ break;
+ }
+ case TokenType::Plus:
+ {
+ e->GetExpr()->Accept(*this);
+ break;
+ }
+ case TokenType::PlusPlus: // FALLTHROUGH
+ case TokenType::MinusMinus:
+ {
+ LValueExtractor extractor(this);
+ auto lvalue = extractor.Run(e->GetExpr().get());
+ if (e->GetSuffix())
+ {
+ m_Evaluation.push_back(MakeValue(*lvalue));
+ }
+ if (e->GetOperator() == TokenType::PlusPlus)
+ {
+ std::visit(ValueIncrement(), *lvalue);
+ }
+ else
+ {
+ std::visit(ValueDecrement(), *lvalue);
+ }
+ if (!e->GetSuffix())
+ {
+ m_Evaluation.push_back(MakeValue(*lvalue));
+ }
+ break;
+ }
+ default:
+ {
+ NOT_IMPLEMENTED;
+ }
+ }
+
+}
+
+void ASTInterpreter::Visit(IdentifierExpression* e) {
+ m_Evaluation.push_back(ModifyVariable(e->GetName()));
+}
+
+void ASTInterpreter::Visit(ListExpression* e) {
+ for (const auto& stmt: e->GetValues()) {
+ stmt->Accept(*this);
+ }
+}
+
+void ASTInterpreter::Visit(VariableDefinitionExpression* e) {
+ e->GetValue()->Accept(*this);
+ auto& name = e->GetName();
+ m_Variables[name].push_back(m_Evaluation.back());
+ m_Scopes.top().push_back(name);
+ m_Evaluation.pop_back();
+}
+
+void ASTInterpreter::Visit(BlockStatement* e) {
+ for (const auto& stmt: e->GetValues()) {
+ stmt->Accept(*this);
+ }
+}
+
+void ASTInterpreter::Visit(LabeledStatement* e) {
+ RunExpression(e->GetStatement());
+}
+
+void ASTInterpreter::Visit(IfStatement* e) {
+ VariableScope scope(this);
+ if (EvalToBool(e->GetCondition())) {
+ VariableScope ifScope(this);
+ RunExpression(e->GetIfStatement());
+ } else {
+ VariableScope elseScope(this);
+ RunExpression(e->GetElseStatement());
+ }
+}
+
+void ASTInterpreter::Visit(SwitchStatement* e) { NOT_IMPLEMENTED;}
+void ASTInterpreter::Visit(CaseStatement *e) { NOT_IMPLEMENTED;}
+
+void ASTInterpreter::Visit(WhileStatement* e) {
+ VariableScope scope(this);
+ if (e->GetDoWhile()) {
+ VariableScope bodyScope(this);
+ RunExpression(e->GetBody());
+ }
+ while (EvalToBool(e->GetCondition())) {
+ VariableScope bodyScope(this);
+ RunExpression(e->GetBody());
+ }
+}
+
+void ASTInterpreter::Visit(ForStatement* e) {
+ VariableScope scope(this);
+
+ {
+ StackScope stackScope(this);
+ RunExpression(e->GetInitialization());
+ }
+ while (EvalToBool(e->GetCondition()))
+ {
+ {
+ VariableScope bodyScope(this);
+ RunExpression(e->GetBody());
+ }
+ {
+ StackScope stackScope(this);
+ RunExpression(e->GetIteration());
+ }
+ }
+}
+
+void ASTInterpreter::Visit(FunctionDeclaration* e) { NOT_IMPLEMENTED;}
+void ASTInterpreter::Visit(TopStatements* e) {
+ for (const auto& stmt: e->GetValues()) {
+ stmt->Accept(*this);
+ }
+}
+
+void ASTInterpreter::Visit(EmptyExpression* e) {
+ NOT_IMPLEMENTED;
+}
+
+void ASTInterpreter::Visit(Call* e)
+{
+ e->GetObjectOrCall()->Accept(*this);
+ if (e->GetMember())
+ {
+ e->GetMember()->Accept(*this);
+ }
+}
+
+void ASTInterpreter::Print(Printer& p)
+{
+ for (auto& it : m_Variables)
+ {
+ auto& value = ModifyVariable(it.first);
+ std::visit(ValuePrint(it.first.c_str(), &p), *value);
+ }
+}
diff --git a/JSImpl/src/ASTInterpreter.h b/JSImpl/src/ASTInterpreter.h
new file mode 100644
index 0000000..0c2c776
--- /dev/null
+++ b/JSImpl/src/ASTInterpreter.h
@@ -0,0 +1,68 @@
+#pragma once
+
+#include "ExpressionVisitor.h"
+
+#include <variant>
+
+class ASTInterpreter : public ExpressionVisitor
+{
+public:
+ ASTInterpreter();
+ ~ASTInterpreter();
+
+
+ typedef std::variant<double, IPLString> Value;
+ typedef IPLSharedPtr<Value> ValuePtr;
+ typedef IPLVector<ValuePtr> ValueStack;
+
+ ValueStack Run(Expression* program);
+
+ virtual void Visit(LiteralNull* e) override;
+ virtual void Visit(LiteralUndefined* e) override;
+ virtual void Visit(LiteralString* e) override;
+ virtual void Visit(LiteralNumber* e) override;
+ virtual void Visit(LiteralBoolean* e) override;
+ virtual void Visit(LiteralObject* e) override;
+ virtual void Visit(BinaryExpression* e) override;
+ virtual void Visit(UnaryExpression* e) override;
+ virtual void Visit(IdentifierExpression* e) override;
+ virtual void Visit(ListExpression* e) override;
+ virtual void Visit(VariableDefinitionExpression* e) override;
+ virtual void Visit(BlockStatement* e) override;
+ virtual void Visit(LabeledStatement* e) override;
+ virtual void Visit(IfStatement* e) override;
+ virtual void Visit(SwitchStatement* e) override;
+ virtual void Visit(CaseStatement *) override;
+ virtual void Visit(WhileStatement* e) override;
+ virtual void Visit(ForStatement* e) override;
+ virtual void Visit(FunctionDeclaration* e) override;
+ virtual void Visit(TopStatements* e) override;
+ virtual void Visit(EmptyExpression* e) override;
+ virtual void Visit(Call* e) override;
+
+ ValuePtr& ModifyVariable(const IPLString& name);
+ bool HasVariable(const IPLString& name);
+
+ class Printer
+ {
+ public:
+ virtual void PrintVariable(const char* name, double value) = 0;
+ virtual void PrintVariable(const char* name, const IPLString& value) = 0;
+ };
+
+ void Print(Printer& p);
+private:
+ void RunExpression(const ExpressionPtr& e);
+ bool EvalToBool(const ExpressionPtr& e);
+
+ void EnterScope();
+ void LeaveScope();
+ friend struct VariableScope;
+ friend struct StackScope;;
+
+ ValueStack m_Evaluation;
+ IPLUnorderedMap<IPLString, ValueStack> m_Variables;
+
+ typedef IPLVector<IPLString> Scope;
+ IPLStack<Scope> m_Scopes;
+};
diff --git a/JSImpl/src/ASTPrinter.cpp b/JSImpl/src/ASTPrinter.cpp
new file mode 100644
index 0000000..4a05510
--- /dev/null
+++ b/JSImpl/src/ASTPrinter.cpp
@@ -0,0 +1,344 @@
+#include "ASTPrinter.h"
+#include "Expression.h"
+
+#include <iostream>
+#include <iosfwd>
+
+std::ostream& operator<<(std::ostream& os, const TokenType& t)
+{
+ switch (t)
+ {
+ case TokenType::LeftParen: os << "\"LeftParen\""; return os;
+ case TokenType::RightParen: os << "\"RightParen\""; return os;
+ case TokenType::LeftBrace: os << "\"LeftBrace\""; return os;
+ case TokenType::RightBrace: os << "\"RightBrace\""; return os;
+ case TokenType::Comma: os << "\"Comma\""; return os;
+ case TokenType::Dot: os << "\"Dot\""; return os;
+ case TokenType::Minus: os << "\"Minus\""; return os;
+ case TokenType::Plus: os << "\"Plus\""; return os;
+ case TokenType::Semicolon: os << "\"Semicolon\""; return os;
+ case TokenType::Star: os << "\"Star\""; return os;
+ case TokenType::Division: os << "\"Division\""; return os;
+ case TokenType::Modulo: os << "\"Modulo\""; return os;
+ case TokenType::BitwiseNot: os << "\"BitwiseNot\""; return os;
+ case TokenType::BitwiseAnd: os << "\"BitwiseAnd\""; return os;
+ case TokenType::BitwiseXor: os << "\"BitwiseXor\""; return os;
+ case TokenType::BitwiseOr: os << "\"BitwiseOr\""; return os;
+ case TokenType::QuestionMark: os << "\"QuestionMark\""; return os;
+ case TokenType::Colon: os << "\"Colon\""; return os;
+ case TokenType::LeftSquareBracket: os << "\"LeftSquareBracket\""; return os;
+ case TokenType::RightSquareBracket: os << "\"RightSquareBracket\""; return os;
+ case TokenType::Bang: os << "\"Bang\""; return os;
+ case TokenType::BangEqual: os << "\"BangEqual\""; return os;
+ case TokenType::Equal: os << "\"Equal\""; return os;
+ case TokenType::EqualEqual: os << "\"EqualEqual\""; return os;
+ case TokenType::StrictEqual: os << "\"StrictEqual\""; return os;
+ case TokenType::StrictNotEqual: os << "\"StrictNotEqual\""; return os;
+ case TokenType::Greater: os << "\"Greater\""; return os;
+ case TokenType::GreaterEqual: os << "\"GreaterEqual\""; return os;
+ case TokenType::Less: os << "\"Less\""; return os;
+ case TokenType::LessEqual: os << "\"LessEqual\""; return os;
+ case TokenType::MinusMinus: os << "\"MinusMinus\""; return os;
+ case TokenType::PlusPlus: os << "\"PlusPlus\""; return os;
+ case TokenType::LeftShift: os << "\"LeftShift\""; return os;
+ case TokenType::RightShift: os << "\"RightShift\""; return os;
+ case TokenType::LogicalAnd: os << "\"LogicalAnd\""; return os;
+ case TokenType::LogicalOr: os << "\"LogicalOr\""; return os;
+ case TokenType::StarEqual: os << "\"StarEqual\""; return os;
+ case TokenType::DivideEqual: os << "\"DivideEqual\""; return os;
+ case TokenType::ModuloEqual: os << "\"ModuloEqual\""; return os;
+ case TokenType::PlusEqual: os << "\"PlusEqual\""; return os;
+ case TokenType::MinusEqual: os << "\"MinusEqual\""; return os;
+ case TokenType::LeftShiftEqual: os << "\"LeftShiftEqual\""; return os;
+ case TokenType::RightShiftEqual: os << "\"RightShiftEqual\""; return os;
+ case TokenType::BitwiseAndEqual: os << "\"BitwiseAndEqual\""; return os;
+ case TokenType::BitwiseXorEqual: os << "\"BitwiseXorEqual\""; return os;
+ case TokenType::BitwiseOrEqual: os << "\"BitwiseOrEqual\""; return os;
+ case TokenType::Identifier: os << "\"Identifier\""; return os;
+ case TokenType::String: os << "\"String\""; return os;
+ case TokenType::Number: os << "\"Number\""; return os;
+ case TokenType::Break: os << "\"Break\""; return os;
+ case TokenType::Case: os << "\"Case\""; return os;
+ case TokenType::Catch: os << "\"Catch\""; return os;
+ case TokenType::Class: os << "\"Class\""; return os;
+ case TokenType::Const: os << "\"Const\""; return os;
+ case TokenType::Continue: os << "\"Continue\""; return os;
+ case TokenType::Debugger: os << "\"Debugger\""; return os;
+ case TokenType::Default: os << "\"Default\""; return os;
+ case TokenType::Delete: os << "\"Delete\""; return os;
+ case TokenType::Do: os << "\"Do\""; return os;
+ case TokenType::Else: os << "\"Else\""; return os;
+ case TokenType::Export: os << "\"Export\""; return os;
+ case TokenType::Extends: os << "\"Extends\""; return os;
+ case TokenType::Finally: os << "\"Finally\""; return os;
+ case TokenType::For: os << "\"For\""; return os;
+ case TokenType::Function: os << "\"Function\""; return os;
+ case TokenType::If: os << "\"If\""; return os;
+ case TokenType::Import: os << "\"Import\""; return os;
+ case TokenType::In: os << "\"In\""; return os;
+ case TokenType::Instanceof: os << "\"Instanceof\""; return os;
+ case TokenType::New: os << "\"New\""; return os;
+ case TokenType::Return: os << "\"Return\""; return os;
+ case TokenType::Super: os << "\"Super\""; return os;
+ case TokenType::Switch: os << "\"Switch\""; return os;
+ case TokenType::This: os << "\"This\""; return os;
+ case TokenType::Throw: os << "\"Throw\""; return os;
+ case TokenType::Try: os << "\"Try\""; return os;
+ case TokenType::Typeof: os << "\"Typeof\""; return os;
+ case TokenType::Var: os << "\"Var\""; return os;
+ case TokenType::Void: os << "\"Void\""; return os;
+ case TokenType::While: os << "\"While\""; return os;
+ case TokenType::With: os << "\"With\""; return os;
+ case TokenType::Yield: os << "\"Yield\""; return os;
+ case TokenType::Null: os << "\"Null\""; return os;
+ case TokenType::Undefined: os << "\"Undefined\""; return os;
+ case TokenType::True: os << "\"True\""; return os;
+ case TokenType::False: os << "\"False\""; return os;
+ case TokenType::Eof: os << "\"Eof\""; return os;
+ case TokenType::Invalid: os << "\"Invalid\""; return os;
+ default:
+ break;
+ }
+ return os;
+}
+
+class ASTToJsonPrinter : public ExpressionVisitor
+{
+public:
+ ASTToJsonPrinter(std::ostream& os);
+ virtual ~ASTToJsonPrinter() {}
+ virtual void Visit(LiteralNull* e) override;
+ virtual void Visit(LiteralUndefined* e) override;
+ virtual void Visit(LiteralString* e) override;
+ virtual void Visit(LiteralNumber* e) override;
+ virtual void Visit(LiteralBoolean* e) override;
+ virtual void Visit(LiteralField* e) override;
+ virtual void Visit(LiteralObject* e) override;
+ virtual void Visit(BinaryExpression* e) override;
+ virtual void Visit(UnaryExpression* e) override;
+ virtual void Visit(IdentifierExpression* e) override;
+ virtual void Visit(ListExpression* e) override;
+ virtual void Visit(VariableDefinitionExpression* e) override;
+ virtual void Visit(BlockStatement* e) override;
+ virtual void Visit(LabeledStatement* e) override;
+ virtual void Visit(IfStatement* e) override;
+ virtual void Visit(SwitchStatement* e) override;
+ virtual void Visit(CaseStatement *) override;
+ virtual void Visit(WhileStatement* e) override;
+ virtual void Visit(ForStatement* e) override;
+ virtual void Visit(Break* e) override;
+ virtual void Visit(Continue* e) override;
+ virtual void Visit(FunctionDeclaration* e) override;
+ virtual void Visit(TopStatements* e) override;
+ virtual void Visit(EmptyExpression* e) override;
+ virtual void Visit(Call* e) override;
+ virtual void Visit(MemberAccess* e) override;
+
+ void Print( const char* name, const ExpressionPtr& expr, bool isLast);
+ void Print( const char* name, const IPLVector<ExpressionPtr>& list, bool isLast);
+ void Print( const char* name, const IPLVector<IPLString>& list, bool isLast);
+ void Print( const char* name, const IPLString& member, bool isLast);
+ void Print( const char* name, bool member, bool isLast);
+ void Print( const char* name, const TokenType& member, bool isLast);
+ void Print( const char* name, const double& member, bool isLast);
+
+ inline void Enter();
+ inline void Exit();
+ inline void NoIndentNextAccept();
+ inline void IndentNextAccept();
+ inline void InsertIndent();
+private:
+ std::ostream& m_Output;
+ unsigned m_Level;
+ bool m_IndentNext;
+};
+
+ASTToJsonPrinter::ASTToJsonPrinter(std::ostream& os)
+ : m_Output(os)
+ , m_Level(0)
+ , m_IndentNext(true)
+{}
+
+void PrepNextElement(std::ostream& os, bool isLast)
+{
+ if (!isLast)
+ {
+ os << ",";
+ }
+ os << "\n";
+}
+
+void ASTToJsonPrinter::Print(const char* name, const ExpressionPtr& expr, bool isLast)
+{
+ if (!expr)
+ {
+ return;
+ }
+ InsertIndent();
+ m_Output << "\"" << name << "\": ";
+ NoIndentNextAccept();
+ expr->Accept(*this);
+ PrepNextElement(m_Output, isLast);
+}
+
+void ASTToJsonPrinter::Print(const char* name, const IPLVector<ExpressionPtr>& list, bool isLast)
+{
+ InsertIndent();
+ m_Output << "\"" << name << "\": [";
+ if (list.empty())
+ {
+ m_Output << "]";
+ PrepNextElement(m_Output, isLast);
+ return;
+ }
+
+ Enter();
+ for (auto i = 0u; i < list.size(); ++i)
+ {
+ IndentNextAccept();
+ list[i]->Accept(*this);
+ if (i + 1 != list.size())
+ {
+ m_Output << ",\n";
+ }
+ }
+ Exit();
+ m_Output << "\n";
+ InsertIndent();
+ m_Output << "]";
+ PrepNextElement(m_Output, isLast);
+}
+
+void ASTToJsonPrinter::Print(const char* name, const IPLVector<IPLString>& list, bool isLast)
+{
+ InsertIndent();
+ m_Output << "\"" << name << "\": [";
+ if (list.empty())
+ {
+ m_Output << "]";
+ PrepNextElement(m_Output, isLast);
+ return;
+ }
+
+ Enter();
+ for (auto i = 0u; i < list.size(); ++i)
+ {
+ InsertIndent();
+ m_Output << "\"" << list[i] << "\"";
+ if (i + 1 != list.size())
+ {
+ m_Output << ",\n";
+ }
+ }
+ Exit();
+ m_Output << "\n";
+ InsertIndent();
+ m_Output << "]";
+ PrepNextElement(m_Output, isLast);
+}
+
+void ASTToJsonPrinter::Print(const char* name, bool member, bool isLast)
+{
+ InsertIndent();
+ m_Output << "\"" << name << "\": " << member;
+ PrepNextElement(m_Output, isLast);
+}
+
+void ASTToJsonPrinter::Print(const char* name, const TokenType& member, bool isLast)
+{
+ InsertIndent();
+ m_Output << "\"" << name << "\": " << member;
+ PrepNextElement(m_Output, isLast);
+}
+
+
+IPLString StripString(const IPLString& str)
+{
+ if (str.front() == '\"')
+ {
+ return str.substr(1, str.length() - 2);
+ }
+ return str;
+}
+
+void ASTToJsonPrinter::Print(const char* name, const IPLString& member, bool isLast)
+{
+ InsertIndent();
+ m_Output << "\"" << name << "\": \"" << StripString(member) << "\"";
+ PrepNextElement(m_Output, isLast);
+}
+
+void ASTToJsonPrinter::Print(const char* name, const double& member, bool isLast)
+{
+ InsertIndent();
+ m_Output << "\"" << name << "\": " << member;
+ PrepNextElement(m_Output, isLast);
+}
+
+
+
+#define MEMBERS_COUNT(type, name, def) ++membersCount;
+#define VISIT_MEMBER(type, name, def) ++currentVisitCount; Print(#name, e->Get##name(), currentVisitCount == membersCount);
+
+#define GENERATE_AST_PRINTER_FUNCTION(ClassName, MEMBERS_ITERATOR) \
+ void ASTToJsonPrinter::Visit(ClassName* e) \
+ { \
+ int membersCount = 0, currentVisitCount = 0; \
+ (void)currentVisitCount;(void)e; \
+ MEMBERS_ITERATOR(MEMBERS_COUNT); \
+ if (m_Level) \
+ { \
+ InsertIndent(); \
+ } \
+ m_Output << "{"; \
+ Enter(); \
+ InsertIndent(); \
+ m_Output << "\"ExpressionType\": \"" << #ClassName "\""; \
+ if (membersCount) \
+ { \
+ m_Output << ","; \
+ } \
+ m_Output << "\n"; \
+ MEMBERS_ITERATOR(VISIT_MEMBER); \
+ Exit(); \
+ InsertIndent(); \
+ m_Output << "}"; \
+ }
+
+EXPRESSION_DEFINITION_ITERATOR(GENERATE_AST_PRINTER_FUNCTION);
+
+void ASTToJsonPrinter::Enter()
+{
+ m_Output << "\n";
+ ++m_Level;
+}
+
+void ASTToJsonPrinter::Exit()
+{
+ --m_Level;
+}
+
+void ASTToJsonPrinter::IndentNextAccept()
+{
+ m_IndentNext = true;
+}
+
+void ASTToJsonPrinter::InsertIndent()
+{
+ for (unsigned i = 0; i < m_Level; ++i)
+ {
+ m_Output << " ";
+ }
+}
+
+void ASTToJsonPrinter::NoIndentNextAccept()
+{
+ m_IndentNext = false;
+}
+
+
+void PrintAST(const ExpressionPtr& ast, std::ostream& where)
+{
+ ASTToJsonPrinter p(where);
+ ast->Accept(p);
+} \ No newline at end of file
diff --git a/JSImpl/src/ASTPrinter.h b/JSImpl/src/ASTPrinter.h
new file mode 100644
index 0000000..25a1228
--- /dev/null
+++ b/JSImpl/src/ASTPrinter.h
@@ -0,0 +1,5 @@
+#pragma once
+
+#include "ExpressionVisitor.h"
+
+void PrintAST(const ExpressionPtr& ast, std::ostream& where);
diff --git a/JSImpl/src/ByteCodeGenerator.cpp b/JSImpl/src/ByteCodeGenerator.cpp
new file mode 100644
index 0000000..4d5cb09
--- /dev/null
+++ b/JSImpl/src/ByteCodeGenerator.cpp
@@ -0,0 +1,840 @@
+#include "ByteCodeGenerator.h"
+#include "ExpressionVisitor.h"
+#include <algorithm>
+#include <sstream>
+#include <iterator>
+
+class ByteCodeGenerator : public ExpressionVisitor
+{
+public:
+
+ ByteCodeGenerator(const ByteCodeGeneratorOptions& o, const IPLVector<IPLString>& source) : m_Source(source), m_Options(o) {};
+ ~ByteCodeGenerator() {};
+
+ virtual void Visit(FunctionDeclaration* e) override;
+ virtual void Visit(BlockStatement* e) override;
+ virtual void Visit(BinaryExpression* e) override;
+ virtual void Visit(LiteralNumber* e) override;
+ virtual void Visit(TopStatements* e) override;
+ virtual void Visit(ListExpression* e) override;
+ virtual void Visit(VariableDefinitionExpression* e) override;
+ virtual void Visit(IdentifierExpression* e) override;
+ virtual void Visit(EmptyExpression* e) override { (void)e; }
+ virtual void Visit(IfStatement* e) override;
+ virtual void Visit(ForStatement* e) override;
+ virtual void Visit(WhileStatement* e) override;
+ virtual void Visit(Break* e) override;
+ virtual void Visit(Continue* e) override;
+ virtual void Visit(UnaryExpression* e) override;
+ virtual void Visit(LiteralField* e) override;
+ virtual void Visit(LiteralObject* e) override;
+ virtual void Visit(LiteralString* e) override;
+ virtual void Visit(MemberAccess* e) override;
+ virtual void Visit(Call* e) override;
+
+ IPLString GetCode();
+ unsigned ResolveRegisterName(IPLString& name);
+
+private:
+ void AddDebugInformation(Expression* e);
+ struct Instruction
+ {
+ enum Type : char
+ {
+ FIRST = 0,
+ ADD = FIRST,
+ SUB,
+ MUL,
+ DIV,
+ MOD,
+ MOV,
+ PRINT,
+ READ,
+ CALL,
+ RET,
+ JMP,
+ JMPT,
+ JMPF,
+ DUP,
+ PUSH,
+ POP,
+ SAVE,
+ RESTORE,
+ LESS,
+ LESSEQ,
+ GREATER,
+ GREATEREQ,
+ EQ,
+ NEQ,
+ LEQ,
+ GETG,
+ SETG,
+ GETUP,
+ SETUP,
+ GET,
+ SET,
+ INC,
+ DEC,
+ AND,
+ OR,
+ XOR,
+ NOT,
+ THROW,
+ CATCH,
+ CONST,
+ STRING,
+ HALT,
+ DEBUG,
+ LAST = DEBUG
+ };
+
+ Type Descriptor;
+ IPLString Args[3];
+ union
+ {
+ double Double[3];
+ long long Int[3];
+ unsigned long long Address[3];
+ } Values;
+ };
+ size_t PushInstruction(Instruction::Type opcode, const IPLString& arg1 = "", const IPLString& arg2 = "", const IPLString& arg3 = "");
+ size_t PushInstruction(Instruction::Type opcode, size_t Address);
+ size_t PushInstruction(Instruction::Type opcode, const IPLString& arg1, size_t Address);
+ size_t PushInstruction(Instruction::Type opcode, int Int);
+ size_t PushInstruction(Instruction::Type opcode, const IPLString& arg0, double value);
+
+ void PushConst(double c);
+ IPLString CreateRegister();
+ bool CheckOpCode(int opcode) { return opcode >= Instruction::Type::FIRST && opcode <= Instruction::Type::LAST; }
+
+ void OpenBreakScope() { m_BreakScopeStack.push(IPLVector<size_t>()); };
+ void OpenContinueScope() { m_ContinueScopeStack.push(IPLVector<size_t>()); };
+ void CloseBreakScope(size_t addr);
+ void CloseContinueScope(size_t addr);
+ void PushBreak();
+ void PushContinue();
+private:
+ IPLVector<IPLString> m_RegisterTable;
+ IPLVector<Instruction> m_Code;
+ IPLVector<IPLString> m_Source;
+
+ IPLStack<IPLVector<size_t>> m_BreakScopeStack;
+ IPLStack<IPLVector<size_t>> m_ContinueScopeStack;
+
+ IPLStack<IPLString> m_RegisterStack;
+ IPLString m_OutputCode;
+ ByteCodeGeneratorOptions m_Options;
+};
+
+void ByteCodeGenerator::PushBreak()
+{
+ assert(!m_BreakScopeStack.empty());
+ auto addr = PushInstruction(Instruction::Type::JMP, 0);
+ m_BreakScopeStack.top().push_back(addr);
+}
+
+void ByteCodeGenerator::PushContinue()
+{
+ assert(!m_ContinueScopeStack.empty());
+ auto addr = PushInstruction(Instruction::Type::JMP, 0);
+ m_ContinueScopeStack.top().push_back(addr);
+}
+
+void ByteCodeGenerator::CloseBreakScope(size_t addr)
+{
+ auto currentScope = m_BreakScopeStack.top();
+ for (const auto& br : currentScope)
+ {
+ assert(m_Code[br].Descriptor == Instruction::Type::JMP);
+ m_Code[br].Values.Address[0] = addr;
+ }
+ m_BreakScopeStack.pop();
+};
+
+void ByteCodeGenerator::CloseContinueScope(size_t addr)
+{
+ auto currentScope = m_ContinueScopeStack.top();
+ for (const auto& br : currentScope)
+ {
+ assert(m_Code[br].Descriptor == Instruction::Type::JMP);
+ m_Code[br].Values.Address[0] = addr;
+ }
+ m_ContinueScopeStack.pop();
+};
+
+size_t ByteCodeGenerator::PushInstruction(Instruction::Type opcode, const IPLString& arg0, const IPLString& arg1, const IPLString& arg2)
+{
+ assert(CheckOpCode(opcode));
+ Instruction ins;
+ ins.Descriptor = opcode;
+ ins.Args[0] = arg0;
+ ins.Args[1] = arg1;
+ ins.Args[2] = arg2;
+ m_Code.push_back(ins);
+ return m_Code.size() - 1;;
+}
+
+size_t ByteCodeGenerator::PushInstruction(Instruction::Type opcode, size_t Address)
+{
+ assert(CheckOpCode(opcode));
+ Instruction ins;
+ ins.Descriptor = opcode;
+ ins.Values.Address[0] = Address;
+ m_Code.push_back(ins);
+ return m_Code.size() - 1;;
+}
+
+size_t ByteCodeGenerator::PushInstruction(Instruction::Type opcode, int Int)
+{
+ assert(CheckOpCode(opcode));
+ Instruction ins;
+ ins.Descriptor = opcode;
+ ins.Values.Int[0] = Int;
+ m_Code.push_back(ins);
+ return m_Code.size() - 1;;
+}
+
+size_t ByteCodeGenerator::PushInstruction(Instruction::Type opcode, const IPLString& arg0, size_t Address)
+{
+ assert(CheckOpCode(opcode));
+ Instruction ins;
+ ins.Descriptor = opcode;
+ ins.Args[0] = arg0;
+ ins.Values.Address[0] = Address;
+ m_Code.push_back(ins);
+ return m_Code.size() - 1;;
+}
+
+size_t ByteCodeGenerator::PushInstruction(Instruction::Type opcode, const IPLString& arg0, double value)
+{
+ assert(CheckOpCode(opcode));
+ Instruction ins;
+ ins.Descriptor = opcode;
+ ins.Args[0] = arg0;
+ ins.Values.Double[0] = value;
+ m_Code.push_back(ins);
+ return m_Code.size() - 1;;
+}
+
+void ByteCodeGenerator::PushConst(double c)
+{
+ IPLString regName = CreateRegister();
+ m_RegisterStack.push(regName);
+
+ PushInstruction(Instruction::Type::CONST, regName, c);
+}
+
+IPLString ByteCodeGenerator::CreateRegister()
+{
+ IPLString regName = IPLString("tmp");
+ regName += std::to_string(m_RegisterTable.size());
+ m_RegisterTable.push_back(regName);
+ return regName;
+}
+
+void ByteCodeGenerator::AddDebugInformation(Expression* e)
+{
+ if (!m_Options.AddDebugInformation || e->GetLine() == (unsigned)-1 || e->GetColumn() == (unsigned)-1)
+ {
+ return;
+ }
+ Instruction ins;
+ ins.Descriptor = Instruction::Type::DEBUG;
+ ins.Values.Int[0] = e->GetLine();
+ ins.Values.Int[1] = e->GetColumn();
+ m_Code.push_back(ins);
+}
+
+void ByteCodeGenerator::Visit(FunctionDeclaration* e)
+{
+ e->GetBody()->Accept(*this);
+}
+
+void ByteCodeGenerator::Visit(ListExpression* e)
+{
+ auto& statements = e->GetValues();
+ for (auto& s : statements)
+ {
+ s->Accept(*this);
+ }
+}
+
+void ByteCodeGenerator::Visit(BlockStatement* e)
+{
+ auto& statements = e->GetValues();
+ for (auto& s : statements)
+ {
+ s->Accept(*this);
+ }
+}
+
+void ByteCodeGenerator::Visit(TopStatements* e)
+{
+ auto& statements = e->GetValues();
+
+ auto startAddress = PushInstruction(Instruction::Type::PUSH, (int)0);
+ for (auto& s : statements)
+ {
+ s->Accept(*this);
+ }
+ m_Code[startAddress].Values.Int[0] = (int)m_RegisterTable.size();
+
+ PushInstruction(Instruction::Type::POP, (int)m_RegisterTable.size());
+}
+
+void ByteCodeGenerator::Visit(VariableDefinitionExpression* e)
+{
+ auto it = std::find_if(m_RegisterTable.begin(), m_RegisterTable.end(), [&](IPLString& current) {
+ return e->GetName() == current;
+ });
+
+
+ if (it != m_RegisterTable.end())
+ {
+ // TODO: error double definitions
+ return;
+ }
+ m_RegisterTable.push_back(e->GetName());
+ if (e->GetValue())
+ {
+ e->GetValue()->Accept(*this);
+ }
+ AddDebugInformation(e);
+ if (!m_RegisterStack.empty())
+ {
+ PushInstruction(Instruction::Type::MOV, e->GetName(), m_RegisterStack.top(), "");
+ m_RegisterStack.pop();
+ }
+}
+
+void ByteCodeGenerator::Visit(BinaryExpression* e)
+{
+ e->GetRight()->Accept(*this);
+ auto r = m_RegisterStack.top();
+ e->GetLeft()->Accept(*this);
+ auto l = m_RegisterStack.top();
+
+ AddDebugInformation(e);
+ if (e->GetOperator() == TokenType::Equal)
+ {
+ PushInstruction(Instruction::Type::MOV, l, r);
+ return;
+ }
+
+ IPLString o = CreateRegister();
+ m_RegisterStack.push(o);
+
+ switch (e->GetOperator()) {
+ case TokenType::Plus:
+ PushInstruction(Instruction::Type::ADD, o, l, r);
+ return;
+ case TokenType::Minus:
+ PushInstruction(Instruction::Type::SUB, o, l, r);
+ return;
+ case TokenType::Star:
+ PushInstruction(Instruction::Type::MUL, o, l, r);
+ return;
+ case TokenType::Division:
+ PushInstruction(Instruction::Type::DIV, o, l, r);
+ return;
+ case TokenType::Less:
+ PushInstruction(Instruction::Type::LESS, o, l, r);
+ return;
+ case TokenType::LessEqual:
+ PushInstruction(Instruction::Type::LESSEQ, o, l, r);
+ return;
+ case TokenType::Greater:
+ PushInstruction(Instruction::Type::GREATER, o, l, r);
+ return;
+ case TokenType::GreaterEqual:
+ PushInstruction(Instruction::Type::GREATEREQ, o, l, r);
+ break;
+ case TokenType::EqualEqual:
+ PushInstruction(Instruction::Type::EQ, o, l, r);
+ return;
+ case TokenType::BangEqual:
+ PushInstruction(Instruction::Type::NEQ,o,l,r);
+ break;
+ case TokenType::Equal:
+
+ break;
+ default:
+ NOT_IMPLEMENTED;
+ }
+}
+
+void ByteCodeGenerator::Visit(IfStatement* e)
+{
+ e->GetCondition()->Accept(*this);
+ auto ifAddress = PushInstruction(Instruction::Type::JMPF, m_RegisterStack.top(), size_t(0));
+
+ e->GetIfStatement()->Accept(*this);
+
+ if (e->GetElseStatement())
+ {
+ auto blockEndAddress = PushInstruction(Instruction::Type::JMP);
+
+ e->GetElseStatement()->Accept(*this);
+
+ // Patching
+ m_Code[ifAddress].Values.Address[0] = blockEndAddress + 1;
+ m_Code[blockEndAddress].Values.Address[0] = m_Code.size();
+ }
+ else
+ {
+ m_Code[ifAddress].Values.Address[0] = m_Code.size();
+ }
+}
+
+void ByteCodeGenerator::Visit(ForStatement* e)
+{
+ OpenBreakScope();
+ OpenContinueScope();
+
+ e->GetInitialization()->Accept(*this);
+ auto compareAddress = m_Code.size();
+ e->GetCondition()->Accept(*this);
+ auto endAddress = PushInstruction(Instruction::Type::JMPF, m_RegisterStack.top(), (size_t)0);
+ m_RegisterStack.pop();
+ e->GetBody()->Accept(*this);
+
+ auto iterationAddress = m_Code.size();
+ e->GetIteration()->Accept(*this);
+
+ PushInstruction(Instruction::Type::JMP, compareAddress);
+ m_Code[endAddress].Values.Address[0] = m_Code.size();
+
+ CloseBreakScope(m_Code.size());
+ CloseContinueScope(iterationAddress);
+}
+
+void ByteCodeGenerator::Visit(WhileStatement* e)
+{
+ auto startAddress = m_Code.size();
+
+ OpenBreakScope();
+ OpenContinueScope();
+
+ if (e->GetDoWhile())
+ {
+ e->GetBody()->Accept(*this);
+ e->GetCondition()->Accept(*this);
+ PushInstruction(Instruction::Type::JMPT, m_RegisterStack.top(), startAddress);
+ }
+ else {
+ e->GetCondition()->Accept(*this);
+ auto endAddress = PushInstruction(Instruction::Type::JMPF, m_RegisterStack.top(), (size_t)0);
+ m_RegisterStack.pop();
+ e->GetBody()->Accept(*this);
+ PushInstruction(Instruction::Type::JMP, startAddress);
+ m_Code[endAddress].Values.Address[0] = m_Code.size();
+ }
+
+ CloseBreakScope(m_Code.size());
+ CloseContinueScope(startAddress);
+}
+
+void ByteCodeGenerator::Visit(Break*)
+{
+ PushBreak();
+}
+
+void ByteCodeGenerator::Visit(Continue*)
+{
+ PushContinue();
+}
+
+void ByteCodeGenerator::Visit(IdentifierExpression* e)
+{
+ m_RegisterStack.push(e->GetName());
+}
+
+void ByteCodeGenerator::Visit(LiteralNumber* e)
+{
+ AddDebugInformation(e);
+ IPLString regName = CreateRegister();
+ m_RegisterStack.push(regName);
+
+ PushInstruction(Instruction::Type::CONST, regName, e->GetValue());
+}
+
+void ByteCodeGenerator::Visit(UnaryExpression* e)
+{
+ AddDebugInformation(e);
+ e->GetExpr()->Accept(*this);
+ auto reg = m_RegisterStack.top();
+ m_RegisterStack.pop();
+ if (e->GetSuffix())
+ {
+ switch (e->GetOperator())
+ {
+ case TokenType::PlusPlus:
+ PushConst(1);
+ {
+ auto one = m_RegisterStack.top();
+ m_RegisterStack.pop();
+ auto o = CreateRegister();
+ PushInstruction(Instruction::Type::MOV, o, reg);
+ m_RegisterStack.push(o);
+ PushInstruction(Instruction::Type::ADD, reg, reg, one);
+ }
+ return;
+ case TokenType::MinusMinus:
+ PushConst(1);
+ {
+ auto one = m_RegisterStack.top();
+ m_RegisterStack.pop();
+ auto o = CreateRegister();
+ PushInstruction(Instruction::Type::MOV, o, reg);
+ m_RegisterStack.push(o);
+ PushInstruction(Instruction::Type::SUB, reg, reg, one);
+ }
+ return;
+ default:
+ NOT_IMPLEMENTED;
+ break;
+ }
+ }
+ else
+ {
+ // prefix
+ switch (e->GetOperator())
+ {
+ case TokenType::Delete:
+ NOT_IMPLEMENTED;
+ return;
+ case TokenType::PlusPlus:
+ PushConst(1);
+ {
+ auto one = m_RegisterStack.top();
+ m_RegisterStack.pop();
+ m_RegisterStack.push(reg);
+ PushInstruction(Instruction::Type::ADD, reg, reg, one);
+ }
+ return;
+ case TokenType::MinusMinus:
+ PushConst(1);
+ {
+ auto one = m_RegisterStack.top();
+ m_RegisterStack.pop();
+ m_RegisterStack.push(reg);
+ PushInstruction(Instruction::Type::SUB, reg, reg, one);
+ }
+ return;
+ case TokenType::Void:
+ NOT_IMPLEMENTED;
+ return;
+ case TokenType::Typeof:
+ NOT_IMPLEMENTED;
+ return;
+ case TokenType::Plus:
+ NOT_IMPLEMENTED;
+ return;
+ case TokenType::Minus:
+ NOT_IMPLEMENTED;
+ return;
+ case TokenType::BitwiseNot:
+ NOT_IMPLEMENTED;
+ return;
+ case TokenType::Bang:
+ NOT_IMPLEMENTED;
+ return;
+ default:
+ NOT_IMPLEMENTED;
+ break;
+ }
+ }
+}
+
+void ByteCodeGenerator::Visit(LiteralField* e)
+{
+ e->GetValue()->Accept(*this);
+ e->GetIdentifier()->Accept(*this);
+}
+
+void ByteCodeGenerator::Visit(LiteralObject* e)
+{
+ auto initialSize = m_RegisterStack.size();
+ auto objReg = CreateRegister();
+
+ for (const auto& field : e->GetValues())
+ {
+ field->Accept(*this);
+ auto fieldName = m_RegisterStack.top();
+ m_RegisterStack.pop();
+
+ auto fieldNameReg = CreateRegister();
+ PushInstruction(Instruction::Type::STRING, fieldNameReg, fieldName);
+
+ auto valueReg = m_RegisterStack.top();
+ m_RegisterStack.pop();
+ PushInstruction(Instruction::Type::SET, objReg, fieldNameReg, valueReg);
+ }
+ assert(m_RegisterStack.size() == initialSize);
+ m_RegisterStack.push(objReg);
+}
+
+void ByteCodeGenerator::Visit(LiteralString* e)
+{
+ auto stringReg = CreateRegister();
+ PushInstruction(Instruction::Type::STRING, stringReg, e->GetValue());
+ m_RegisterStack.push(stringReg);
+}
+
+void ByteCodeGenerator::Visit(Call* e)
+{
+ e->GetObjectOrCall()->Accept(*this);
+ if (e->GetMember())
+ {
+ e->GetMember()->Accept(*this);
+ }
+}
+
+void ByteCodeGenerator::Visit(MemberAccess* e)
+{
+ auto objectReg = m_RegisterStack.top();
+ m_RegisterStack.pop();
+
+ auto identifierNameReg = CreateRegister();
+ PushInstruction(Instruction::Type::STRING, identifierNameReg, e->GetName());
+
+ auto resultReg = CreateRegister();
+ PushInstruction(Instruction::Type::GET, objectReg, identifierNameReg, resultReg);
+
+ m_RegisterStack.push(resultReg);
+}
+
+unsigned ByteCodeGenerator::ResolveRegisterName(IPLString& name)
+{
+ auto it = std::find_if(m_RegisterTable.begin(), m_RegisterTable.end(), [&](IPLString& current) {
+ return name == current;
+ });
+ return unsigned(it - m_RegisterTable.begin());
+}
+
+IPLString ByteCodeGenerator::GetCode()
+{
+ IPLString result;
+ auto programCounter = 0;
+ for (auto& i : m_Code)
+ {
+ if (i.Descriptor != ByteCodeGenerator::Instruction::DEBUG)
+ {
+ result += std::to_string(programCounter) + ": ";
+ }
+ switch (i.Descriptor)
+ {
+ case ByteCodeGenerator::Instruction::ADD:
+ result += "add r" + std::to_string(ResolveRegisterName(i.Args[0]))
+ + " r" + std::to_string(ResolveRegisterName(i.Args[1]))
+ + " r" + std::to_string(ResolveRegisterName(i.Args[2])) + '\n';
+ break;
+ case ByteCodeGenerator::Instruction::SUB:
+ result += "sub r" + std::to_string(ResolveRegisterName(i.Args[0]))
+ + " r" + std::to_string(ResolveRegisterName(i.Args[1]))
+ + " r" + std::to_string(ResolveRegisterName(i.Args[2])) + '\n';
+ break;
+ case ByteCodeGenerator::Instruction::MUL:
+ result += "mul r" + std::to_string(ResolveRegisterName(i.Args[0]))
+ + " r" + std::to_string(ResolveRegisterName(i.Args[1]))
+ + " r" + std::to_string(ResolveRegisterName(i.Args[2])) + '\n';
+ break;
+ case ByteCodeGenerator::Instruction::DIV:
+ result += "div r" + std::to_string(ResolveRegisterName(i.Args[0]))
+ + " r" + std::to_string(ResolveRegisterName(i.Args[1]))
+ + " r" + std::to_string(ResolveRegisterName(i.Args[2])) + '\n';
+ break;
+ case ByteCodeGenerator::Instruction::MOD:
+ result += "mod r" + std::to_string(ResolveRegisterName(i.Args[0]))
+ + " r" + std::to_string(ResolveRegisterName(i.Args[1]))
+ + " r" + std::to_string(ResolveRegisterName(i.Args[2])) + '\n';
+ break;
+ case ByteCodeGenerator::Instruction::MOV:
+ result += "mov r" + std::to_string(ResolveRegisterName(i.Args[0]))
+ + " r" + std::to_string(ResolveRegisterName(i.Args[1])) + '\n';
+ break;
+ case ByteCodeGenerator::Instruction::PRINT:
+ result += "print r" + std::to_string(ResolveRegisterName(i.Args[0])) + '\n';
+ break;
+ case ByteCodeGenerator::Instruction::READ:
+ result += "read";
+ NOT_IMPLEMENTED;
+ break;
+ case ByteCodeGenerator::Instruction::CALL:
+ result += "call";
+ NOT_IMPLEMENTED;
+ break;
+ case ByteCodeGenerator::Instruction::RET:
+ result += "ret";
+ NOT_IMPLEMENTED;
+ break;
+ case ByteCodeGenerator::Instruction::JMP:
+ result += "jmp " + std::to_string(i.Values.Address[0]) + '\n';
+ break;
+ case ByteCodeGenerator::Instruction::JMPT:
+ result += "jmpt r" + std::to_string(ResolveRegisterName(i.Args[0]))
+ + " " + std::to_string(i.Values.Address[0]) + '\n';
+ break;
+ case ByteCodeGenerator::Instruction::JMPF:
+ result += "jmpf r" + std::to_string(ResolveRegisterName(i.Args[0]))
+ + " " + std::to_string(i.Values.Address[0]) + '\n';
+ break;
+ case ByteCodeGenerator::Instruction::DUP:
+ result += "dup";
+ NOT_IMPLEMENTED;
+ break;
+ case ByteCodeGenerator::Instruction::PUSH:
+ result += "push " + std::to_string(i.Values.Int[0]) + '\n';
+ break;
+ case ByteCodeGenerator::Instruction::POP:
+ result += "pop " + std::to_string(i.Values.Int[0]) + '\n';
+ break;
+ case ByteCodeGenerator::Instruction::SAVE:
+ result += "save";
+ NOT_IMPLEMENTED;
+ break;
+ case ByteCodeGenerator::Instruction::RESTORE:
+ result += "restore";
+ NOT_IMPLEMENTED;
+ break;
+ case ByteCodeGenerator::Instruction::LESS:
+ result += "less r" + std::to_string(ResolveRegisterName(i.Args[0]))
+ + " r" + std::to_string(ResolveRegisterName(i.Args[1]))
+ + " r" + std::to_string(ResolveRegisterName(i.Args[2])) + '\n';
+ break;
+ case ByteCodeGenerator::Instruction::LESSEQ:
+ result += "lesseq r" + std::to_string(ResolveRegisterName(i.Args[0]))
+ + " r" + std::to_string(ResolveRegisterName(i.Args[1]))
+ + " r" + std::to_string(ResolveRegisterName(i.Args[2])) + '\n';
+ break;
+ case ByteCodeGenerator::Instruction::GREATER:
+ result += "greater r" + std::to_string(ResolveRegisterName(i.Args[0]))
+ + " r" + std::to_string(ResolveRegisterName(i.Args[1]))
+ + " r" + std::to_string(ResolveRegisterName(i.Args[2])) + '\n';
+ break;
+ case ByteCodeGenerator::Instruction::GREATEREQ:
+ result += "greatereq r" + std::to_string(ResolveRegisterName(i.Args[0]))
+ + " r" + std::to_string(ResolveRegisterName(i.Args[1]))
+ + " r" + std::to_string(ResolveRegisterName(i.Args[2])) + '\n';
+ break;
+ case ByteCodeGenerator::Instruction::EQ:
+ result += "eq r" + std::to_string(ResolveRegisterName(i.Args[0]))
+ + " r" + std::to_string(ResolveRegisterName(i.Args[1]))
+ + " r" + std::to_string(ResolveRegisterName(i.Args[2])) + '\n';
+ break;
+ case ByteCodeGenerator::Instruction::NEQ:
+ result += "neq r" + std::to_string(ResolveRegisterName(i.Args[0]))
+ + " r" + std::to_string(ResolveRegisterName(i.Args[1]))
+ + " r" + std::to_string(ResolveRegisterName(i.Args[2])) + '\n';
+ break;
+ case ByteCodeGenerator::Instruction::LEQ:
+ result += "leq r" + std::to_string(ResolveRegisterName(i.Args[0]))
+ + " r" + std::to_string(ResolveRegisterName(i.Args[1]))
+ + " r" + std::to_string(ResolveRegisterName(i.Args[2])) + '\n';
+ break;
+ case ByteCodeGenerator::Instruction::GETG:
+ result += "getg";
+ NOT_IMPLEMENTED;
+ break;
+ case ByteCodeGenerator::Instruction::SETG:
+ result += "setg";
+ NOT_IMPLEMENTED;
+ break;
+ case ByteCodeGenerator::Instruction::GETUP:
+ result += "getup";
+ NOT_IMPLEMENTED;
+ break;
+ case ByteCodeGenerator::Instruction::SETUP:
+ result += "setup";
+ NOT_IMPLEMENTED;
+ break;
+ case ByteCodeGenerator::Instruction::GET:
+ result += "get r" + std::to_string(ResolveRegisterName(i.Args[0]))
+ + " r" + std::to_string(ResolveRegisterName(i.Args[1]))
+ + " r" + std::to_string(ResolveRegisterName(i.Args[2])) + '\n';
+ break;
+ case ByteCodeGenerator::Instruction::SET:
+ result += "set r" + std::to_string(ResolveRegisterName(i.Args[0]))
+ + " r" + std::to_string(ResolveRegisterName(i.Args[1]))
+ + " r" + std::to_string(ResolveRegisterName(i.Args[2])) + '\n';
+ break;
+ case ByteCodeGenerator::Instruction::INC:
+ result += "inc r" + std::to_string(ResolveRegisterName(i.Args[0]))
+ + " r" + std::to_string(i.Values.Int[0]) + '\n';
+ break;
+ case ByteCodeGenerator::Instruction::DEC:
+ result += "dec r" + std::to_string(ResolveRegisterName(i.Args[0]))
+ + " r" + std::to_string(i.Values.Int[0]) + '\n';
+ break;
+ case ByteCodeGenerator::Instruction::AND:
+ result += "and r" + std::to_string(ResolveRegisterName(i.Args[0]))
+ + " r" + std::to_string(ResolveRegisterName(i.Args[1]))
+ + " r" + std::to_string(ResolveRegisterName(i.Args[2])) + '\n';
+ break;
+ case ByteCodeGenerator::Instruction::OR:
+ result += "or r" + std::to_string(ResolveRegisterName(i.Args[0]))
+ + " r" + std::to_string(ResolveRegisterName(i.Args[1]))
+ + " r" + std::to_string(ResolveRegisterName(i.Args[2])) + '\n';
+ break;
+ case ByteCodeGenerator::Instruction::XOR:
+ result += "xor r" + std::to_string(ResolveRegisterName(i.Args[0]))
+ + " r" + std::to_string(ResolveRegisterName(i.Args[1]))
+ + " r" + std::to_string(ResolveRegisterName(i.Args[2])) + '\n';
+ break;
+ case ByteCodeGenerator::Instruction::NOT:
+ result += "not r" + std::to_string(ResolveRegisterName(i.Args[0]))
+ + " r" + std::to_string(ResolveRegisterName(i.Args[1])) + '\n';
+ NOT_IMPLEMENTED;
+ break;
+ case ByteCodeGenerator::Instruction::THROW:
+ result += "throw";
+ NOT_IMPLEMENTED;
+ break;
+ case ByteCodeGenerator::Instruction::CATCH:
+ result += "catch";
+ NOT_IMPLEMENTED;
+ break;
+ case ByteCodeGenerator::Instruction::CONST:
+ result += "const r" + std::to_string(ResolveRegisterName(i.Args[0])) + " " + std::to_string(i.Values.Double[0]) + '\n';
+ break;
+ case ByteCodeGenerator::Instruction::STRING:
+ result += "string r" + std::to_string(ResolveRegisterName(i.Args[0])) + " " + i.Args[1] + '\n';
+ break;
+ case ByteCodeGenerator::Instruction::HALT:
+ result += "halt\n";
+ break;
+ case ByteCodeGenerator::Instruction::DEBUG:
+ {
+ auto line = int(i.Values.Int[0]);
+ auto column = int(i.Values.Int[1]);
+ result += "D: " + m_Source[line].substr(0, column) + "@@=>" + m_Source[line].substr(column, m_Source[line].size()) + '\n';
+ }
+ break;
+ default:
+ NOT_IMPLEMENTED;
+ break;
+
+ }
+ ++programCounter;
+ }
+ result += std::to_string(programCounter) + ": ";
+ result += "halt\n";
+ return result;
+}
+
+IPLString GenerateByteCode(ExpressionPtr program, const IPLString& source, const ByteCodeGeneratorOptions& options)
+{
+ std::istringstream sourceStream(source);
+
+ IPLVector<IPLString> sourceByLines;
+ while (sourceStream.good())
+ {
+ IPLString currentLine;
+ std::getline(sourceStream, currentLine);
+ sourceByLines.push_back(currentLine);
+ }
+ ByteCodeGenerator generator(options, sourceByLines);
+ program->Accept(generator);
+
+ return generator.GetCode();
+}
diff --git a/JSImpl/src/ByteCodeGenerator.h b/JSImpl/src/ByteCodeGenerator.h
new file mode 100644
index 0000000..4a1d521
--- /dev/null
+++ b/JSImpl/src/ByteCodeGenerator.h
@@ -0,0 +1,16 @@
+#pragma once
+
+#include "Expression.h"
+
+struct ByteCodeGeneratorOptions
+{
+ enum OptimizationsType
+ {
+ None
+ };
+ ByteCodeGeneratorOptions(OptimizationsType o = None, bool debug = false) : Optimisations(o), AddDebugInformation(debug) {}
+ OptimizationsType Optimisations;
+ bool AddDebugInformation;
+};
+
+IPLString GenerateByteCode(ExpressionPtr program, const IPLString& source, const ByteCodeGeneratorOptions& options = ByteCodeGeneratorOptions());
diff --git a/JSImpl/src/CommonTypes.h b/JSImpl/src/CommonTypes.h
new file mode 100644
index 0000000..d85a10b
--- /dev/null
+++ b/JSImpl/src/CommonTypes.h
@@ -0,0 +1,41 @@
+#pragma once
+#include <string>
+#include <vector>
+#include <unordered_map>
+#include <memory>
+#include <stack>
+#include <cassert>
+
+template<typename T>
+using IPLVector = std::vector<T>;
+using IPLString = std::string;
+
+template<typename T, typename K>
+using IPLPair = std::pair<T, K>;
+
+template <typename T>
+using IPLStack = std::stack<T>;
+
+template <typename Key, typename T>
+using IPLUnorderedMap = std::unordered_map<Key, T>;
+
+template <typename T>
+using IPLSharedPtr = std::shared_ptr<T>;
+
+template <typename T, class... Args>
+inline IPLSharedPtr<T> IPLMakeSharePtr(Args&&... args) {
+ return std::make_shared<T, Args...>(args...);
+};
+
+template< typename T>
+using IPLEnableShared = std::enable_shared_from_this<T>;
+
+struct IPLError
+{
+ unsigned Row;
+ unsigned Column;
+ IPLString File;
+ IPLString What;
+};
+
+#define NOT_IMPLEMENTED assert(0 && "not-implemented")
diff --git a/JSImpl/src/Expression.cpp b/JSImpl/src/Expression.cpp
new file mode 100644
index 0000000..7153b3f
--- /dev/null
+++ b/JSImpl/src/Expression.cpp
@@ -0,0 +1,4 @@
+#include "Expression.h"
+#include <assert.h>
+
+
diff --git a/JSImpl/src/Expression.h b/JSImpl/src/Expression.h
new file mode 100644
index 0000000..570687a
--- /dev/null
+++ b/JSImpl/src/Expression.h
@@ -0,0 +1,57 @@
+#pragma once
+
+#include "CommonTypes.h"
+#include "Lexer.h"
+#include "ExpressionVisitor.h"
+#include "ExpressionDefinitions.h"
+
+class Expression : public IPLEnableShared<Expression>
+{
+ public:
+ Expression() : m_Line((unsigned)-1), m_Column((unsigned)-1) {}
+ virtual ~Expression() {}
+ virtual void Accept(ExpressionVisitor& v) = 0;
+ unsigned GetLine() { return m_Line; };
+ unsigned GetColumn() { return m_Column; };
+ void SetLocation(unsigned l, unsigned c) { m_Line = l; m_Column = c; };
+ private:
+ unsigned m_Line = 0;
+ unsigned m_Column = 0;
+};
+
+#define EXPAND_ARGUMENT(type, name, def)\
+ const type& name = def,
+
+#define EXPAND_INITIALIZER_LIST(type, name, def)\
+ m_##name(name),
+
+#define GENERATE_GETTERS(type, name, def)\
+ const type& Get##name() const { return m_##name; }\
+ type& Get##name##ByRef() { return m_##name; }
+
+#define GENERATE_MEMBER_DEFINITIONS(type, name, def)\
+ type m_##name;
+
+#define GENERATE_EXPRESSION(ClassName, MEMBERS_ITERATOR) \
+ class ClassName : public Expression \
+ { \
+ public: \
+ ClassName(MEMBERS_ITERATOR(EXPAND_ARGUMENT) bool __dummy = 0) \
+ : \
+ MEMBERS_ITERATOR(EXPAND_INITIALIZER_LIST) m_dummy(__dummy) \
+ { \
+ (void)m_dummy; /* silence warning about unused private field */ \
+ } \
+ virtual ~ClassName() {} \
+ virtual void Accept(ExpressionVisitor& v) override { v.Visit(this); } \
+ \
+ MEMBERS_ITERATOR(GENERATE_GETTERS) \
+ private: \
+ MEMBERS_ITERATOR(GENERATE_MEMBER_DEFINITIONS) \
+ bool m_dummy; /* NOLINT */ \
+ };
+
+EXPRESSION_DEFINITION_ITERATOR(GENERATE_EXPRESSION);
+#undef GENERATE_EXPRESSION
+
+inline ExpressionPtr CreateEmptyExpression() { return IPLMakeSharePtr<EmptyExpression>(); }
diff --git a/JSImpl/src/ExpressionDefinitions.h b/JSImpl/src/ExpressionDefinitions.h
new file mode 100644
index 0000000..33f13b3
--- /dev/null
+++ b/JSImpl/src/ExpressionDefinitions.h
@@ -0,0 +1,116 @@
+#pragma once
+
+#define NO_MEMBERS(MACRO)
+
+#define LITERAL_BOOLEAN_MEMBERS(MACRO)\
+ MACRO(bool, Value, false)
+
+#define LITERAL_NUMBER_MEMBERS(MACRO)\
+ MACRO(double, Value, 0.0)
+
+#define LITERAL_STRING_MEMBERS(MACRO)\
+ MACRO(IPLString, Value, "")
+
+#define LITERAL_FIELD_MEMBERS(MACRO)\
+ MACRO(ExpressionPtr, Identifier, nullptr)\
+ MACRO(ExpressionPtr, Value, nullptr)
+
+#define LITERAL_OBJECT_MEMBERS(MACRO)\
+ MACRO(IPLVector<ExpressionPtr>, Values, IPLVector<ExpressionPtr>())
+
+#define BINARY_EXPRESSION_MEMBERS(MACRO)\
+ MACRO(ExpressionPtr, Left, nullptr)\
+ MACRO(ExpressionPtr, Right, nullptr)\
+ MACRO(TokenType, Operator, TokenType::Invalid)
+
+#define UNARY_EXPRESSION_MEMBERS(MACRO)\
+ MACRO(IPLSharedPtr<Expression>, Expr, nullptr)\
+ MACRO(TokenType, Operator, TokenType::Invalid)\
+ MACRO(bool, Suffix, false)
+
+#define IDENTIFIER_EXPRESSION_MEMBERS(MACRO)\
+ MACRO(IPLString, Name, "")
+
+#define VARIABLEDEFINITION_EXPRESSION_MEMBERS(MACRO)\
+ MACRO(IPLString, Name, "")\
+ MACRO(ExpressionPtr, Value, nullptr)
+
+#define LIST_EXPRESSION_MEMBERS(MACRO)\
+ MACRO(IPLVector<ExpressionPtr>, Values, IPLVector<ExpressionPtr>())
+
+#define BLOCK_EXPRESSION_MEMBERS(MACRO)\
+ MACRO(IPLVector<ExpressionPtr>, Values, IPLVector<ExpressionPtr>())
+
+#define LABELED_EXPRESSION_MEMBERS(MACRO)\
+ MACRO(IPLString, Identifier, "")\
+ MACRO(ExpressionPtr, Statement, nullptr)
+
+#define IF_EXPRESSION_MEMBERS(MACRO)\
+ MACRO(ExpressionPtr, Condition, nullptr)\
+ MACRO(ExpressionPtr, IfStatement, nullptr)\
+ MACRO(ExpressionPtr, ElseStatement, nullptr)
+
+#define CASE_EXPRESSION_MEMBERS(MACRO)\
+ MACRO(ExpressionPtr, Condition, nullptr)\
+ MACRO(ExpressionPtr, Body, nullptr)
+
+#define SWITCH_EXPRESSION_MEMBERS(MACRO)\
+ MACRO(ExpressionPtr, Condition, nullptr)\
+ MACRO(IPLVector<ExpressionPtr>, Cases, IPLVector<ExpressionPtr>())\
+ MACRO(ExpressionPtr, DefaultCase, nullptr)
+
+#define WHILE_EXPRESSION_MEMBERS(MACRO)\
+ MACRO(ExpressionPtr, Condition, nullptr)\
+ MACRO(ExpressionPtr, Body, nullptr)\
+ MACRO(bool, DoWhile, false)
+
+#define FOR_EXPRESSION_MEMBERS(MACRO)\
+ MACRO(ExpressionPtr, Initialization, nullptr)\
+ MACRO(ExpressionPtr, Condition, nullptr)\
+ MACRO(ExpressionPtr, Iteration, nullptr)\
+ MACRO(ExpressionPtr, Body, nullptr)
+
+#define FUNCTION_EXPRESSION_MEMBERS(MACRO)\
+ MACRO(IPLString, Name, "")\
+ MACRO(IPLVector<IPLString>, ArgumentsIdentifiers, IPLVector<IPLString>())\
+ MACRO(ExpressionPtr, Body, nullptr)
+
+#define TOP_EXPRESSION_MEMBERS(MACRO)\
+ MACRO(IPLVector<ExpressionPtr>, Values, IPLVector<ExpressionPtr>())
+
+#define CALL_EXPRESSION_MEMBERS(MACRO)\
+ MACRO(ExpressionPtr, ObjectOrCall, ExpressionPtr())\
+ MACRO(ExpressionPtr, Member, ExpressionPtr())
+
+#define MEMBER_ACCESS_EXPRESSION_MEMBERS(MACRO)\
+ MACRO(IPLString, Name, "")
+
+#define MEMBER_NO_MEMBERS(MACRO)
+
+#define EXPRESSION_DEFINITION_ITERATOR(MACRO)\
+ MACRO(LiteralNull, NO_MEMBERS)\
+ MACRO(LiteralUndefined, NO_MEMBERS)\
+ MACRO(LiteralBoolean, LITERAL_BOOLEAN_MEMBERS)\
+ MACRO(LiteralNumber, LITERAL_NUMBER_MEMBERS)\
+ MACRO(LiteralString, LITERAL_STRING_MEMBERS)\
+ MACRO(LiteralField, LITERAL_FIELD_MEMBERS)\
+ MACRO(LiteralObject, LITERAL_OBJECT_MEMBERS)\
+ MACRO(BinaryExpression, BINARY_EXPRESSION_MEMBERS)\
+ MACRO(UnaryExpression, UNARY_EXPRESSION_MEMBERS)\
+ MACRO(IdentifierExpression, IDENTIFIER_EXPRESSION_MEMBERS)\
+ MACRO(VariableDefinitionExpression, VARIABLEDEFINITION_EXPRESSION_MEMBERS)\
+ MACRO(ListExpression, LIST_EXPRESSION_MEMBERS)\
+ MACRO(BlockStatement, BLOCK_EXPRESSION_MEMBERS)\
+ MACRO(LabeledStatement, LABELED_EXPRESSION_MEMBERS)\
+ MACRO(IfStatement, IF_EXPRESSION_MEMBERS)\
+ MACRO(SwitchStatement, SWITCH_EXPRESSION_MEMBERS)\
+ MACRO(CaseStatement, CASE_EXPRESSION_MEMBERS)\
+ MACRO(WhileStatement, WHILE_EXPRESSION_MEMBERS)\
+ MACRO(ForStatement, FOR_EXPRESSION_MEMBERS)\
+ MACRO(FunctionDeclaration, FUNCTION_EXPRESSION_MEMBERS)\
+ MACRO(TopStatements, TOP_EXPRESSION_MEMBERS)\
+ MACRO(EmptyExpression, NO_MEMBERS)\
+ MACRO(Call, CALL_EXPRESSION_MEMBERS)\
+ MACRO(MemberAccess, MEMBER_ACCESS_EXPRESSION_MEMBERS)\
+ MACRO(Break, MEMBER_NO_MEMBERS)\
+ MACRO(Continue, MEMBER_NO_MEMBERS)
diff --git a/JSImpl/src/ExpressionVisitor.h b/JSImpl/src/ExpressionVisitor.h
new file mode 100644
index 0000000..8fbab7d
--- /dev/null
+++ b/JSImpl/src/ExpressionVisitor.h
@@ -0,0 +1,39 @@
+#pragma once
+
+#include "ExpressionsFwd.h"
+
+class ExpressionVisitor
+{
+public:
+ virtual ~ExpressionVisitor() {}
+
+ virtual void Visit(LiteralNull* e) { (void)e; NOT_IMPLEMENTED; }
+ virtual void Visit(LiteralUndefined* e) { (void)e; NOT_IMPLEMENTED; }
+ virtual void Visit(LiteralString* e) { (void)e; NOT_IMPLEMENTED; }
+ virtual void Visit(LiteralNumber* e) { (void)e; NOT_IMPLEMENTED; }
+ virtual void Visit(LiteralBoolean* e) { (void)e; NOT_IMPLEMENTED; }
+ virtual void Visit(LiteralField* e) { (void)e; NOT_IMPLEMENTED; }
+ virtual void Visit(LiteralObject* e) { (void)e; NOT_IMPLEMENTED; }
+ virtual void Visit(BinaryExpression* e) { (void)e; NOT_IMPLEMENTED; }
+ virtual void Visit(UnaryExpression* e) { (void)e; NOT_IMPLEMENTED; }
+ virtual void Visit(IdentifierExpression* e) { (void)e; NOT_IMPLEMENTED; }
+ virtual void Visit(ListExpression* e) { (void)e; NOT_IMPLEMENTED; }
+ virtual void Visit(VariableDefinitionExpression* e) { (void)e; NOT_IMPLEMENTED; }
+ virtual void Visit(BlockStatement* e) { (void)e; NOT_IMPLEMENTED; }
+ virtual void Visit(LabeledStatement* e) { (void)e; NOT_IMPLEMENTED; }
+ virtual void Visit(IfStatement* e) { (void)e; NOT_IMPLEMENTED; }
+ virtual void Visit(SwitchStatement* e) { (void)e; NOT_IMPLEMENTED; }
+ virtual void Visit(CaseStatement *e) { (void)e; NOT_IMPLEMENTED; }
+ virtual void Visit(WhileStatement* e) { (void)e; NOT_IMPLEMENTED; }
+ virtual void Visit(ForStatement* e) { (void)e; NOT_IMPLEMENTED; }
+ virtual void Visit(Break* e) { (void)e; NOT_IMPLEMENTED; }
+ virtual void Visit(Continue* e) { (void)e; NOT_IMPLEMENTED; }
+ virtual void Visit(FunctionDeclaration* e) { (void)e; NOT_IMPLEMENTED; }
+ virtual void Visit(TopStatements* e) { (void)e; NOT_IMPLEMENTED; }
+ virtual void Visit(EmptyExpression* e) { (void)e; NOT_IMPLEMENTED; }
+ virtual void Visit(Call* e) { (void)e; NOT_IMPLEMENTED; }
+ virtual void Visit(MemberAccess* e) { (void)e; NOT_IMPLEMENTED; }
+
+ virtual void Visit(Expression* e) { (void)e; NOT_IMPLEMENTED; } // Unkown case
+
+}; \ No newline at end of file
diff --git a/JSImpl/src/ExpressionsFwd.h b/JSImpl/src/ExpressionsFwd.h
new file mode 100644
index 0000000..753167d
--- /dev/null
+++ b/JSImpl/src/ExpressionsFwd.h
@@ -0,0 +1,33 @@
+#pragma once
+#include "CommonTypes.h"
+
+class LiteralNull;
+class LiteralUndefined;
+class LiteralNumber;
+class LiteralString;
+class LiteralBoolean;
+class LiteralField;
+class LiteralObject;
+class Expression;
+class BinaryExpression;
+class UnaryExpression;
+class LiteralExpression;
+class IdentifierExpression;
+class ListExpression;
+class VariableDefinitionExpression;
+class BlockStatement;
+class LabeledStatement;
+class IfStatement;
+class SwitchStatement;
+class CaseStatement;
+class WhileStatement;
+class ForStatement;
+class FunctionDeclaration;
+class TopStatements;
+class EmptyExpression;
+class Call;
+class MemberAccess;
+class Break;
+class Continue;
+
+using ExpressionPtr = IPLSharedPtr<Expression>;
diff --git a/JSImpl/src/JSONParser.cpp b/JSImpl/src/JSONParser.cpp
new file mode 100644
index 0000000..3f87aad
--- /dev/null
+++ b/JSImpl/src/JSONParser.cpp
@@ -0,0 +1,369 @@
+#include "JSONParser.h"
+#include "ExpressionDefinitions.h"
+
+#include <unordered_map>
+#include <cstdlib>
+#include <cstring>
+
+void SkipWhitespaces(const char*& json)
+{
+ while (*json && (*json == ' ' || *json == '\t' || *json == '\n'))
+ {
+ ++json;
+ }
+}
+
+inline void PassStringToVal(const char*& json, const char* name)
+{
+ SkipWhitespaces(json);
+ json += 1/*"*/ + strlen(name) + 3/*": */;
+}
+
+inline void PassStringToString(const char*& json, const char* name)
+{
+ PassStringToVal(json, name);
+ ++json; //"
+}
+
+inline void PassStringToArray(const char*& json, const char* name)
+{
+ PassStringToString(json, name);
+}
+
+inline void PassStatementEnd(const char*& json, bool isLast)
+{
+ if (!isLast)
+ {
+ ++json; //,
+ }
+}
+
+void JSONParse(const char*& json, const char* name, bool isLast, bool& value);
+void JSONParse(const char*& json, const char* name, bool isLast, double& value);
+void JSONParse(const char*& json, const char* name, bool isLast, IPLString& value);
+void JSONParse(const char*& json, const char* name, bool isLast, TokenType& value);
+void JSONParse(const char*& json, const char* name, bool isLast, ExpressionPtr& value);
+void JSONParse(const char*& json, const char* name, bool isLast, IPLVector<ExpressionPtr>& value);
+void JSONParse(const char*& json, const char* name, bool isLast, IPLVector<IPLString>& value);
+
+#define GENERATE_EXPRESSION_TYPE_ENUMS(ClassName, MEMBERS_ITERATOR) \
+enum class ClassName##Type : unsigned char \
+{ \
+ Invalid \
+};
+EXPRESSION_DEFINITION_ITERATOR(GENERATE_EXPRESSION_TYPE_ENUMS);
+#undef GENERATE_EXPRESSION_TYPE_ENUM_MEMBERS
+
+template <typename T>
+ExpressionPtr JSONParseWrap(const char*&, const char*)
+{
+ assert(false);
+ return nullptr;
+}
+
+#define MEMBERS_COUNT(type, name, def) \
+ ++membersCount;
+
+#define VISIT_MEMBER(type, name, def) \
+ ++currentVisitCount; \
+ JSONParse(json, #name, currentVisitCount == membersCount, ptr->Get##name##ByRef()); \
+
+#define GENERATE_JSON_PARSE_FUNCTION_DEFINITIONS(ClassName, MEMBERS_ITERATOR) \
+template <> \
+ExpressionPtr JSONParseWrap<ClassName##Type>(const char*& json, const char* eName) \
+{ \
+ auto ptr = IPLMakeSharePtr<::ClassName>(); \
+ int membersCount = 0, currentVisitCount = 0; \
+ (void)currentVisitCount; \
+ json += strlen("{"); \
+ SkipWhitespaces(json); \
+ json += strlen("\"ExpresionType\": \"") + strlen(eName) + strlen("\","); \
+ SkipWhitespaces(json); \
+ MEMBERS_ITERATOR(MEMBERS_COUNT); \
+ SkipWhitespaces(json); \
+ if (membersCount) \
+ { \
+ json += strlen(","); \
+ } \
+ SkipWhitespaces(json); \
+ MEMBERS_ITERATOR(VISIT_MEMBER); \
+ SkipWhitespaces(json); \
+ json += strlen("}"); \
+ return ptr; \
+}
+
+EXPRESSION_DEFINITION_ITERATOR(GENERATE_JSON_PARSE_FUNCTION_DEFINITIONS);
+#undef GENERATE_JSON_PARSE_FUNCTION_DEFINITIONS
+#undef MEMBERS_COUNT
+#undef VISIT_MEMBER
+
+IPLString ReadExpressionType(const char* json)
+{
+ IPLString str;
+
+ SkipWhitespaces(json);
+ ++json; //{
+ SkipWhitespaces(json);
+ json += strlen("\"ExpressionType\": \"");
+
+ while (*json != '"')
+ {
+ str += *json++;
+ }
+
+ return str;
+}
+
+#define EXPRESSION_PARSE_CALLER_CASES(ClassName, MEMBERS_ITERATOR) \
+ if (type.compare(#ClassName) == 0) \
+ return JSONParseWrap<ClassName##Type>(json, #ClassName);
+
+ExpressionPtr ExpressionParseCaller(const IPLString& type, const char*& json)
+{
+ EXPRESSION_DEFINITION_ITERATOR(EXPRESSION_PARSE_CALLER_CASES);
+
+ assert(false);
+ return nullptr;
+}
+
+#undef EXPRESSION_PARSE_CALLER_CASES
+
+std::unordered_map<IPLString, TokenType> GetTokenTable()
+{
+ std::unordered_map<IPLString, TokenType> table;
+ table["LeftParen"] = TokenType::LeftParen;
+ table["RightParen"] = TokenType::RightParen;
+ table["LeftBrace"] = TokenType::LeftBrace;
+ table["RightBrace"] = TokenType::RightBrace;
+ table["Comma"] = TokenType::Comma;
+ table["Dot"] = TokenType::Dot;
+ table["Minus"] = TokenType::Minus;
+ table["Plus"] = TokenType::Plus;
+ table["Semicolon"] = TokenType::Semicolon;
+ table["Star"] = TokenType::Star;
+ table["Division"] = TokenType::Division;
+ table["Modulo"] = TokenType::Modulo;
+ table["BitwiseNot"] = TokenType::BitwiseNot;
+ table["BitwiseAnd"] = TokenType::BitwiseAnd;
+ table["BitwiseXor"] = TokenType::BitwiseXor;
+ table["BitwiseOr"] = TokenType::BitwiseOr;
+ table["QuestionMark"] = TokenType::QuestionMark;
+ table["Colon"] = TokenType::Colon;
+ table["LeftSquareBracket"] = TokenType::LeftSquareBracket;
+ table["RightSquareBracket"] = TokenType::RightSquareBracket;
+ table["Bang"] = TokenType::Bang;
+ table["BangEqual"] = TokenType::BangEqual;
+ table["Equal"] = TokenType::Equal;
+ table["EqualEqual"] = TokenType::EqualEqual;
+ table["StrictEqual"] = TokenType::StrictEqual;
+ table["StrictNotEqual"] = TokenType::StrictNotEqual;
+ table["Greater"] = TokenType::Greater;
+ table["GreaterEqual"] = TokenType::GreaterEqual;
+ table["Less"] = TokenType::Less;
+ table["LessEqual"] = TokenType::LessEqual;
+ table["MinusMinus"] = TokenType::MinusMinus;
+ table["PlusPlus"] = TokenType::PlusPlus;
+ table["LeftShift"] = TokenType::LeftShift;
+ table["RightShift"] = TokenType::RightShift;
+ table["LogicalAnd"] = TokenType::LogicalAnd;
+ table["LogicalOr"] = TokenType::LogicalOr;
+ table["StarEqual"] = TokenType::StarEqual;
+ table["DivideEqual"] = TokenType::DivideEqual;
+ table["ModuloEqual"] = TokenType::ModuloEqual;
+ table["PlusEqual"] = TokenType::PlusEqual;
+ table["MinusEqual"] = TokenType::MinusEqual;
+ table["LeftShiftEqual"] = TokenType::LeftShiftEqual;
+ table["RightShiftEqual"] = TokenType::RightShiftEqual;
+ table["BitwiseAndEqual"] = TokenType::BitwiseAndEqual;
+ table["BitwiseXorEqual"] = TokenType::BitwiseXorEqual;
+ table["BitwiseOrEqual"] = TokenType::BitwiseOrEqual;
+ table["Identifier"] = TokenType::Identifier;
+ table["String"] = TokenType::String;
+ table["Number"] = TokenType::Number;
+ table["Break"] = TokenType::Break;
+ table["Case"] = TokenType::Case;
+ table["Catch"] = TokenType::Catch;
+ table["Class"] = TokenType::Class;
+ table["Const"] = TokenType::Const;
+ table["Continue"] = TokenType::Continue;
+ table["Debugger"] = TokenType::Debugger;
+ table["Default"] = TokenType::Default;
+ table["Delete"] = TokenType::Delete;
+ table["Do"] = TokenType::Do;
+ table["Else"] = TokenType::Else;
+ table["Export"] = TokenType::Export;
+ table["Extends"] = TokenType::Extends;
+ table["Finally"] = TokenType::Finally;
+ table["For"] = TokenType::For;
+ table["Function"] = TokenType::Function;
+ table["If"] = TokenType::If;
+ table["Import"] = TokenType::Import;
+ table["In"] = TokenType::In;
+ table["Instanceof"] = TokenType::Instanceof;
+ table["New"] = TokenType::New;
+ table["Return"] = TokenType::Return;
+ table["Super"] = TokenType::Super;
+ table["Switch"] = TokenType::Switch;
+ table["This"] = TokenType::This;
+ table["Throw"] = TokenType::Throw;
+ table["Try"] = TokenType::Try;
+ table["Typeof"] = TokenType::Typeof;
+ table["Var"] = TokenType::Var;
+ table["Void"] = TokenType::Void;
+ table["While"] = TokenType::While;
+ table["With"] = TokenType::With;
+ table["Yield"] = TokenType::Yield;
+ table["Null"] = TokenType::Null;
+ table["Undefined"] = TokenType::Undefined;
+ table["True"] = TokenType::True;
+ table["False"] = TokenType::False;
+ table["Eof"] = TokenType::Eof;
+ return table;
+}
+
+TokenType StringToToken(IPLString str)
+{
+ static const auto table = GetTokenTable();
+
+ auto it = table.find(str);
+ if (it == table.end())
+ {
+ assert(false);
+ return TokenType::Invalid;
+ }
+
+ return it->second;
+}
+
+void JSONParse(const char*& json, const char* name, bool isLast, bool& value)
+{
+ PassStringToVal(json, name);
+
+ if (*json == '1')
+ {
+ value = true;
+ }
+ else
+ {
+ value = false;
+ }
+
+ ++json;
+
+ PassStatementEnd(json, isLast);
+}
+
+void JSONParse(const char*& json, const char* name, bool isLast, double& value)
+{
+ PassStringToVal(json, name);
+
+ value = atof(json);
+
+ while ((*json >= '0' && *json <= '9') || *json == '.')
+ {
+ ++json;
+ }
+
+ PassStatementEnd(json, isLast);
+}
+
+void JSONParse(const char*& json, const char* name, bool isLast, IPLString& value)
+{
+ PassStringToString(json, name);
+
+ while (*json != '"')
+ {
+ value += *json++;
+ }
+
+ ++json; //"
+
+ PassStatementEnd(json, isLast);
+}
+
+void JSONParse(const char*& json, const char* name, bool isLast, TokenType& value)
+{
+ PassStringToString(json, name);
+
+ IPLString str;
+ while (*json != '"')
+ {
+ str += *json++;
+ }
+
+ value = StringToToken(str.c_str());
+
+ ++json; //"
+
+ PassStatementEnd(json, isLast);
+}
+
+void JSONParse(const char*& json, const char* name, bool isLast, ExpressionPtr& value)
+{
+ PassStringToVal(json, name);
+
+ const IPLString& type = ReadExpressionType(json);
+ value = ExpressionParseCaller(type, json);
+
+ PassStatementEnd(json, isLast);
+}
+
+void JSONParse(const char*& json, const char* name, bool isLast, IPLVector<ExpressionPtr>& value)
+{
+ PassStringToArray(json, name);
+
+ while (true)
+ {
+ SkipWhitespaces(json);
+ if (*json == ']')
+ {
+ ++json;
+ PassStatementEnd(json, isLast);
+ return;
+ }
+
+ const IPLString& type = ReadExpressionType(json);
+ value.push_back(ExpressionParseCaller(type, json));
+
+ if (*json == ',')
+ {
+ ++json;
+ }
+ }
+}
+
+void JSONParse(const char*& json, const char* name, bool isLast, IPLVector<IPLString>& value)
+{
+ PassStringToArray(json, name);
+
+ while (true)
+ {
+ SkipWhitespaces(json);
+ if (*json == ']')
+ {
+ ++json;
+ PassStatementEnd(json, isLast);
+ return;
+ }
+
+ value.push_back(IPLString());
+
+ ++json;
+ while (*json != '"')
+ {
+ value.back() += *json;
+ ++json;
+ }
+ ++json;
+
+ if (*json == ',')
+ {
+ ++json;
+ }
+ }
+}
+
+ExpressionPtr ParseJSON(const char* json)
+{
+ return JSONParseWrap<TopStatementsType>(json, "TopStatements");
+}
diff --git a/JSImpl/src/JSONParser.h b/JSImpl/src/JSONParser.h
new file mode 100644
index 0000000..a32f447
--- /dev/null
+++ b/JSImpl/src/JSONParser.h
@@ -0,0 +1,5 @@
+#pragma once
+
+#include "Expression.h"
+
+ExpressionPtr ParseJSON(const char*); \ No newline at end of file
diff --git a/JSImpl/src/Lexer.cpp b/JSImpl/src/Lexer.cpp
new file mode 100644
index 0000000..30a7e42
--- /dev/null
+++ b/JSImpl/src/Lexer.cpp
@@ -0,0 +1,573 @@
+#include "Lexer.h"
+#include <utility>
+
+namespace
+{
+inline bool IsUpperCase(char c)
+{
+ return c >= 'A' && c <= 'Z';
+}
+
+inline bool IsLowerCase(char c)
+{
+ return c >= 'a' && c <= 'z';
+}
+
+inline bool IsDigit(char c)
+{
+ return c >= '0' && c <= '9';
+}
+
+inline bool IsValidIdentifierStartingChar(char c)
+{
+ return IsUpperCase(c) || IsLowerCase(c) || c == '_';
+}
+
+inline bool IsValidIdentifierChar(char c)
+{
+ return IsValidIdentifierStartingChar(c) || IsDigit(c);
+}
+
+inline bool IsStringBound(char c)
+{
+ return c == '\'' || c == '"';
+}
+
+inline bool IsNewLine(char c)
+{
+ return c == '\n';
+}
+
+inline bool IsEnd(char c)
+{
+ return c == '\0';
+}
+}
+
+struct Keyword
+{
+ TokenType Type;
+ IPLString Content;
+};
+
+using Identifier = Keyword;
+
+enum class State : unsigned char
+{
+ Success,
+ Fail,
+ Error
+};
+
+#define RETURN_SUCCESS(ret) m_GenerationState = State::Success; return ret;
+#define RETURN_FAIL(ret) m_GenerationState = State::Fail; return ret;
+#define RETURN_ERROR(ret) m_GenerationState = State::Error; return ret;
+
+class Tokenizer
+{
+public:
+ Tokenizer(const char* code, const LexerSettings& settings);
+ LexerResult Tokenize();
+
+private:
+ Token NextToken();
+
+ inline Token ProduceSkipToken();
+ inline Token ProduceToken(TokenType type);
+ inline Token ProduceToken(TokenType type, const IPLString& lexeme, double number);
+ inline Token ProduceErrorToken();
+ inline Token ProduceInvalidToken();
+
+ bool FilterToken(TokenType type);
+
+ IPLString ParseComment();
+ double ParseNumber();
+ IPLString ParseString();
+ Keyword ParseKeyword();
+ Identifier ParseIdentifier();
+
+ inline bool IsStateSuccess() const;
+ inline bool IsStateError() const;
+
+ void SetError(const IPLString& what);
+
+ bool Match(const char c);
+
+ inline void NextSymbol();
+ inline void PreviousSymbol();
+ inline void NextLine();
+
+ unsigned m_Line;
+ unsigned m_Column;
+ unsigned m_Current;
+ unsigned m_LastTokenPozition;
+ const char* m_Code;
+
+ IPLError m_Error;
+ State m_GenerationState;
+
+ LexerSettings m_Settings;
+
+ IPLUnorderedMap<IPLString, TokenType> m_KeyWordsTable;
+};
+
+LexerResult Tokenize(const char* code, const LexerSettings& settings)
+{
+ Tokenizer tokenizer(code, settings);
+ return tokenizer.Tokenize();
+}
+
+LexerResult Tokenize(const char * code)
+{
+ return Tokenize(code, { false, false });
+}
+
+Tokenizer::Tokenizer(const char* code, const LexerSettings& settings)
+ : m_Line(0)
+ , m_Column(0)
+ , m_Current(0)
+ , m_LastTokenPozition(0)
+ , m_Code(code)
+ , m_Error()
+ , m_GenerationState(State::Success)
+ , m_Settings(settings)
+{
+ m_KeyWordsTable["break"] = TokenType::Break;
+ m_KeyWordsTable["case"] = TokenType::Case;
+ m_KeyWordsTable["catch"] = TokenType::Catch;
+ m_KeyWordsTable["class"] = TokenType::Class;
+ m_KeyWordsTable["const"] = TokenType::Const;
+ m_KeyWordsTable["continue"] = TokenType::Continue;
+ m_KeyWordsTable["debugger"] = TokenType::Debugger;
+ m_KeyWordsTable["default"] = TokenType::Default;
+ m_KeyWordsTable["delete"] = TokenType::Delete;
+ m_KeyWordsTable["do"] = TokenType::Do;
+ m_KeyWordsTable["else"] = TokenType::Else;
+ m_KeyWordsTable["export"] = TokenType::Export;
+ m_KeyWordsTable["extends"] = TokenType::Extends;
+ m_KeyWordsTable["finally"] = TokenType::Finally;
+ m_KeyWordsTable["for"] = TokenType::For;
+ m_KeyWordsTable["function"] = TokenType::Function;
+ m_KeyWordsTable["if"] = TokenType::If;
+ m_KeyWordsTable["import"] = TokenType::Import;
+ m_KeyWordsTable["in"] = TokenType::In;
+ m_KeyWordsTable["instanceof"] = TokenType::Instanceof;
+ m_KeyWordsTable["new"] = TokenType::New;
+ m_KeyWordsTable["return"] = TokenType::Return;
+ m_KeyWordsTable["super"] = TokenType::Super;
+ m_KeyWordsTable["switch"] = TokenType::Switch;
+ m_KeyWordsTable["this"] = TokenType::This;
+ m_KeyWordsTable["throw"] = TokenType::Throw;
+ m_KeyWordsTable["try"] = TokenType::Try;
+ m_KeyWordsTable["typeof"] = TokenType::Typeof;
+ m_KeyWordsTable["var"] = TokenType::Var;
+ m_KeyWordsTable["let"] = TokenType::Let;
+ m_KeyWordsTable["void"] = TokenType::Void;
+ m_KeyWordsTable["while"] = TokenType::While;
+ m_KeyWordsTable["with"] = TokenType::With;
+ m_KeyWordsTable["yield"] = TokenType::Yield;
+ m_KeyWordsTable["null"] = TokenType::Null;
+ m_KeyWordsTable["undefined"] = TokenType::Undefined;
+ m_KeyWordsTable["true"] = TokenType::True;
+ m_KeyWordsTable["false"] = TokenType::False;
+}
+
+LexerResult Tokenizer::Tokenize()
+{
+ LexerResult result{ true, IPLError(), IPLVector<Token>() };
+ Token token;
+ do
+ {
+ token = NextToken();
+
+ if (m_GenerationState == State::Error )
+ {
+ result.IsSuccessful = false;
+ result.Error = IPLError(m_Error);
+ return result;
+ }
+ if (FilterToken(token.Type))
+ {
+ result.tokens.emplace_back(token);
+ }
+ } while (token.Type != TokenType::Eof && token.Type != TokenType::Invalid);
+
+ return result;
+}
+
+bool Tokenizer::FilterToken(TokenType type)
+{
+ if (type == TokenType::Comment)
+ {
+ return m_Settings.CreateCommentTokens;
+ }
+ else if (type == TokenType::Whitespace ||
+ type == TokenType::Tab ||
+ type == TokenType::NewLine)
+ {
+ return m_Settings.CreateWhitespaceTokens;
+ }
+ return true;
+}
+
+bool Tokenizer::Match(const char c)
+{
+ if (c == m_Code[m_Current])
+ {
+ NextSymbol();
+ return true;
+ }
+ return false;
+}
+
+inline void Tokenizer::NextSymbol()
+{
+ ++m_Current;
+ ++m_Column;
+}
+
+inline void Tokenizer::PreviousSymbol()
+{
+ --m_Current;
+ --m_Column;
+}
+
+inline void Tokenizer::NextLine()
+{
+ ++m_Current;
+ ++m_Line;
+ m_LastTokenPozition = m_Column = 0;
+}
+
+inline Token Tokenizer::ProduceToken(TokenType type,const IPLString& lexeme, double number = 0.0)
+{
+ auto token = Token{ type, m_Line, m_LastTokenPozition, lexeme, number };
+ m_LastTokenPozition = m_Column;
+ return token;
+}
+
+inline Token Tokenizer::ProduceSkipToken()
+{
+ return ProduceToken(TokenType::Invalid, "");
+}
+
+inline Token Tokenizer::ProduceToken(TokenType type)
+{
+ switch (type)
+ {
+ case TokenType::RightSquareBracket:
+ return ProduceToken(type, "]");
+ case TokenType::LeftSquareBracket:
+ return ProduceToken(type, "[");
+ case TokenType::Colon:
+ return ProduceToken(type, ":");
+ case TokenType::QuestionMark:
+ return ProduceToken(type, "?");
+ case TokenType::BitwiseXor:
+ return ProduceToken(type, "^");
+ case TokenType::LogicalOr:
+ return ProduceToken(type, "||");
+ case TokenType::BitwiseOr:
+ return ProduceToken(type, "|");
+ case TokenType::LogicalAnd:
+ return ProduceToken(type, "&&");
+ case TokenType::BitwiseAnd:
+ return ProduceToken(type, "&");
+ case TokenType::LessEqual:
+ return ProduceToken(type, "<=");
+ case TokenType::LeftShift:
+ return ProduceToken(type, "<<");
+ case TokenType::Less:
+ return ProduceToken(type, "<");
+ case TokenType::GreaterEqual:
+ return ProduceToken(type, ">=");
+ case TokenType::RightShift:
+ return ProduceToken(type, ">>");
+ case TokenType::Greater:
+ return ProduceToken(type, ">");
+ case TokenType::StrictNotEqual:
+ return ProduceToken(type, "!==");
+ case TokenType::BangEqual:
+ return ProduceToken(type, "!=");
+ case TokenType::Bang:
+ return ProduceToken(type, "!");
+ case TokenType::StrictEqual:
+ return ProduceToken(type, "===");
+ case TokenType::EqualEqual:
+ return ProduceToken(type, "==");
+ case TokenType::Equal:
+ return ProduceToken(type, "=");
+ case TokenType::BitwiseNot:
+ return ProduceToken(type, "~");
+ case TokenType::Modulo:
+ return ProduceToken(type, "%");
+ case TokenType::Division:
+ return ProduceToken(type, "/");
+ case TokenType::LeftParen:
+ return ProduceToken(type, "(");
+ case TokenType::RightParen:
+ return ProduceToken(type, ")");
+ case TokenType::LeftBrace:
+ return ProduceToken(type, "{");
+ case TokenType::RightBrace:
+ return ProduceToken(type, "}");
+ case TokenType::Comma:
+ return ProduceToken(type, ",");
+ case TokenType::Dot:
+ return ProduceToken(type, ".");
+ case TokenType::Minus:
+ return ProduceToken(type, "-");
+ case TokenType::MinusMinus:
+ return ProduceToken(type, "--");
+ case TokenType::Plus:
+ return ProduceToken(type, "+");
+ case TokenType::PlusPlus:
+ return ProduceToken(type, "++");
+ case TokenType::Semicolon:
+ return ProduceToken(type, ";");
+ case TokenType::Star:
+ return ProduceToken(type, "*");
+ case TokenType::Backslash:
+ return ProduceToken(type, "\\");
+ default: // EoF Invalid
+ break;
+ }
+ return ProduceToken(type, "");
+}
+
+inline Token Tokenizer::ProduceErrorToken()
+{
+ return ProduceToken(TokenType::Invalid, "");
+}
+
+inline Token Tokenizer::ProduceInvalidToken()
+{
+ SetError("Invalid or unexpected token");
+ RETURN_ERROR(ProduceToken(TokenType::Invalid, ""));
+}
+
+IPLString Tokenizer::ParseComment()
+{
+ auto start = m_Current;
+
+ if (!Match('/'))
+ {
+ RETURN_FAIL(IPLString());
+ }
+
+ if (Match('/'))
+ {
+ while (!IsEnd(m_Code[m_Current]) && !IsNewLine(m_Code[m_Current]))
+ {
+ NextSymbol();
+ }
+ RETURN_SUCCESS(IPLString(m_Code + start, m_Code + m_Current))
+ }
+ else if (!Match('*'))
+ {
+ PreviousSymbol();
+ RETURN_FAIL(IPLString());
+ }
+
+ while (!IsEnd(m_Code[m_Current]))
+ {
+ if (Match('*') && Match('/'))
+ {
+ RETURN_SUCCESS(IPLString(m_Code + start, m_Code + m_Current));
+ }
+ NextSymbol();
+ }
+
+ SetError("unterminated comment");
+ RETURN_ERROR(IPLString());
+}
+
+double Tokenizer::ParseNumber()
+{
+ if (!IsDigit(m_Code[m_Current]))
+ {
+ RETURN_FAIL(0.0);
+ }
+
+ size_t parsedBytes = 0;
+ double number = std::stod(m_Code + m_Current, &parsedBytes);
+ m_Current += static_cast<unsigned>(parsedBytes);
+ m_Column += static_cast<unsigned>(parsedBytes);
+
+ RETURN_SUCCESS(number);
+}
+
+IPLString Tokenizer::ParseString()
+{
+ if (!IsStringBound(m_Code[m_Current]))
+ {
+ RETURN_FAIL(IPLString());
+ }
+
+ char bound = m_Code[m_Current];
+ auto start = m_Current;
+
+ // skip first " or '
+ NextSymbol();
+ while (m_Code[m_Current] != bound && !IsEnd(m_Code[m_Current]) && !IsNewLine(m_Code[m_Current]))
+ {
+ NextSymbol();
+ }
+
+ if (IsEnd(m_Code[m_Current]) || IsNewLine(m_Code[m_Current]))
+ {
+ SetError("\"\" string literal contains an unescaped line break");
+ RETURN_ERROR(IPLString());
+ }
+
+ // skip second " or '
+ NextSymbol();
+
+ RETURN_SUCCESS(IPLString(m_Code + start, m_Code + m_Current));
+}
+
+Keyword Tokenizer::ParseKeyword()
+{
+ if (!IsLowerCase(m_Code[m_Current]))
+ {
+ RETURN_FAIL(Keyword());
+ }
+
+ auto start = m_Current;
+
+ NextSymbol();
+ while (IsLowerCase(m_Code[m_Current]))
+ {
+ NextSymbol();
+ }
+
+ auto key = IPLString(m_Code + start, m_Code + m_Current);
+ auto keyword = m_KeyWordsTable.find(key);
+
+ if (keyword == m_KeyWordsTable.end())
+ {
+ // It's not a keyword so we must revert current counter
+ m_Column -= m_Current - start;
+ m_Current = start;
+
+ RETURN_FAIL(Keyword());
+ }
+
+ RETURN_SUCCESS((Keyword{ keyword->second, keyword->first }));
+}
+
+Identifier Tokenizer::ParseIdentifier()
+{
+ if (!IsValidIdentifierStartingChar(m_Code[m_Current]))
+ {
+ RETURN_FAIL(Identifier());
+ }
+
+ auto start = m_Current;
+
+ NextSymbol();
+ while (IsValidIdentifierChar(m_Code[m_Current]))
+ {
+ NextSymbol();
+ }
+
+ RETURN_SUCCESS((Identifier{ TokenType::Identifier, IPLString(m_Code + start, m_Code + m_Current) }));
+}
+
+inline bool Tokenizer::IsStateSuccess() const
+{
+ return m_GenerationState == State::Success;
+}
+
+inline bool Tokenizer::IsStateError() const
+{
+ return m_GenerationState == State::Error;
+}
+
+void Tokenizer::SetError(const IPLString& what)
+{
+ m_Error = IPLError{ m_Line, m_Column, "", "Syntax error: " + what };
+}
+
+Token Tokenizer::NextToken()
+{
+ if (IsEnd(m_Code[m_Current]))
+ {
+ return ProduceToken(TokenType::Eof);
+ }
+
+ const auto& comment = ParseComment();
+ if (IsStateError())
+ {
+ return ProduceErrorToken();
+ }
+ if (IsStateSuccess())
+ {
+ return ProduceToken(TokenType::Comment, comment);
+ }
+
+ // Single Char
+ switch (m_Code[m_Current])
+ {
+ case '(': NextSymbol(); return ProduceToken(TokenType::LeftParen);
+ case ')': NextSymbol(); return ProduceToken(TokenType::RightParen);
+ case '{': NextSymbol(); return ProduceToken(TokenType::LeftBrace);
+ case '}': NextSymbol(); return ProduceToken(TokenType::RightBrace);
+ case ',': NextSymbol(); return ProduceToken(TokenType::Comma);
+ case '.': NextSymbol(); return ProduceToken(TokenType::Dot);
+ case '-': NextSymbol(); return Match('-') ? ProduceToken(TokenType::MinusMinus) : ProduceToken(TokenType::Minus);
+ case '+': NextSymbol(); return Match('+') ? ProduceToken(TokenType::PlusPlus) : ProduceToken(TokenType::Plus);
+ case ';': NextSymbol(); return ProduceToken(TokenType::Semicolon);
+ case '*': NextSymbol(); return ProduceToken(TokenType::Star);
+ case '/': NextSymbol(); return ProduceToken(TokenType::Division);
+ case '%': NextSymbol(); return ProduceToken(TokenType::Modulo);
+ case '~': NextSymbol(); return ProduceToken(TokenType::BitwiseNot);
+ case '=': NextSymbol(); return Match('=') ? Match('=') ? ProduceToken(TokenType::StrictEqual) : ProduceToken(TokenType::EqualEqual) : ProduceToken(TokenType::Equal);
+ case '!': NextSymbol(); return Match('=') ? Match('=') ? ProduceToken(TokenType::StrictNotEqual) : ProduceToken(TokenType::BangEqual) : ProduceToken(TokenType::Bang);
+ case '>': NextSymbol(); return Match('=') ? ProduceToken(TokenType::GreaterEqual) : Match('>') ? ProduceToken(TokenType::RightShift) : ProduceToken(TokenType::Greater);
+ case '<': NextSymbol(); return Match('=') ? ProduceToken(TokenType::LessEqual) : Match('<') ? ProduceToken(TokenType::LeftShift) : ProduceToken(TokenType::Less);
+ case '&': NextSymbol(); return Match('&') ? ProduceToken(TokenType::LogicalAnd) : ProduceToken(TokenType::BitwiseAnd);
+ case '^': NextSymbol(); return ProduceToken(TokenType::BitwiseXor);
+ case '|': NextSymbol(); return Match('|') ? ProduceToken(TokenType::LogicalOr) : ProduceToken(TokenType::BitwiseOr);
+ case '?': NextSymbol(); return ProduceToken(TokenType::QuestionMark);
+ case ':': NextSymbol(); return ProduceToken(TokenType::Colon);
+ case '[': NextSymbol(); return ProduceToken(TokenType::LeftSquareBracket);
+ case ']': NextSymbol(); return ProduceToken(TokenType::RightSquareBracket);
+ case '\\': NextSymbol(); return ProduceToken(TokenType::Backslash);
+ case '\n': NextLine(); return ProduceToken(TokenType::NewLine);
+ case ' ': NextSymbol(); return ProduceToken(TokenType::Whitespace);
+ case '\t': NextSymbol(); return ProduceToken(TokenType::Tab);
+ default:
+ break;
+ }
+
+ const auto& number = ParseNumber();
+ if (IsStateSuccess())
+ {
+ return ProduceToken(TokenType::Number, "", number);
+ }
+
+ const auto& string = ParseString();
+ if (IsStateSuccess())
+ {
+ return ProduceToken(TokenType::String, string);
+ }
+ else if (IsStateError())
+ {
+ return ProduceErrorToken();
+ }
+
+ const auto& keyword = ParseKeyword();
+ if (IsStateSuccess())
+ {
+ return ProduceToken(keyword.Type, keyword.Content);
+ }
+
+ const auto& identifier = ParseIdentifier();
+ if (IsStateSuccess())
+ {
+ return ProduceToken(identifier.Type, identifier.Content);
+ }
+
+ return ProduceInvalidToken();
+}
diff --git a/JSImpl/src/Lexer.h b/JSImpl/src/Lexer.h
new file mode 100644
index 0000000..00acc7a
--- /dev/null
+++ b/JSImpl/src/Lexer.h
@@ -0,0 +1,134 @@
+#pragma once
+
+#include "CommonTypes.h"
+
+enum class TokenType
+{
+ // Single-character tokens.
+ LeftParen,
+ RightParen,
+ LeftBrace,
+ RightBrace,
+ Comma,
+ Dot,
+ Minus,
+ Plus,
+ Semicolon,
+ Star,
+ Division,
+ Modulo,
+ BitwiseNot,
+ BitwiseAnd,
+ BitwiseXor,
+ BitwiseOr,
+ QuestionMark,
+ Colon,
+ LeftSquareBracket,
+ RightSquareBracket,
+
+ // One or two character tokens
+ Bang,
+ BangEqual,
+ Equal,
+ EqualEqual,
+ StrictEqual,
+ StrictNotEqual,
+ Greater,
+ GreaterEqual,
+ Less,
+ LessEqual,
+ MinusMinus,
+ PlusPlus,
+ LeftShift,
+ RightShift,
+ LogicalAnd,
+ LogicalOr,
+ StarEqual,
+ DivideEqual,
+ ModuloEqual,
+ PlusEqual,
+ MinusEqual,
+ LeftShiftEqual,
+ RightShiftEqual,
+ BitwiseAndEqual,
+ BitwiseXorEqual,
+ BitwiseOrEqual,
+ Backslash,
+
+ Identifier,
+ String,
+ Number,
+
+ // Keywords. ECMAScript 2015
+ Break,
+ Case,
+ Catch,
+ Class,
+ Const,
+ Continue,
+ Debugger,
+ Default,
+ Delete,
+ Do,
+ Else,
+ Export,
+ Extends,
+ Finally,
+ For,
+ Function,
+ If,
+ Import,
+ In,
+ Instanceof,
+ New,
+ Return,
+ Super,
+ Switch,
+ This,
+ Throw,
+ Try,
+ Typeof,
+ Var,
+ Let,
+ Void,
+ While,
+ With,
+ Yield,
+ Null,
+ Undefined,
+ True,
+ False,
+
+ Whitespace,
+ Tab,
+ NewLine,
+ Comment,
+
+ Eof,
+ Invalid
+};
+
+struct Token
+{
+ TokenType Type;
+ unsigned Line;
+ unsigned Column;
+ IPLString Lexeme;
+ double Number;
+};
+
+struct LexerResult
+{
+ bool IsSuccessful;
+ IPLError Error;
+ IPLVector<Token> tokens;
+};
+
+struct LexerSettings
+{
+ bool CreateWhitespaceTokens;
+ bool CreateCommentTokens;
+};
+
+LexerResult Tokenize(const char* code, const LexerSettings& settings);
+LexerResult Tokenize(const char* code); \ No newline at end of file
diff --git a/JSImpl/src/Parser.cpp b/JSImpl/src/Parser.cpp
new file mode 100644
index 0000000..8f415fb
--- /dev/null
+++ b/JSImpl/src/Parser.cpp
@@ -0,0 +1,1198 @@
+#include "Parser.h"
+
+class Parser
+{
+public:
+ Parser(const IPLVector<Token>& tokens, const std::function<void()>& onError = {});
+ ExpressionPtr Parse();
+private:
+ enum NormalType {
+ Initial,
+ Normal,
+ };
+
+ enum AllowType {
+ AllowIn,
+ NoIn,
+ };
+
+ enum CompletenessType {
+ NoShortIf,
+ Full
+ };
+
+ bool MatchOneOf(IPLVector<TokenType> types);
+ bool Match(TokenType type);
+ bool Peek(TokenType type);
+ ExpressionPtr RegularExpression();
+ ExpressionPtr ParenthesizedExpression();
+ ExpressionPtr PrimaryExpression(NormalType a);
+ ExpressionPtr FunctionExpression();
+ ExpressionPtr ObjectLiteral();
+ ExpressionPtr ArrayLiteral();
+ ExpressionPtr Unary(NormalType a);
+ ExpressionPtr LeftSideExpression(NormalType a);
+ ExpressionPtr CallExpression(NormalType a);
+ ExpressionPtr CallExpressionHelper(NormalType a);
+ ExpressionPtr ShortNewExpression();
+ ExpressionPtr ShortNewSubexpression();
+ ExpressionPtr FullNewExpression();
+ ExpressionPtr FullNewSubexpression();
+ ExpressionPtr SimpleExpression();
+ ExpressionPtr MultiplicativeExpression(NormalType a);
+ ExpressionPtr AdditiveExpression(NormalType a);
+ ExpressionPtr ShiftExpression(NormalType a);
+ ExpressionPtr RelationalExpression(NormalType a, AllowType b);
+ ExpressionPtr EqualityExpression(NormalType a, AllowType b);
+ ExpressionPtr BitwiseExpression(NormalType a, AllowType b);
+ ExpressionPtr LogicalExpression(NormalType a, AllowType b);
+ ExpressionPtr ConditionalExpression(NormalType a, AllowType b);
+ ExpressionPtr AssignmentExpression(NormalType a, AllowType b);
+ ExpressionPtr Expression(NormalType a, AllowType b);
+ ExpressionPtr OptionalExpression();
+ ExpressionPtr Arguments();
+
+ //Statements
+ ExpressionPtr Statement();
+ ExpressionPtr EmptyStatement();
+ ExpressionPtr VariableDefinition(AllowType b);
+ ExpressionPtr Block();
+ ExpressionPtr LabeledStatement();
+ ExpressionPtr IfStatementfull();
+ ExpressionPtr SwitchStatement();
+ ExpressionPtr DoStatement();
+ ExpressionPtr WhileStatement();
+ ExpressionPtr ForStatement();
+ ExpressionPtr WithStatement();
+ ExpressionPtr ContinueStatement();
+ ExpressionPtr BreakStatement();
+ ExpressionPtr OptionalLabel();
+ ExpressionPtr ReturnStatement();
+ ExpressionPtr TryStatement();
+
+ ExpressionPtr FunctionDefinition();
+ ExpressionPtr Program();
+ ExpressionPtr TopStatements();
+ ExpressionPtr TopStatement();
+
+ struct InternalState
+ {
+ unsigned Current;
+ };
+
+ struct Location
+ {
+ unsigned Line;
+ unsigned Column;
+ };
+ Location GetLocation() const { return { m_Tokens[m_Current].Line , m_Tokens[m_Current].Column }; }
+
+ InternalState Snapshot();
+ void Restore(const InternalState& state);
+
+ Token& Prev() { return m_Tokens[m_Current - 1]; }
+ IPLVector<Token> m_Tokens;
+ unsigned m_Current;
+ std::function<void()> OnError;
+};
+
+Parser::Parser(const IPLVector<Token>& tokens, const std::function<void()>& onError)
+ : m_Tokens(tokens)
+ , m_Current(0)
+ , OnError(onError)
+{
+}
+
+bool Parser::MatchOneOf(IPLVector<TokenType> types)
+{
+ for (auto t : types)
+ {
+ if (t == m_Tokens[m_Current].Type)
+ {
+ ++m_Current;
+ return true;
+ }
+ }
+ return false;
+}
+
+bool Parser::Match(TokenType type)
+{
+ if (type == m_Tokens[m_Current].Type)
+ {
+ ++m_Current;
+ return true;
+ }
+ return false;
+}
+
+bool Parser::Peek(TokenType type)
+{
+ return type == m_Tokens[m_Current].Type;
+}
+
+ExpressionPtr Parser::RegularExpression()
+{
+ return nullptr;
+}
+
+ExpressionPtr Parser::PrimaryExpression(NormalType a)
+{
+ if (a == NormalType::Initial)
+ {
+ auto simple = SimpleExpression();
+ return simple;
+ }
+
+ if (auto simple = SimpleExpression())
+ {
+ return simple;
+ }
+ else if(auto function = FunctionExpression())
+ {
+ return function;
+ }
+ else if (auto object = ObjectLiteral())
+ {
+ return object;
+ }
+ return nullptr;
+}
+
+ExpressionPtr Parser::ParenthesizedExpression()
+{
+ if (Match(TokenType::LeftParen))
+ {
+ auto ex = Parser::Expression(NormalType::Normal, AllowType::AllowIn);
+ if (Match(TokenType::RightParen))
+ {
+ return ex;
+ }
+ // TODO log error
+ assert(false);
+ }
+ return nullptr;
+}
+
+ExpressionPtr Parser::FunctionExpression()
+{
+ auto FormalParameters = [&](IPLVector<IPLString>& identifiers) -> bool {
+ if (Match(TokenType::LeftParen))
+ {
+ while (Match(TokenType::Identifier))
+ {
+ identifiers.push_back(Prev().Lexeme);
+ if (!Match(TokenType::Comma))
+ {
+ break;
+ }
+ }
+
+ if (Match(TokenType::RightParen))
+ {
+ return true;
+ }
+ }
+ return false;
+ };
+
+ auto Body = [&]() -> ExpressionPtr {
+
+ if (Match(TokenType::LeftBrace))
+ {
+ auto ts = TopStatements();
+ if (Match(TokenType::RightBrace))
+ {
+ return ts;
+ }
+ }
+ return nullptr;
+ };
+
+ if (Match(TokenType::Function))
+ {
+ IPLString name;
+ if (Match(TokenType::Identifier))
+ {
+ name = Prev().Lexeme;
+ }
+ IPLVector<IPLString> identifiers;
+ if (FormalParameters(identifiers))
+ {
+ if (auto body = Body())
+ {
+ return IPLMakeSharePtr<FunctionDeclaration>(name, identifiers, body);
+ }
+ else
+ {
+ // TODO log error
+ return nullptr;
+ }
+ }
+ // TODO log error
+ return nullptr;
+ }
+ return nullptr;
+}
+
+ExpressionPtr Parser::ObjectLiteral()
+{
+ if (Match(TokenType::LeftBrace))
+ {
+ using FieldList = IPLVector<ExpressionPtr>;
+ auto MatchLiteralField = [&]() ->ExpressionPtr {
+ if (!Match(TokenType::Identifier))
+ {
+ return nullptr;
+ }
+ auto id = IPLMakeSharePtr<IdentifierExpression>(Prev().Lexeme);
+ if (!Match(TokenType::Colon))
+ {
+ return nullptr;
+ }
+ auto ae = AssignmentExpression(NormalType::Normal, AllowType::AllowIn);
+ return IPLMakeSharePtr<LiteralField>(id, ae);
+ };
+
+ auto MatchFieldList = [&](FieldList& result) -> bool {
+ auto lf = MatchLiteralField();
+ while (lf)
+ {
+ result.push_back(lf);
+ if (!Match(TokenType::Comma))
+ {
+ break;
+ }
+ lf = MatchLiteralField();
+ if (!lf)
+ {
+ // TODO log error
+ return false;
+ }
+ }
+ return true;
+ };
+ FieldList fl;
+ if (!MatchFieldList(fl))
+ {
+ return nullptr;
+ }
+ auto ol = IPLMakeSharePtr<LiteralObject>(fl);
+ if (Match(TokenType::RightBrace))
+ {
+ return ol;
+ }
+ // TODO Add error loging
+ assert(false);
+ }
+ return nullptr;
+}
+
+ExpressionPtr Parser::ArrayLiteral()
+{
+ if (Match(TokenType::LeftSquareBracket))
+ {
+ auto LiteralElement = [&]() -> ExpressionPtr {
+ return AssignmentExpression(NormalType::Normal, AllowType::AllowIn);
+ };
+
+ auto ElementList = [&]() -> ExpressionPtr {
+ auto result = IPLMakeSharePtr<ListExpression>();
+ while (auto lf = LiteralElement())
+ {
+ result->GetValuesByRef().push_back(lf);
+ if (!Match(TokenType::Comma))
+ {
+ break;
+ }
+ }
+ return result;
+ };
+
+ auto el = ElementList();
+ if (Match(TokenType::RightSquareBracket)) {
+ return el;
+ }
+ // TODO Add error loging
+ assert(false);
+ }
+ return nullptr;
+}
+
+ExpressionPtr Parser::SimpleExpression()
+{
+ if (Match(TokenType::Number))
+ {
+ return IPLMakeSharePtr<LiteralNumber>(Prev().Number);
+ }
+ else if (Match(TokenType::String))
+ {
+ const auto& lexeme = Prev().Lexeme;
+ const auto length = lexeme.length();
+ assert(length >= 2);
+ auto value = lexeme.substr(1, length-2);
+ return IPLMakeSharePtr<LiteralString>(value);
+ }
+ else if (Match(TokenType::Null))
+ {
+ return IPLMakeSharePtr<LiteralNull>();
+ }
+ else if (Match(TokenType::Undefined))
+ {
+ return IPLMakeSharePtr<LiteralUndefined>();
+ }
+ else if (Match(TokenType::True))
+ {
+ bool t = true;
+ return IPLMakeSharePtr<LiteralBoolean>(t);
+ }
+ else if (Match(TokenType::False))
+ {
+ bool f = false;
+ return IPLMakeSharePtr<LiteralBoolean>(f);
+ }
+ else if (Match(TokenType::Identifier))
+ {
+ return IPLMakeSharePtr<IdentifierExpression>(Prev().Lexeme);
+ }
+ else if (auto al = ArrayLiteral())
+ {
+ return al;
+ }
+ else if (auto p = ParenthesizedExpression())
+ {
+ return p;
+ }
+ else
+ {
+ // TODO implement
+ return ExpressionPtr();
+ }
+}
+
+ExpressionPtr Parser::LeftSideExpression(NormalType a)
+{
+ ExpressionPtr result;
+ auto ss = Snapshot();
+ if ((result = CallExpression(a)))
+ {
+ return result;
+ }
+ Restore(ss);
+ if ((result = ShortNewExpression()))
+ {
+ return result;
+ }
+ // TODO error
+ return nullptr;
+}
+
+ExpressionPtr Parser::CallExpression(NormalType a)
+{
+ ExpressionPtr result;
+
+ auto ss = Snapshot();
+ if (auto pe = PrimaryExpression(a))
+ {
+ result = IPLMakeSharePtr<Call>(pe);
+ }
+ else
+ {
+ Restore(ss);
+ }
+ if (auto fne = FullNewExpression())
+ {
+ result = IPLMakeSharePtr<::Call>(fne);
+ }
+
+ ExpressionPtr right;
+ do
+ {
+ right = CallExpressionHelper(a);
+ if (right)
+ {
+ result = IPLMakeSharePtr<::Call>(result, right);
+ }
+ } while (right);
+
+ return result;
+}
+
+ExpressionPtr Parser::CallExpressionHelper(NormalType a)
+{
+ if (Match(TokenType::LeftSquareBracket))
+ {
+ auto expr = Expression(NormalType::Normal, AllowType::AllowIn);
+ if (Match(TokenType::RightSquareBracket))
+ {
+ // return meaningfull expr
+ auto next = CallExpressionHelper(a);
+ return nullptr;
+ }
+ // TODO error
+ return nullptr;
+ }
+ if (Match(TokenType::Dot))
+ {
+ if (Match(TokenType::Identifier))
+ {
+ return IPLMakeSharePtr<MemberAccess>(Prev().Lexeme);
+ }
+ // TODO error
+ return nullptr;
+ }
+
+ if (auto args = Arguments())
+ {
+ // return meaningfull expr
+ auto next = CallExpressionHelper(a);
+ return nullptr;
+ }
+
+ return nullptr;
+};
+
+ExpressionPtr Parser::ShortNewExpression()
+{
+ if (Match(TokenType::New))
+ {
+ return ShortNewSubexpression();
+ }
+ return nullptr;
+}
+
+ExpressionPtr Parser::ShortNewSubexpression()
+{
+ ExpressionPtr result;
+ auto ss = Snapshot();
+ if ((result = FullNewSubexpression()))
+ {
+ return result;
+ }
+ Restore(ss);
+ if ((result = ShortNewExpression()))
+ {
+ return result;
+ }
+ // TODO error
+ return nullptr;
+}
+
+ExpressionPtr Parser::FullNewExpression()
+{
+ if (Match(TokenType::New))
+ {
+ auto subExpr = FullNewSubexpression();
+ auto arguments = Arguments();
+ }
+ return nullptr;
+}
+
+ExpressionPtr Parser::FullNewSubexpression()
+{
+ ExpressionPtr result;
+ if ((result = PrimaryExpression(NormalType::Normal)))
+ {
+ return result;
+ }
+ NOT_IMPLEMENTED;
+ return nullptr;
+}
+
+ExpressionPtr Parser::Unary(NormalType a)
+{
+ if (MatchOneOf({
+ TokenType::Delete,
+ TokenType::MinusMinus,
+ TokenType::PlusPlus,
+ }))
+ {
+ auto op = Prev().Type;
+ auto ls = LeftSideExpression(NormalType::Normal);
+ auto suffix = false;
+ return IPLMakeSharePtr<UnaryExpression>(ls, op, suffix);
+ }
+ else if (MatchOneOf({
+ TokenType::Void,
+ TokenType::Typeof,
+ TokenType::Plus,
+ TokenType::Minus,
+ TokenType::BitwiseNot,
+ TokenType::Bang,
+ }))
+ {
+ auto type = Prev().Type;
+ auto ls = Unary(NormalType::Normal);
+ auto suffix = false;
+ return IPLMakeSharePtr<UnaryExpression>(ls, type, suffix);
+ }
+ else
+ {
+ auto leftSide = LeftSideExpression(a);
+ if (MatchOneOf({ TokenType::PlusPlus, TokenType::MinusMinus }))
+ {
+ auto suffix = true;
+ return IPLMakeSharePtr<UnaryExpression>(leftSide, Prev().Type, suffix);
+ }
+ return leftSide;
+ }
+}
+
+ExpressionPtr Parser::MultiplicativeExpression(NormalType a)
+{
+ auto left = Unary(a);
+
+ while(MatchOneOf({ TokenType::Star, TokenType::Division, TokenType::Modulo }))
+ {
+ auto type = Prev().Type;
+ auto right = Unary(a);
+ left = IPLMakeSharePtr<BinaryExpression>(left, right, type);
+ }
+ return left;
+}
+
+ExpressionPtr Parser::AdditiveExpression(NormalType a)
+{
+ auto left = MultiplicativeExpression(a);
+ while (MatchOneOf({ TokenType::Plus, TokenType::Minus}))
+ {
+ auto type = Prev().Type;
+ auto right = MultiplicativeExpression(a);
+ left = IPLMakeSharePtr<BinaryExpression>(left, right, type);
+ }
+ return left;
+}
+
+ExpressionPtr Parser::ShiftExpression(NormalType a)
+{
+ auto left = AdditiveExpression(a);
+ while (MatchOneOf({ TokenType::LeftShift, TokenType::RightShift }))
+ {
+ auto type = Prev().Type;
+ auto right = AdditiveExpression(a);
+ left = IPLMakeSharePtr<BinaryExpression>(left, right, type);
+ }
+ return left;
+}
+
+ExpressionPtr Parser::RelationalExpression(NormalType a, AllowType)
+{
+ auto left = ShiftExpression(a);
+ while (MatchOneOf({ TokenType::Less,
+ TokenType::Greater,
+ TokenType::LessEqual,
+ TokenType::GreaterEqual,
+ TokenType::Instanceof,
+ TokenType::In
+ }))
+ {
+ auto type = Prev().Type;
+ auto right = ShiftExpression(a);
+ left = IPLMakeSharePtr<BinaryExpression>(left, right, type);
+ }
+ return left;
+}
+
+ExpressionPtr Parser::EqualityExpression(NormalType a, AllowType b)
+{
+ auto left = RelationalExpression(a, b);
+ while (MatchOneOf({TokenType::EqualEqual,
+ TokenType::BangEqual,
+ TokenType::StrictEqual,
+ TokenType::StrictNotEqual,
+
+ }))
+ {
+ auto type = Prev().Type;
+ auto right = RelationalExpression(a, b);
+ left = IPLMakeSharePtr<BinaryExpression>(left, right, type);
+ }
+ return left;
+}
+
+ExpressionPtr Parser::BitwiseExpression(NormalType a, AllowType b)
+{
+ auto BitwiseAndExpression = [&](NormalType _a, AllowType _b) -> ExpressionPtr {
+ auto left = EqualityExpression(_a, _b);
+ while (Match(TokenType::BitwiseAnd))
+ {
+ auto type = Prev().Type;
+ auto right = EqualityExpression(_a, _b);
+ left = IPLMakeSharePtr<BinaryExpression>(left, right, type);
+ }
+ return left;
+ };
+
+ auto BitwiseXorExpression = [&](NormalType _a, AllowType _b) -> ExpressionPtr {
+ auto left = BitwiseAndExpression(_a, _b);
+ while (Match(TokenType::BitwiseXor))
+ {
+ auto type = Prev().Type;
+ auto right = BitwiseAndExpression(_a, _b);
+ left = IPLMakeSharePtr<BinaryExpression>(left, right, type);
+ }
+ return left;
+ };
+
+ auto BitwiseOrExpression = [&](NormalType _a, AllowType _b) -> ExpressionPtr {
+ auto left = BitwiseXorExpression(_a, _b);
+ while (Match(TokenType::BitwiseOr))
+ {
+ auto type = Prev().Type;
+ auto right = BitwiseXorExpression(_a, _b);
+ left = IPLMakeSharePtr<BinaryExpression>(left, right, type);
+ }
+ return left;
+ };
+
+ return BitwiseOrExpression(a, b);
+}
+
+
+ExpressionPtr Parser::LogicalExpression(NormalType a, AllowType b)
+{
+ std::function<ExpressionPtr(NormalType a, AllowType b)> LogicalAndExpression;
+ LogicalAndExpression = [&](NormalType a, AllowType b) -> ExpressionPtr {
+ auto left = BitwiseExpression(a, b);
+ while (Match(TokenType::LogicalAnd))
+ {
+ auto type = Prev().Type;
+ auto right = BitwiseExpression(a, b);
+ left = IPLMakeSharePtr<BinaryExpression>(left, right, type);
+ }
+ return left;
+ };
+
+ auto LogicalOrExpression = [&](NormalType a, AllowType b) -> ExpressionPtr {
+ auto left = LogicalAndExpression(a, b);
+ while (Match(TokenType::LogicalAnd))
+ {
+ auto type = Prev().Type;
+ auto right = LogicalAndExpression(a, b);
+ left = IPLMakeSharePtr<BinaryExpression>(left, right, type);
+ }
+ return left;
+ };
+
+ return LogicalOrExpression(a, b);
+}
+
+ExpressionPtr Parser::ConditionalExpression(NormalType a, AllowType b)
+{
+ auto condition = LogicalExpression(a, b);
+ if (Match(TokenType::QuestionMark))
+ {
+ auto trueExpr= AssignmentExpression(NormalType::Normal, b);
+ (void)trueExpr;
+ if (Match(TokenType::Colon))
+ {
+ auto falseExpr = AssignmentExpression(NormalType::Normal, b);
+ (void)falseExpr;
+ // TODO implement trinary operator
+ assert(false);
+ return ExpressionPtr();
+ }
+ // TODO log parsing error
+ assert(false);
+ }
+ return condition;
+}
+
+ExpressionPtr Parser::AssignmentExpression(NormalType a, AllowType b)
+{
+ auto location = GetLocation();
+
+ auto left = ConditionalExpression(a, b);
+ if (!left)
+ {
+ left = LeftSideExpression(a);
+ }
+
+ if (!left)
+ {
+ return nullptr;
+ }
+ if (MatchOneOf({ TokenType::Equal,
+ TokenType::StarEqual,
+ TokenType::DivideEqual,
+ TokenType::ModuloEqual,
+ TokenType::PlusEqual,
+ TokenType::MinusEqual,
+ TokenType::LeftShiftEqual,
+ TokenType::RightShiftEqual,
+ TokenType::BitwiseAndEqual,
+ TokenType::BitwiseXorEqual,
+ TokenType::BitwiseOrEqual }))
+ {
+ auto type = Prev().Type;
+ auto right = AssignmentExpression(NormalType::Normal, b);
+ auto be = IPLMakeSharePtr<BinaryExpression>(left, right, type);
+ if (be)
+ {
+ be->SetLocation(location.Line, location.Column);
+ }
+ return be;
+ }
+
+ return left;
+}
+
+ExpressionPtr Parser::Expression(NormalType a, AllowType b)
+{
+ auto ae = AssignmentExpression(a, b);
+ while (Match(TokenType::Comma))
+ {
+ auto type = Prev().Type;
+
+ auto next = AssignmentExpression(a, b);
+ if (!next)
+ {
+ next = AssignmentExpression(NormalType::Normal, b);
+ }
+
+ if (next)
+ {
+ ae = IPLMakeSharePtr<BinaryExpression>(ae, next, type);
+ }
+ else
+ {
+ // TODO log
+ assert(false);
+ }
+ }
+ return ae;
+}
+
+
+ExpressionPtr Parser::Statement()
+{
+ ExpressionPtr result;
+ if ((result = EmptyStatement())) return result;
+ if ((result = Expression(NormalType::Initial, AllowType::AllowIn))) return result;
+ if ((result = VariableDefinition(AllowType::AllowIn))) return result;
+ if ((result = Block())) return result;
+ if ((result = LabeledStatement())) return result;
+ if ((result = IfStatementfull())) return result;
+ if ((result = SwitchStatement())) return result;
+ if ((result = DoStatement())) return result;
+ if ((result = WhileStatement())) return result;
+ if ((result = ForStatement())) return result;
+ if ((result = WithStatement())) return result;
+ if ((result = ContinueStatement())) return result;
+ if ((result = BreakStatement())) return result;
+ if ((result = OptionalLabel())) return result;
+ if ((result = ReturnStatement())) return result;
+ if ((result = TryStatement())) return result;
+ return result;
+}
+
+ExpressionPtr Parser::EmptyStatement()
+{
+ if (Match(TokenType::Semicolon))
+ {
+ // Not sure what to do here;
+ // This just will consume ;
+ return nullptr;
+ }
+ return nullptr;
+}
+
+ExpressionPtr Parser::VariableDefinition(AllowType b)
+{
+ auto VariableDeclaration = [&]() -> ExpressionPtr {
+ auto location = GetLocation();
+ if (Match(TokenType::Identifier))
+ {
+ auto id = Prev().Lexeme;
+ auto ae = CreateEmptyExpression();
+ if (Match(TokenType::Equal))
+ {
+ ae = AssignmentExpression(NormalType::Normal, b);
+ }
+ auto vd = IPLMakeSharePtr<VariableDefinitionExpression>(id, ae);
+ vd->SetLocation(location.Line, location.Column);
+ return vd;
+ }
+ return nullptr;
+ };
+
+ auto VariableDeclarationList = [&]() -> ExpressionPtr {
+ auto vdList = IPLMakeSharePtr<ListExpression>();
+ vdList->GetValuesByRef().push_back(VariableDeclaration());
+ while (Match(TokenType::Comma))
+ {
+ vdList->GetValuesByRef().push_back(VariableDeclaration());
+ }
+ return vdList;
+ };
+
+ if (Match(TokenType::Var))
+ {
+ return VariableDeclarationList();
+ }
+
+ return nullptr;
+}
+
+ExpressionPtr Parser::Block()
+{
+ auto BlockStatementsPrefix = [&]() -> ExpressionPtr {
+ auto StatementsList = IPLMakeSharePtr<BlockStatement>();
+ while (auto s = Statement())
+ {
+ StatementsList->GetValuesByRef().push_back(s);
+ }
+ return StatementsList;
+ };
+
+ if (Match(TokenType::LeftBrace))
+ {
+ auto statements = BlockStatementsPrefix();
+ if (Match(TokenType::RightBrace))
+ {
+ return statements;
+ }
+ else
+ {
+ // TODO log error - empty block?
+ assert(false);
+ return nullptr;
+ }
+ }
+ return nullptr;
+}
+
+ExpressionPtr Parser::LabeledStatement()
+{
+ auto location = GetLocation();
+ if (Match(TokenType::Identifier))
+ {
+ auto identifier = Prev().Lexeme;
+ auto stament = Statement();
+ auto ls = IPLMakeSharePtr<::LabeledStatement>(identifier, stament);
+ ls->SetLocation(location.Line, location.Column);
+ return ls;
+ }
+ return nullptr;
+}
+
+ExpressionPtr Parser::IfStatementfull()
+{
+ auto location = GetLocation();
+ if (Match(TokenType::If))
+ {
+ auto cond = ParenthesizedExpression();
+ auto ifBody = Statement();
+ ExpressionPtr elseBody = nullptr;
+ if (Match(TokenType::Else))
+ {
+ elseBody = Statement();
+ }
+ auto is = IPLMakeSharePtr<::IfStatement>(cond, ifBody, elseBody);
+ is->SetLocation(location.Line, location.Column);
+ return is;
+ }
+ return nullptr;
+}
+
+ExpressionPtr Parser::SwitchStatement()
+{
+ if (Match(TokenType::Switch))
+ {
+ auto cond = ParenthesizedExpression();
+ IPLVector<ExpressionPtr> cases;
+ ExpressionPtr defaultCase = nullptr;
+ if (Match(TokenType::LeftBrace))
+ {
+
+ while (!Match(TokenType::RightBrace))
+ {
+ if (Match(TokenType::Case))
+ {
+ auto expr = Expression(NormalType::Normal, AllowType::AllowIn);
+ if (Match(TokenType::Colon))
+ {
+ auto statement = Statement();
+ cases.push_back(IPLMakeSharePtr<CaseStatement>(expr, statement));
+ }
+ }
+ else if (Match(TokenType::Default))
+ {
+ if (Match(TokenType::Colon))
+ {
+ defaultCase = Statement();
+ }
+ }
+ }
+ return IPLMakeSharePtr<::SwitchStatement>(cond, cases, defaultCase);
+ }
+ }
+ return nullptr;
+}
+
+ExpressionPtr Parser::DoStatement()
+{
+ if(Match(TokenType::Do))
+ {
+ auto body = Statement();
+ if (Match(TokenType::While))
+ {
+ auto cond = ParenthesizedExpression();
+ auto isDoWhile = true;
+ return IPLMakeSharePtr<::WhileStatement>(cond, body, isDoWhile);
+ }
+ // TODO log error
+ }
+ return nullptr;
+}
+
+ExpressionPtr Parser::WhileStatement()
+{
+ auto location = GetLocation();
+ if (Match(TokenType::While))
+ {
+ auto cond = ParenthesizedExpression();
+ auto body = Statement();
+ auto isDoWhile = false;
+ auto ws = IPLMakeSharePtr<::WhileStatement>(cond, body, isDoWhile);
+ ws->SetLocation(location.Line, location.Column);
+ return ws;
+ }
+ return nullptr;
+}
+
+ExpressionPtr Parser::ForStatement()
+{
+ auto location = GetLocation();
+ if (Match(TokenType::For))
+ {
+ if (!Match(TokenType::LeftParen))
+ {
+ assert(false);
+ }
+ auto initializer = Expression(NormalType::Normal, AllowType::AllowIn);
+ if (!initializer)
+ {
+ initializer = VariableDefinition(AllowType::AllowIn);
+ }
+ if (!Match(TokenType::Semicolon))
+ {
+ assert(false);
+ }
+
+ auto cond = OptionalExpression();
+ if (!Match(TokenType::Semicolon))
+ {
+ assert(false);
+ }
+ auto iteration = OptionalExpression();
+ if (!Match(TokenType::RightParen))
+ {
+ assert(false);
+ }
+ auto body = Statement();
+ auto fs = IPLMakeSharePtr<::ForStatement>(initializer, cond, iteration, body);
+ fs->SetLocation(location.Line, location.Column);
+ return fs;
+ }
+ return nullptr;
+}
+
+ExpressionPtr Parser::WithStatement()
+{
+ return nullptr;
+}
+
+ExpressionPtr Parser::ContinueStatement()
+{
+ if (Match(TokenType::Continue))
+ {
+ ExpressionPtr expr = OptionalLabel();
+ return IPLMakeSharePtr<Continue>();
+ }
+ return nullptr;
+}
+
+ExpressionPtr Parser::BreakStatement()
+{
+ if (Match(TokenType::Break))
+ {
+ ExpressionPtr expr = OptionalLabel();
+ return IPLMakeSharePtr<Break>();
+ }
+ return nullptr;
+}
+
+ExpressionPtr Parser::OptionalLabel()
+{
+ if (Match(TokenType::Identifier))
+ {
+ return IPLMakeSharePtr<IdentifierExpression>(Prev().Lexeme);
+ }
+ return nullptr;
+}
+
+ExpressionPtr Parser::ReturnStatement()
+{
+ if (Match(TokenType::Return))
+ {
+ auto type = TokenType::Return;
+ ExpressionPtr expr = OptionalExpression();
+ bool suffix = true;
+ return IPLMakeSharePtr<UnaryExpression>(expr, type, suffix);
+ }
+ return nullptr;
+}
+
+ExpressionPtr Parser::TryStatement()
+{
+ return nullptr;
+}
+
+ExpressionPtr Parser::OptionalExpression()
+{
+ return Parser::Expression(NormalType::Normal, AllowType::AllowIn);
+}
+
+ExpressionPtr Parser::Arguments()
+{
+ if (Match(TokenType::LeftParen))
+ {
+ auto result = IPLMakeSharePtr<ListExpression>();
+ auto current = AssignmentExpression(NormalType::Normal, AllowType::AllowIn);
+ while (current)
+ {
+ result->GetValuesByRef().push_back(current);
+ if (Match(TokenType::Comma))
+ {
+ current = AssignmentExpression(NormalType::Normal, AllowType::AllowIn);
+ if (current)
+ {
+ // TODO error
+ return nullptr;
+ }
+ }
+ else
+ {
+ current = nullptr;
+ }
+ }
+
+ if (Match(TokenType::RightParen))
+ {
+ return result;
+ }
+ // TODO error
+ return nullptr;
+ }
+ return nullptr;
+}
+
+ExpressionPtr Parser::Parse()
+{
+ auto result = Parser::Program();
+ assert(m_Current + 1 == m_Tokens.size());
+ return result;
+}
+
+ExpressionPtr Parser::FunctionDefinition()
+{
+ auto FormalParameters = [&](IPLVector<IPLString>& identifiers) -> bool {
+ if (Match(TokenType::LeftParen))
+ {
+ while (Match(TokenType::Identifier))
+ {
+ identifiers.push_back(Prev().Lexeme);
+ if (!Match(TokenType::Comma))
+ {
+ break;
+ }
+ }
+
+ if (Match(TokenType::RightParen))
+ {
+ return true;
+ }
+ }
+ return false;
+ };
+
+ auto Body = [&]() -> ExpressionPtr {
+
+ if (Match(TokenType::LeftBrace))
+ {
+ auto ts = TopStatements();
+ if (Match(TokenType::RightBrace))
+ {
+ return ts;
+ }
+ }
+ return nullptr;
+ };
+ auto location = GetLocation();
+ if (Match(TokenType::Function))
+ {
+ if (Match(TokenType::Identifier))
+ {
+ auto name = Prev().Lexeme;
+ IPLVector<IPLString> identifiers;
+ if (FormalParameters(identifiers))
+ {
+ if (auto body = Body())
+ {
+ auto fd = IPLMakeSharePtr<FunctionDeclaration>(name, identifiers, body);
+ fd->SetLocation(location.Line, location.Column);
+ return fd;
+ }
+ else
+ {
+ // TODO log error
+ return nullptr;
+ }
+ }
+ }
+ }
+ return nullptr;
+}
+
+
+ExpressionPtr Parser::Program()
+{
+ return TopStatements();
+}
+
+ExpressionPtr Parser::TopStatements()
+{
+ auto statements = IPLMakeSharePtr<::TopStatements>();
+ while (auto ts = TopStatement())
+ {
+ statements->GetValuesByRef().push_back(ts);
+ }
+ return statements;
+}
+
+ExpressionPtr Parser::TopStatement()
+{
+ auto result = FunctionDefinition();
+ if (!result)
+ {
+ result = Statement();
+ }
+ return result;
+}
+
+ExpressionPtr Parse(const IPLVector<Token>& tokens, const std::function<void()>& onError)
+{
+ Parser p(tokens, onError);
+ return p.Parse();
+}
+
+Parser::InternalState Parser::Snapshot()
+{
+ return { m_Current };
+}
+
+void Parser::Restore(const InternalState& state)
+{
+ m_Current = state.Current;
+}
diff --git a/JSImpl/src/Parser.h b/JSImpl/src/Parser.h
new file mode 100644
index 0000000..33890cb
--- /dev/null
+++ b/JSImpl/src/Parser.h
@@ -0,0 +1,8 @@
+#pragma once
+
+#include "CommonTypes.h"
+#include "Expression.h"
+#include "Lexer.h"
+#include <functional>
+
+ExpressionPtr Parse(const IPLVector<Token>&, const std::function<void()>& onError = {});
diff --git a/JSImpl/src/main.cpp b/JSImpl/src/main.cpp
new file mode 100644
index 0000000..aee465d
--- /dev/null
+++ b/JSImpl/src/main.cpp
@@ -0,0 +1,249 @@
+#include "Lexer.h"
+#include "Parser.h"
+#include "ASTPrinter.h"
+#include "ASTInterpreter.h"
+#include "ByteCodeGenerator.h"
+#include <iostream>
+#include <cstring>
+#include <unordered_map>
+#include <sstream>
+#include <fstream>
+#include <iterator>
+
+#if defined(_WIN32)
+#include <Windows.h>
+#endif
+
+void RunParseCalc()
+{
+ //Tokenize("var a = 0; var b = a + 123;a+b;", tokens);
+ auto tokens = Tokenize("var a = 5; if(a == 5){a++;}").tokens;
+
+ // TODO make actual test :D
+ auto expr = Parse(tokens);
+ PrintAST(expr, std::cout);
+ //ASTInterpreter i;
+ //std::cout << "Running" << std::endl;
+ //auto result = i.Run(expr.get());
+ //std::cout << "Stack after run, top to bottom:" << std::endl;
+ //while (!result.empty()) {
+ // std::cout << result.back() << std::endl;
+ // result.pop_back();
+ //}
+ //std::cout << "S = " << i.ModifyVariable("a") << std::endl;
+}
+
+class InterpreterPrinter : public ASTInterpreter::Printer
+{
+public:
+ virtual void PrintVariable(const char* name, double value) override
+ {
+ std::cout << name << ": number : " << value << std::endl;
+ }
+ virtual void PrintVariable(const char* name, const IPLString& value) override
+ {
+ std::cout << name << ": string : " << value << std::endl;
+ }
+};
+
+void InteractiveInterpreter()
+{
+ char command[1000];
+ ASTInterpreter i;
+ InterpreterPrinter p;
+ do
+ {
+ std::cin.getline(command, 1000);
+ if (std::strcmp(command, "exit") == 0)
+ {
+ break;
+ }
+ if (std::strcmp(command, "print") == 0)
+ {
+ i.Print(p);
+ continue;
+ }
+ auto tokens = Tokenize(command).tokens;
+ auto result = i.Run(Parse(tokens).get());
+ while (!result.empty()) {
+ std::cout << result.back() << std::endl;
+ result.pop_back();
+ }
+ } while (true);
+}
+
+void Generate()
+{
+ //Tokenize("var a = 0; var b = a + 123;a+b;", tokens);
+ /*Tokenize("var a; if(a < 4) { a = 8; if(a < 7) {var b = 4;}} else { a = 2} ", tokens);*/
+ //IPLString source = "var i = 0; \n"
+ // "for (var j = 0; j < 10; j++)\n"
+ // "{\n"
+ // " i = i + j;\n"
+ // "}";
+ IPLString source = "var a = 5; do{ a--; if(a == 4) continue; }while(a != 0)\n";
+ auto tokens = Tokenize(source.c_str()).tokens;
+
+ auto asmb = GenerateByteCode(Parse(tokens), source,
+ ByteCodeGeneratorOptions(ByteCodeGeneratorOptions::OptimizationsType::None, false));
+
+ //sets the color to intense red on blue background
+#if defined(_WIN32)
+ HANDLE hStdout = GetStdHandle(STD_OUTPUT_HANDLE);
+ std::istringstream asmbStream(asmb);
+ while (asmbStream.good())
+ {
+ IPLString it;
+ std::getline(asmbStream, it);
+ if (it[0] == 'D')
+ {
+ SetConsoleTextAttribute(hStdout, FOREGROUND_GREEN| BACKGROUND_BLUE | FOREGROUND_INTENSITY);
+ auto dd = it.find("@@=>");
+ std::cout << it.substr(0, dd);
+ SetConsoleTextAttribute(hStdout, FOREGROUND_RED | BACKGROUND_BLUE | FOREGROUND_INTENSITY);
+ std::cout << it.substr(dd, 4);
+ SetConsoleTextAttribute(hStdout, FOREGROUND_GREEN | BACKGROUND_BLUE | FOREGROUND_INTENSITY);
+ std::cout << it.substr(dd + 4, it.size()) << std::endl;
+ }
+ else
+ {
+ std::cout << it << std::endl;
+ }
+ SetConsoleTextAttribute(hStdout, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
+ }
+#else
+ std::cout << asmb;
+#endif
+}
+
+
+class CammandLineApp
+{
+public:
+ CammandLineApp()
+ : m_PrintAst(false)
+ , m_PrintTokens(false)
+ {
+ m_CommandMapping["--output"] = CommandType::Output;
+ m_CommandMapping["--input"] = CommandType::Input;
+ m_CommandMapping["--ast"] = CommandType::PrintAST;
+ m_CommandMapping["--tokens"] = CommandType::PrintTokens;
+ m_CommandMapping["--help"] = CommandType::Help;
+ }
+
+ enum class CommandType
+ {
+ Output,
+ Input,
+ PrintAST,
+ PrintTokens,
+ Help
+ };
+
+ void PrintHelp()
+ {
+ std::cout << "Supports following arguments:" << std::endl
+ << "--output - output file path" << std::endl
+ << "--input - input file path" << std::endl
+ << "--ast - will write ast of the input in the output" << std::endl
+ << "--tokens - will tokenize input file and will write the result as json in the output" << std::endl
+ << "--help - this message" << std::endl;
+ }
+
+ void ParseArguments(int argcount, char* arguments[])
+ {
+ for (int i = 1; i < argcount; )
+ {
+ auto it = m_CommandMapping.find(arguments[i]);
+ if (it == m_CommandMapping.end())
+ {
+ PrintHelp();
+ }
+ auto command = it->second;
+ ++i;
+ switch (command)
+ {
+ case CommandType::Output:
+ assert(i < argcount);
+ m_Output = arguments[i];
+ ++i;
+ break;
+ case CommandType::Input:
+ assert(i < argcount);
+ m_Input = arguments[i];
+ ++i;
+ break;
+ case CommandType::PrintAST:
+ m_PrintAst = true;
+ break;
+ case CommandType::PrintTokens:
+ m_PrintTokens = true;
+ break;
+ case CommandType::Help:
+ default:
+ PrintHelp();
+ return;
+ }
+ }
+ }
+
+ void ExecuteCommands()
+ {
+ std::ifstream input(m_Input.c_str());
+ input.seekg(0, std::ios::end);
+ std::string code;
+ int size = (int)input.tellg();
+ code.resize(size);
+ input.seekg(0, std::ios::beg);
+ input.read(&code[0], code.size());
+ input.close();
+
+ auto tokenizationResult = Tokenize(code.c_str());
+ if (!tokenizationResult.IsSuccessful)
+ {
+ return;
+ }
+ auto programAst = Parse(tokenizationResult.tokens);
+ if (m_PrintAst)
+ {
+ std::ofstream output(m_Output, std::ofstream::trunc);
+ PrintAST(programAst, output);
+ output.close();
+ }
+
+ if (m_PrintTokens)
+ {
+
+ }
+ }
+
+ void RunAsCommandLine(int argcount, char* arguments[])
+ {
+ ParseArguments(argcount, arguments);
+ ExecuteCommands();
+ }
+private:
+ std::string m_Output;
+ std::string m_Input;
+ bool m_PrintAst;
+ bool m_PrintTokens;
+ std::unordered_map<std::string, CommandType> m_CommandMapping;
+};
+
+int main(int argc, char* argv[])
+{
+ (void)argv;
+ (void)argc;
+ // You can try =>
+ // Working dir: $(ProjectDir)
+ // Command arguments: --input ./../examples/code.js --output ./../examples/some.ast --ast
+ //CammandLineApp cmd;
+ //cmd.RunAsCommandLine(argc, argv);
+ //auto r = Tokenize("a#4", {true ,true});
+ //RunParseCalc();
+ Generate();
+#if defined(_WIN32)
+ //std::system("pause");
+#endif
+ return 0;
+}