diff options
19 files changed, 4685 insertions, 0 deletions
| -rw-r--r-- | JSImpl/src/ASTInterpreter.cpp | 586 | ||||
| -rw-r--r-- | JSImpl/src/ASTInterpreter.h | 68 | ||||
| -rw-r--r-- | JSImpl/src/ASTPrinter.cpp | 344 | ||||
| -rw-r--r-- | JSImpl/src/ASTPrinter.h | 5 | ||||
| -rw-r--r-- | JSImpl/src/ByteCodeGenerator.cpp | 840 | ||||
| -rw-r--r-- | JSImpl/src/ByteCodeGenerator.h | 16 | ||||
| -rw-r--r-- | JSImpl/src/CommonTypes.h | 41 | ||||
| -rw-r--r-- | JSImpl/src/Expression.cpp | 4 | ||||
| -rw-r--r-- | JSImpl/src/Expression.h | 57 | ||||
| -rw-r--r-- | JSImpl/src/ExpressionDefinitions.h | 116 | ||||
| -rw-r--r-- | JSImpl/src/ExpressionVisitor.h | 39 | ||||
| -rw-r--r-- | JSImpl/src/ExpressionsFwd.h | 33 | ||||
| -rw-r--r-- | JSImpl/src/JSONParser.cpp | 369 | ||||
| -rw-r--r-- | JSImpl/src/JSONParser.h | 5 | ||||
| -rw-r--r-- | JSImpl/src/Lexer.cpp | 573 | ||||
| -rw-r--r-- | JSImpl/src/Lexer.h | 134 | ||||
| -rw-r--r-- | JSImpl/src/Parser.cpp | 1198 | ||||
| -rw-r--r-- | JSImpl/src/Parser.h | 8 | ||||
| -rw-r--r-- | JSImpl/src/main.cpp | 249 |
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; +} |
