From 093ffde6bcee990bdbf5f0621647272824711ac4 Mon Sep 17 00:00:00 2001 From: Deukhoofd Date: Fri, 8 Jan 2021 16:14:02 +0100 Subject: [PATCH] Initial work on type registration in the binder. --- CMakeLists.txt | 2 +- repl/InputWindow.hpp | 20 +- repl/main.cpp | 10 +- src/Binder/Binder.cpp | 203 ++++++++++++ src/Binder/Binder.hpp | 36 +++ src/Binder/BoundNamespace.hpp | 50 +++ src/Binder/BoundType.hpp | 43 +++ src/Binder/BoundVariable.hpp | 21 ++ src/CoreData/Identifier.hpp | 38 ++- src/CoreData/PrimitiveTypes.hpp | 57 +++- src/Diagnostics/Diagnostic.hpp | 8 +- src/Diagnostics/DiagnosticType.hpp | 2 + src/Diagnostics/DiagnosticTypeEN_US.hpp | 2 + src/Diagnostics/Logger.hpp | 12 +- src/Parser/Lexer/Lexer.cpp | 290 +++++++++--------- src/Parser/Lexer/Lexer.hpp | 20 +- src/Parser/Lexer/NumericalLexers.cpp | 92 +++--- src/Parser/Lexer/NumericalLexers.hpp | 8 +- src/Parser/Parser.cpp | 13 +- src/Parser/Parser.hpp | 5 +- src/Parser/ParserDefines.hpp | 2 +- src/Parser/Statements/ParsedStatement.hpp | 16 +- src/Parser/Statements/ParsedStatementKind.hpp | 2 + .../Statements/ParsedStatementStringifier.hpp | 1 + src/ScriptEngine.cpp | 1 + src/ScriptEngine.hpp | 11 + src/Utils/TreePrinter.hpp | 13 + tests/LexerTests/IdentifierLexTests.cpp | 12 +- tests/LexerTests/LexerIntegrationTests.cpp | 2 +- tests/LexerTests/NumericalLexTests.cpp | 4 +- tests/LexerTests/StringLexTests.cpp | 8 +- tests/LexerTests/SymbolLexTests.cpp | 6 +- tests/ParserTests/ClassTests.cpp | 8 +- tests/ParserTests/FunctionTests.cpp | 80 ++--- tests/ParserTests/ParserIntegrationTests.cpp | 6 +- tests/ParserTests/VirtPropTests.cpp | 101 +++--- 36 files changed, 819 insertions(+), 386 deletions(-) create mode 100644 src/Binder/Binder.cpp create mode 100644 src/Binder/Binder.hpp create mode 100644 src/Binder/BoundNamespace.hpp create mode 100644 src/Binder/BoundType.hpp create mode 100644 src/Binder/BoundVariable.hpp create mode 100644 src/ScriptEngine.cpp create mode 100644 src/ScriptEngine.hpp create mode 100644 src/Utils/TreePrinter.hpp diff --git a/CMakeLists.txt b/CMakeLists.txt index d894179..b4c3253 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -19,7 +19,7 @@ if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang") add_link_options(-fuse-ld=lld) endif () -file(GLOB_RECURSE SRC_FILES "src/*.cpp" "src/*.hpp") +file(GLOB_RECURSE SRC_FILES "src/*.cpp") add_library(MalachScript SHARED ${SRC_FILES}) set(LINKS) diff --git a/repl/InputWindow.hpp b/repl/InputWindow.hpp index f4a90c6..e99c590 100644 --- a/repl/InputWindow.hpp +++ b/repl/InputWindow.hpp @@ -9,14 +9,14 @@ namespace MalachScriptRepl { private: WINDOW* _window; - std::vector _lines = {u8""}; + std::vector _lines = {""}; int _row = 0; int _col = 0; int _rightPos = 0; int _scroll = 0; int _lineCount; - std::function&)> _onChange; + std::function&)> _onChange; const MalachScript::Diagnostics::Diagnostic* _diag; public: @@ -26,7 +26,7 @@ namespace MalachScriptRepl { _lineCount = height; } - inline void RegisterOnChange(std::function&)> listener) { + inline void RegisterOnChange(std::function&)> listener) { _onChange = listener; } @@ -99,7 +99,7 @@ namespace MalachScriptRepl { } inline void Return() { - _lines.insert(_lines.begin() + _row + _scroll + 1, u8""); + _lines.insert(_lines.begin() + _row + _scroll + 1, ""); if (_row >= _lineCount - 1) { ScrollDown(); } else { @@ -119,10 +119,10 @@ namespace MalachScriptRepl { wclrtoeol(_window); auto& line = _lines[_row + _scroll]; if ((int)line.length() <= _col) { - line += u8" "; + line += " "; } else { for (size_t i = 0; i < 4; i++) { - line.insert(line.begin() + _col, u8' '); + line.insert(line.begin() + _col, ' '); } } waddstr(_window, (char*)line.c_str()); @@ -148,7 +148,7 @@ namespace MalachScriptRepl { wmove(_window, _row, 0); auto& line = _lines[_row + _scroll]; if ((int)line.length() <= _col) { - line += (char8_t)c; + line += (char)c; } else { line.insert(line.begin() + _col, c); } @@ -160,7 +160,7 @@ namespace MalachScriptRepl { } inline void ResetText() { - std::u8string script; + std::string script; for (size_t i = 0; i < _lines.size(); i++) { script += _lines[i]; if (i != _lines.size() - 1) { @@ -196,11 +196,11 @@ namespace MalachScriptRepl { wmove(_window, _row, _col); } - inline void SetScriptWithDiagnostics(std::u8string& script, const MalachScript::Diagnostics::Diagnostic* diag) { + inline void SetScriptWithDiagnostics(std::string& script, const MalachScript::Diagnostics::Diagnostic* diag) { _diag = diag; auto yx = GetCursorPosition(); Clear(); - script += u8" "; + script += " "; size_t linenum = 0; size_t index = 0; diff --git a/repl/main.cpp b/repl/main.cpp index e97b86e..7c40d60 100644 --- a/repl/main.cpp +++ b/repl/main.cpp @@ -7,9 +7,9 @@ #include "../src/Parser/Statements/ParsedStatementStringifier.hpp" #include "InputWindow.hpp" -void ParseAndUpdate(const std::vector& lines, WINDOW* diagnosticsWindow, WINDOW* parsedWindow, +void ParseAndUpdate(const std::vector& lines, WINDOW* diagnosticsWindow, WINDOW* parsedWindow, MalachScriptRepl::InputWindow& inputWindow) { - std::u8string script; + std::string script; for (size_t i = 0; i < lines.size(); i++) { script += lines[i]; if (i != lines.size() - 1) { @@ -23,9 +23,9 @@ void ParseAndUpdate(const std::vector& lines, WINDOW* diagnostics outfile.close(); auto logger = MalachScript::Diagnostics::Logger(); - auto lexer = MalachScript::Parser::Lexer(u8"diag", script, &logger); + auto lexer = MalachScript::Parser::Lexer("diag", script, &logger); const auto* firstToken = lexer.Lex(); - const auto* parsedResult = MalachScript::Parser::Parser::Parse(firstToken, u8"diag", &logger); + const auto* parsedResult = MalachScript::Parser::Parser::Parse(firstToken, "diag", &logger); const MalachScript::Diagnostics::Diagnostic* diag = nullptr; wclear(diagnosticsWindow); @@ -96,7 +96,7 @@ int main([[maybe_unused]] int argc, [[maybe_unused]] const char* argv[]) { auto inputWindow = MalachScriptRepl::InputWindow(inputFieldSize, maxX - 3, 1, 2); inputWindow.RegisterOnChange( - [diagnosticsWindow, parsedResultWindow, &inputWindow](const std::vector& lines) { + [diagnosticsWindow, parsedResultWindow, &inputWindow](const std::vector& lines) { ParseAndUpdate(lines, diagnosticsWindow, parsedResultWindow, inputWindow); }); diff --git a/src/Binder/Binder.cpp b/src/Binder/Binder.cpp new file mode 100644 index 0000000..d75c30f --- /dev/null +++ b/src/Binder/Binder.cpp @@ -0,0 +1,203 @@ +#include "Binder.hpp" +#include "../CoreData/PrimitiveTypes.hpp" +#include "../Diagnostics/Logger.hpp" +using namespace MalachScript::Parser; +using namespace MalachScript::Diagnostics; + +namespace MalachScript::Binder { + void Binder::Bind(BoundNamespace* ns, const std::vector& statements, + const Binder::log_func& log) { + for (const auto* s : statements) { + TypeRegistrationFirstPass(ns, s, {}, log); + } + for (const auto* s : statements) { + TypeRegistrationSecondPass(ns, s, {}, log); + } + for (const auto* s : statements) { + TypeRegistrationThirdPass(ns, s, {}, log); + } + FinaliseTypes(ns, log); + } + + inline static std::optional ResolveType(BoundNamespace* ns, const Identifier& identifier) { + switch (identifier) { + case "int"_id: return MalachScript::PrimitiveTypes::IntType(); + case "int8"_id: return MalachScript::PrimitiveTypes::Int8Type(); + case "int16"_id: return MalachScript::PrimitiveTypes::Int16Type(); + case "int32"_id: return MalachScript::PrimitiveTypes::Int32Type(); + case "int64"_id: return MalachScript::PrimitiveTypes::Int64Type(); + + case "uint"_id: return MalachScript::PrimitiveTypes::UintType(); + case "uint8"_id: return MalachScript::PrimitiveTypes::Uint8Type(); + case "uint16"_id: return MalachScript::PrimitiveTypes::Uint16Type(); + case "uint32"_id: return MalachScript::PrimitiveTypes::Uint32Type(); + case "uint64"_id: return MalachScript::PrimitiveTypes::Uint64Type(); + + case "float"_id: return MalachScript::PrimitiveTypes::FloatType(); + case "double"_id: return MalachScript::PrimitiveTypes::DoubleType(); + + case "bool"_id: return MalachScript::PrimitiveTypes::BoolType(); + } + return ns->ResolveType(identifier); + } + + void Binder::TypeRegistrationFirstPass(BoundNamespace* ns, const ParsedStatement* statement, + std::optional activeType, const log_func& log) { + switch (statement->GetKind()) { + case Parser::ParsedStatementKind::Script: { + const auto* s = static_cast(statement); + for (const auto& child : s->GetStatements()) { + TypeRegistrationFirstPass(ns, child.get(), activeType, log); + } + break; + } + case Parser::ParsedStatementKind::Class: { + const auto* s = static_cast(statement); + auto identifier = s->GetIdentifier(); + if (activeType.has_value()) { + } + auto* type = new BoundType(s->GetClassAttr()); + if (activeType.has_value()) { + activeType.value()->RegisterType(identifier, type); + } else { + ns->RegisterType(identifier, type); + } + for (const auto& child : s->GetBody()) { + TypeRegistrationFirstPass(ns, child.get(), type, log); + } + break; + } + case Parser::ParsedStatementKind::Namespace: { + const auto* s = static_cast(statement); + auto identifier = s->GetIdentifier(); + auto* innerNamespace = new BoundNamespace(); + ns->RegisterNamespace(identifier, innerNamespace); + TypeRegistrationFirstPass(innerNamespace, s->GetScript().get(), activeType, log); + break; + } + default: break; + } + } + void Binder::TypeRegistrationSecondPass(BoundNamespace* ns, const ParsedStatement* statement, + std::optional activeType, const log_func& log) { + switch (statement->GetKind()) { + case ParsedStatementKind::Script: { + const auto* s = static_cast(statement); + for (const auto& child : s->GetStatements()) { + TypeRegistrationSecondPass(ns, child.get(), activeType, log); + } + break; + }; + case ParsedStatementKind::Class: { + const auto* s = static_cast(statement); + auto type = ns->ResolveType(s->GetIdentifier()); + if (!type.has_value()) { + throw std::logic_error("Shouldn't be reached"); + } + for (const auto& inherits : s->GetInherits()) { + auto inheritType = ResolveType(ns, inherits); + if (!inheritType.has_value()) { + log(DiagnosticLevel::Error, DiagnosticType::UnknownType, s->GetSpan(), + {inherits.GetStdString()}); + } else { + type.value()->AddInheritType(inheritType.value()); + } + } + + for (const auto& child : s->GetBody()) { + TypeRegistrationSecondPass(ns, child.get(), type.value(), log); + } + break; + } + case ParsedStatementKind::TypeDef: { + const auto* s = static_cast(statement); + auto defineTo = s->GetDefineTo(); + auto defineFrom = s->GetDefineFrom(); + auto defineFromType = ResolveType(ns, defineFrom); + if (!defineFromType.has_value()) { + log(DiagnosticLevel::Error, DiagnosticType::UnknownType, s->GetSpan(), {defineFrom.GetStdString()}); + } else { + if (activeType.has_value()) { + activeType.value()->RegisterType(defineTo, defineFromType.value()); + } else { + ns->RegisterType(defineTo, defineFromType.value()); + } + } + break; + } + case ParsedStatementKind::Namespace: { + const auto* s = static_cast(statement); + auto identifier = s->GetIdentifier(); + auto innerNamespace = ns->ResolveNamespace(identifier); + if (!innerNamespace.has_value()) { + throw std::logic_error("Shouldn't be reached"); + } + TypeRegistrationSecondPass(innerNamespace.value(), s->GetScript().get(), activeType, log); + break; + }; + default: break; + } + } + void Binder::TypeRegistrationThirdPass(BoundNamespace* ns, const MalachScript::Parser::ParsedStatement* statement, + std::optional activeType, const Binder::log_func& log) { + switch (statement->GetKind()) { + case ParsedStatementKind::Script: { + const auto* s = static_cast(statement); + for (const auto& child : s->GetStatements()) { + TypeRegistrationThirdPass(ns, child.get(), activeType, log); + } + break; + }; + case ParsedStatementKind::Class: { + const auto* s = static_cast(statement); + auto type = ns->ResolveType(s->GetIdentifier()); + if (!type.has_value()) { + throw std::logic_error("Shouldn't be reached"); + } + for (const auto& child : s->GetBody()) { + TypeRegistrationThirdPass(ns, child.get(), type.value(), log); + } + break; + } + case ParsedStatementKind::Namespace: { + const auto* s = static_cast(statement); + auto identifier = s->GetIdentifier(); + auto innerNamespace = ns->ResolveNamespace(identifier); + if (!innerNamespace.has_value()) { + throw std::logic_error("Shouldn't be reached"); + } + TypeRegistrationThirdPass(innerNamespace.value(), s->GetScript().get(), activeType, log); + break; + }; + case ParsedStatementKind::Var: { + const auto* var = static_cast(statement); + const auto& typeStatement = var->GetTypeStatement(); + // FIXME: Resolve namespace of scoped identifier + auto type = ResolveType(ns, typeStatement->GetScopedIdentifier().GetIdentifier()); + if (!type.has_value()) { + throw std::logic_error("Shouldn't be reached"); + } + if (activeType.has_value()) { + activeType.value()->AddField(var->GetIdentifier(), + new BoundVariable(type.value(), var->GetAccess())); + } else { + ns->AddVariable(var->GetIdentifier(), new BoundVariable(type.value(), var->GetAccess())); + } + + break; + } + default: break; + } + } + + static void FinaliseNamespace(BoundNamespace* ns, const Binder::log_func& log) { + for (const auto& t : ns->GetTypes()) { + t.second->Finalise(); + } + for (const auto& n : ns->GetNamespaces()) { + FinaliseNamespace(n.second, log); + } + } + + void Binder::FinaliseTypes(BoundNamespace* ns, const Binder::log_func& log) { FinaliseNamespace(ns, log); } +} \ No newline at end of file diff --git a/src/Binder/Binder.hpp b/src/Binder/Binder.hpp new file mode 100644 index 0000000..31232b8 --- /dev/null +++ b/src/Binder/Binder.hpp @@ -0,0 +1,36 @@ +#ifndef MALACHSCRIPT_BINDER_HPP +#define MALACHSCRIPT_BINDER_HPP + +#include +#include "../Diagnostics/Logger.hpp" +#include "../Parser/Statements/ParsedStatement.hpp" +#include "BoundNamespace.hpp" + +namespace MalachScript::Binder { + class Binder { + public: + using log_func = const std::function&)>; + + static void Bind(BoundNamespace* ns, + const std::vector& statements, + const log_func& log); + + private: + // Register all types and namespaces + static void TypeRegistrationFirstPass(BoundNamespace* ns, + const MalachScript::Parser::ParsedStatement* statement, + std::optional activeType, const log_func& log); + // Register typedefs and type inheritance + static void TypeRegistrationSecondPass(BoundNamespace* ns, + const MalachScript::Parser::ParsedStatement* statement, + std::optional activeType, const log_func& log); + // Register variables, fields, etc + static void TypeRegistrationThirdPass(BoundNamespace* ns, + const MalachScript::Parser::ParsedStatement* statement, + std::optional activeType, const log_func& log); + // Finalise types, calculating size. + static void FinaliseTypes(BoundNamespace* ns, const log_func& log); + }; +} +#endif // MALACHSCRIPT_BINDER_HPP diff --git a/src/Binder/BoundNamespace.hpp b/src/Binder/BoundNamespace.hpp new file mode 100644 index 0000000..3330c2a --- /dev/null +++ b/src/Binder/BoundNamespace.hpp @@ -0,0 +1,50 @@ +#ifndef MALACHSCRIPT_BOUNDNAMESPACE_HPP +#define MALACHSCRIPT_BOUNDNAMESPACE_HPP + +#include +#include +#include "../CoreData/Identifier.hpp" +#include "BoundType.hpp" +#include "BoundVariable.hpp" + +namespace MalachScript::Binder { + class BoundNamespace { + public: + inline void RegisterNamespace(const Identifier& identifier, BoundNamespace* ns) { + _namespaces[identifier] = ns; + } + + inline void RegisterType(const Identifier& identifier, BoundType* type) { _types[identifier] = type; } + inline void RegisterType(const Identifier& identifier, const BoundType* type) { + _types[identifier] = const_cast(type); + } + inline void AddVariable(const Identifier& identifier, BoundVariable* var) { _variables[identifier] = var; } + + inline std::optional ResolveType(const Identifier& identifier) const noexcept { + auto find = _types.find(identifier); + if (find == _types.end()) { + return {}; + } + return find->second; + } + inline std::optional ResolveNamespace(const Identifier& identifier) const noexcept { + auto find = _namespaces.find(identifier); + if (find == _namespaces.end()) { + return {}; + } + return find->second; + } + + inline const std::unordered_map& GetNamespaces() const noexcept { + return _namespaces; + } + inline const std::unordered_map& GetTypes() const noexcept { return _types; } + + private: + std::unordered_map _namespaces; + std::unordered_map _types; + std::unordered_map _variables; + }; +} + +#endif // MALACHSCRIPT_BOUNDNAMESPACE_HPP diff --git a/src/Binder/BoundType.hpp b/src/Binder/BoundType.hpp new file mode 100644 index 0000000..e4a7de1 --- /dev/null +++ b/src/Binder/BoundType.hpp @@ -0,0 +1,43 @@ +#ifndef MALACHSCRIPT_BOUNDTYPE_HPP +#define MALACHSCRIPT_BOUNDTYPE_HPP + +#include +#include "BoundVariable.hpp" + +namespace MalachScript::Binder { + class BoundType { + public: + BoundType(ClassAttr classAttr) : _classAttr(classAttr) {} + BoundType(ClassAttr classAttr, size_t size) : _classAttr(classAttr), _size(size), _inherits(0) {} + + inline void Finalise() noexcept { + _initialised = true; + // TODO: Calculate size + } + [[nodiscard]] inline size_t GetSize() const noexcept { return _size; } + [[nodiscard]] inline ClassAttr GetAttributes() const noexcept { return _classAttr; } + + inline void AddInheritType(const BoundType* type) { _inherits.push_back(type); } + inline void AddField(const Identifier& identifier, BoundVariable* var) { + _fields.push_back(var); + _fieldsLookup[identifier] = var; + } + + inline void RegisterType(const Identifier& identifier, const BoundType* type) { + _types[identifier] = const_cast(type); + } + + private: + bool _initialised = false; + ClassAttr _classAttr; + size_t _size = 0; + std::vector _inherits; + std::vector _fields; + std::unordered_map _fieldsLookup; + // TODO: functions + + std::unordered_map _types; + }; +} + +#endif // MALACHSCRIPT_BOUNDTYPE_HPP diff --git a/src/Binder/BoundVariable.hpp b/src/Binder/BoundVariable.hpp new file mode 100644 index 0000000..127bede --- /dev/null +++ b/src/Binder/BoundVariable.hpp @@ -0,0 +1,21 @@ +#ifndef MALACHSCRIPT_BOUNDVARIABLE_HPP +#define MALACHSCRIPT_BOUNDVARIABLE_HPP + +namespace MalachScript::Binder { + class BoundType; + + class BoundVariable { + public: + BoundVariable(const BoundType* type, AccessModifier accessModifier) + : _type(type), _accessModifier(accessModifier) {} + + [[nodiscard]] inline const BoundType* GetType() const noexcept { return _type; } + [[nodiscard]] inline AccessModifier GetAccess() const noexcept { return _accessModifier; } + + private: + const BoundType* _type; + AccessModifier _accessModifier; + }; +} + +#endif // MALACHSCRIPT_BOUNDVARIABLE_HPP diff --git a/src/CoreData/Identifier.hpp b/src/CoreData/Identifier.hpp index 4ddc17a..6e1bf21 100644 --- a/src/CoreData/Identifier.hpp +++ b/src/CoreData/Identifier.hpp @@ -2,7 +2,10 @@ #define MALACHSCRIPT_IDENTIFIER_HPP #include +#include #include +#include + namespace MalachScript { constexpr static uint32_t crc_table[256] = { @@ -35,28 +38,30 @@ namespace MalachScript { 0x40DF0B66, 0x37D83BF0, 0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9, 0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6, 0xBAD03605, 0xCDD70693, 0x54DE5729, 0x23D967BF, 0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94, 0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D}; - static int constexpr CalcLength(const char8_t* str) { return *str ? 1 + CalcLength(str + 1) : 0; } + static int constexpr CalcLength(const char* str) { return *str ? 1 + CalcLength(str + 1) : 0; } - static std::u8string empty; + static std::string empty; class Identifier { - const char8_t* _str; + const char* _str; size_t _length; uint32_t _hash; public: Identifier() : _str(nullptr), _length(0), _hash(0) {} - constexpr Identifier(const char8_t* c) : _str(c), _length(CalcLength(c)), _hash(Hash(c)) {} - constexpr Identifier(const char8_t* c, size_t length, uint32_t hash) : _str(c), _length(length), _hash(hash) {} + constexpr Identifier(const char* c) : _str(c), _length(CalcLength(c)), _hash(Hash(c)) {} + constexpr Identifier(const char* c, size_t length) : _str(c), _length(length), _hash(Hash(c)) {} + constexpr Identifier(const char* c, size_t length, uint32_t hash) : _str(c), _length(length), _hash(hash) {} [[nodiscard]] constexpr inline uint32_t GetHash() const noexcept { return _hash; } - [[nodiscard]] constexpr inline std::u8string_view GetString() const noexcept { - return std::u8string_view(_str, _length); + [[nodiscard]] constexpr inline std::string_view GetString() const noexcept { + return std::string_view(_str, _length); } + [[nodiscard]] inline std::string GetStdString() const noexcept { return std::string((char*)_str, _length); } [[nodiscard]] constexpr inline size_t GetLength() const noexcept { return _length; } - constexpr inline static uint32_t Hash(const std::u8string_view& sv) { + constexpr inline static uint32_t Hash(const std::string_view& sv) { uint32_t crc = 0xffffffff; for (auto c : sv) { crc = (crc >> 8) ^ crc_table[(crc ^ c) & 0xff]; @@ -64,6 +69,9 @@ namespace MalachScript { return crc ^ 0xffffffff; } + [[nodiscard]] inline constexpr std::size_t operator()() const noexcept { return _hash; } + [[nodiscard]] inline constexpr operator uint32_t() const noexcept { return _hash; } + friend std::ostream& operator<<(std::ostream& out, const Identifier& c) { out << std::string((const char*)c._str, c._length); return out; @@ -86,4 +94,18 @@ namespace MalachScript { }; } +namespace std { + /// @brief Helper class for getting the hash of a string view literal. + template <> struct hash { + /// @brief Returns the hash of a stringview. + /// @param s a StringView. + /// @return The hash of the StringView. + constexpr std::size_t operator()(MalachScript::Identifier const& s) const noexcept { return s.GetHash(); } + }; +} + +inline constexpr MalachScript::Identifier operator"" _id(const char* c, size_t l) { + return MalachScript::Identifier(c, l); +} + #endif // MALACHSCRIPT_IDENTIFIER_HPP diff --git a/src/CoreData/PrimitiveTypes.hpp b/src/CoreData/PrimitiveTypes.hpp index ae34a75..ccf600b 100644 --- a/src/CoreData/PrimitiveTypes.hpp +++ b/src/CoreData/PrimitiveTypes.hpp @@ -2,6 +2,7 @@ #define MALACHSCRIPT_PRIMITIVETYPES_HPP #include +#include "../Binder/BoundType.hpp" #include "Identifier.hpp" #if !__cpp_constinit @@ -9,22 +10,34 @@ #endif namespace MalachScript { - static constinit Identifier _voidName = u8"void"; - static constinit Identifier _intName = u8"int"; - static constinit Identifier _int8Name = u8"int8"; - static constinit Identifier _int16Name = u8"int16"; - static constinit Identifier _int32Name = u8"int32"; - static constinit Identifier _int64Name = u8"int64"; - static constinit Identifier _uintName = u8"uint"; - static constinit Identifier _uint8Name = u8"uint8"; - static constinit Identifier _uint16Name = u8"uint16"; - static constinit Identifier _uint32Name = u8"uint32"; - static constinit Identifier _uint64Name = u8"uint64"; - static constinit Identifier _floatName = u8"float"; - static constinit Identifier _doubleName = u8"double"; - static constinit Identifier _boolName = u8"bool"; + static constinit Identifier _voidName = "void"; + static constinit Identifier _intName = "int"; + static constinit Identifier _int8Name = "int8"; + static constinit Identifier _int16Name = "int16"; + static constinit Identifier _int32Name = "int32"; + static constinit Identifier _int64Name = "int64"; + static constinit Identifier _uintName = "uint"; + static constinit Identifier _uint8Name = "uint8"; + static constinit Identifier _uint16Name = "uint16"; + static constinit Identifier _uint32Name = "uint32"; + static constinit Identifier _uint64Name = "uint64"; + static constinit Identifier _floatName = "float"; + static constinit Identifier _doubleName = "double"; + static constinit Identifier _boolName = "bool"; - static constinit Identifier _autoName = u8"auto"; + static constinit Identifier _autoName = "auto"; + + static Binder::BoundType _int8Type = Binder::BoundType(ClassAttr::None, sizeof(int8_t)); + static Binder::BoundType _int16Type = Binder::BoundType(ClassAttr::None, sizeof(int16_t)); + static Binder::BoundType _int32Type = Binder::BoundType(ClassAttr::None, sizeof(int32_t)); + static Binder::BoundType _int64Type = Binder::BoundType(ClassAttr::None, sizeof(int64_t)); + static Binder::BoundType _uint8Type = Binder::BoundType(ClassAttr::None, sizeof(uint8_t)); + static Binder::BoundType _uint16Type = Binder::BoundType(ClassAttr::None, sizeof(uint16_t)); + static Binder::BoundType _uint32Type = Binder::BoundType(ClassAttr::None, sizeof(uint32_t)); + static Binder::BoundType _uint64Type = Binder::BoundType(ClassAttr::None, sizeof(uint64_t)); + static Binder::BoundType _floatType = Binder::BoundType(ClassAttr::None, sizeof(float)); + static Binder::BoundType _doubleType = Binder::BoundType(ClassAttr::None, sizeof(double)); + static Binder::BoundType _boolType = Binder::BoundType(ClassAttr::None, sizeof(uint8_t)); class PrimitiveTypes { public: @@ -43,6 +56,20 @@ namespace MalachScript { constexpr static const Identifier& DoubleName() noexcept { return _doubleName; } constexpr static const Identifier& BoolName() noexcept { return _boolName; } constexpr static const Identifier& AutoName() noexcept { return _autoName; } + + constexpr static const Binder::BoundType* IntType() noexcept { return &_int32Type; } + constexpr static const Binder::BoundType* Int8Type() noexcept { return &_int8Type; } + constexpr static const Binder::BoundType* Int16Type() noexcept { return &_int16Type; } + constexpr static const Binder::BoundType* Int32Type() noexcept { return &_int32Type; } + constexpr static const Binder::BoundType* Int64Type() noexcept { return &_int64Type; } + constexpr static const Binder::BoundType* UintType() noexcept { return &_uint32Type; } + constexpr static const Binder::BoundType* Uint8Type() noexcept { return &_uint8Type; } + constexpr static const Binder::BoundType* Uint16Type() noexcept { return &_uint16Type; } + constexpr static const Binder::BoundType* Uint32Type() noexcept { return &_uint32Type; } + constexpr static const Binder::BoundType* Uint64Type() noexcept { return &_uint64Type; } + constexpr static const Binder::BoundType* FloatType() noexcept { return &_floatType; } + constexpr static const Binder::BoundType* DoubleType() noexcept { return &_doubleType; } + constexpr static const Binder::BoundType* BoolType() noexcept { return &_boolType; } }; } diff --git a/src/Diagnostics/Diagnostic.hpp b/src/Diagnostics/Diagnostic.hpp index cfed5b8..10ecd0e 100644 --- a/src/Diagnostics/Diagnostic.hpp +++ b/src/Diagnostics/Diagnostic.hpp @@ -9,19 +9,19 @@ namespace MalachScript::Diagnostics { class Diagnostic { DiagnosticLevel _level; DiagnosticType _type; - std::u8string_view _scriptName; + std::string_view _scriptName; TextSpan _span; std::vector _formats; public: - inline Diagnostic(DiagnosticLevel level, DiagnosticType type, const std::u8string_view& scriptName, - TextSpan span, const std::vector& formats = {}) + inline Diagnostic(DiagnosticLevel level, DiagnosticType type, const std::string_view& scriptName, TextSpan span, + const std::vector& formats = {}) : _level(level), _type(type), _scriptName(scriptName), _span(span), _formats(formats) {} [[nodiscard]] inline DiagnosticLevel GetLevel() const noexcept { return _level; } [[nodiscard]] inline DiagnosticType GetType() const noexcept { return _type; } [[nodiscard]] inline const TextSpan& GetSpan() const noexcept { return _span; } - [[nodiscard]] inline const std::u8string_view& GetScriptName() const noexcept { return _scriptName; } + [[nodiscard]] inline const std::string_view& GetScriptName() const noexcept { return _scriptName; } [[nodiscard]] inline const std::vector& GetFormats() const noexcept { return _formats; } }; } diff --git a/src/Diagnostics/DiagnosticType.hpp b/src/Diagnostics/DiagnosticType.hpp index 666b42c..89023d5 100644 --- a/src/Diagnostics/DiagnosticType.hpp +++ b/src/Diagnostics/DiagnosticType.hpp @@ -8,6 +8,8 @@ namespace MalachScript::Diagnostics { ExpectedEndOfString, UnexpectedToken, DoubleProperty, + + UnknownType, }; } diff --git a/src/Diagnostics/DiagnosticTypeEN_US.hpp b/src/Diagnostics/DiagnosticTypeEN_US.hpp index dc2f3bd..d8447f7 100644 --- a/src/Diagnostics/DiagnosticTypeEN_US.hpp +++ b/src/Diagnostics/DiagnosticTypeEN_US.hpp @@ -23,6 +23,8 @@ namespace MalachScript::Diagnostics { diag->GetFormats()); } case DiagnosticType::DoubleProperty: return "Property block found twice."; + + case DiagnosticType::UnknownType: util::Format("Unknown Type Encounted: '{0}'", diag->GetFormats()); } return std::to_string((uint8_t)diag->GetType()); } diff --git a/src/Diagnostics/Logger.hpp b/src/Diagnostics/Logger.hpp index b925593..075a440 100644 --- a/src/Diagnostics/Logger.hpp +++ b/src/Diagnostics/Logger.hpp @@ -9,24 +9,24 @@ namespace MalachScript::Diagnostics { std::vector _messages; public: - inline void Log(DiagnosticLevel level, DiagnosticType type, std::u8string_view scriptName, TextSpan span, + inline void Log(DiagnosticLevel level, DiagnosticType type, std::string_view scriptName, TextSpan span, const std::vector& formats = {}) { _messages.emplace_back(level, type, scriptName, span, formats); } - inline void LogTrace(DiagnosticType type, std::u8string_view scriptName, TextSpan span) { + inline void LogTrace(DiagnosticType type, std::string_view scriptName, TextSpan span) { Log(DiagnosticLevel::Trace, type, scriptName, span); } - inline void LogInfo(DiagnosticType type, std::u8string_view scriptName, TextSpan span) { + inline void LogInfo(DiagnosticType type, std::string_view scriptName, TextSpan span) { Log(DiagnosticLevel::Information, type, scriptName, span); } - inline void LogWarning(DiagnosticType type, std::u8string_view scriptName, TextSpan span) { + inline void LogWarning(DiagnosticType type, std::string_view scriptName, TextSpan span) { Log(DiagnosticLevel::Warning, type, scriptName, span); } - inline void LogError(DiagnosticType type, std::u8string_view scriptName, TextSpan span, + inline void LogError(DiagnosticType type, std::string_view scriptName, TextSpan span, const std::vector& formats = {}) { Log(DiagnosticLevel::Error, type, scriptName, span, formats); } - inline void LogCritical(DiagnosticType type, std::u8string_view scriptName, TextSpan span) { + inline void LogCritical(DiagnosticType type, std::string_view scriptName, TextSpan span) { Log(DiagnosticLevel::Critical, type, scriptName, span); } diff --git a/src/Parser/Lexer/Lexer.cpp b/src/Parser/Lexer/Lexer.cpp index 690b9a9..19fa076 100644 --- a/src/Parser/Lexer/Lexer.cpp +++ b/src/Parser/Lexer/Lexer.cpp @@ -25,13 +25,13 @@ namespace MalachScript::Parser { auto start = _position; auto c = Consume(); switch (c) { - case u8'\0': return Create>(TextSpan(start + 1, start + 2)); - case u8'*': { + case '\0': return Create>(TextSpan(start + 1, start + 2)); + case '*': { auto n = Peek(); - if (n == u8'*') { + if (n == '*') { Progress(); n = Peek(); - if (n == u8'=') { + if (n == '=') { Progress(); // **= return Create>(TextSpan(start, start + 3)); @@ -39,7 +39,7 @@ namespace MalachScript::Parser { // ** return Create>(TextSpan(start, start + 2)); } - if (n == u8'=') { + if (n == '=') { Progress(); // *= return Create>(TextSpan(start, start + 2)); @@ -47,30 +47,30 @@ namespace MalachScript::Parser { // * return Create>(TextSpan(start, start + 1)); } - case u8'/': - if (Peek() == u8'=') { + case '/': + if (Peek() == '=') { Progress(); // /= return Create>(TextSpan(start, start + 2)); } // / return Create>(TextSpan(start, start + 1)); - case u8'%': - if (Peek() == u8'=') { + case '%': + if (Peek() == '=') { Progress(); // %= return Create>(TextSpan(start, start + 2)); } // % return Create>(TextSpan(start, start + 1)); - case u8'+': { + case '+': { auto n = Peek(); - if (n == u8'=') { + if (n == '=') { Progress(); // += return Create>(TextSpan(start, start + 2)); } - if (n == u8'+') { + if (n == '+') { Progress(); // ++ return Create>(TextSpan(start, start + 2)); @@ -78,14 +78,14 @@ namespace MalachScript::Parser { // + return Create>(TextSpan(start, start + 1)); } - case u8'-': { + case '-': { auto n = Peek(); - if (n == u8'=') { + if (n == '=') { Progress(); // -= return Create>(TextSpan(start, start + 2)); } - if (n == u8'-') { + if (n == '-') { Progress(); // -- return Create>(TextSpan(start, start + 2)); @@ -93,16 +93,16 @@ namespace MalachScript::Parser { // - return Create>(TextSpan(start, start + 1)); } - case u8'<': { + case '<': { auto n = Peek(); - if (n == u8'=') { + if (n == '=') { Progress(); // <= return Create>(TextSpan(start, start + 2)); } - if (n == u8'<') { + if (n == '<') { Progress(); - if (Peek() == u8'=') { + if (Peek() == '=') { Progress(); // <<= return Create>( @@ -114,25 +114,25 @@ namespace MalachScript::Parser { // < return Create>(TextSpan(start, start + 1)); } - case u8'>': { + case '>': { auto n = Peek(); - if (n == u8'=') { + if (n == '=') { Progress(); // >= return Create>(TextSpan(start, start + 2)); } - if (n == u8'>') { + if (n == '>') { Progress(); n = Peek(); - if (n == u8'=') { + if (n == '=') { Progress(); // >>= return Create>( TextSpan(start, start + 3)); } - if (n == u8'>') { + if (n == '>') { Progress(); - if (Peek() == u8'=') { + if (Peek() == '=') { Progress(); // >>>= return Create>( @@ -148,10 +148,10 @@ namespace MalachScript::Parser { // > return Create>(TextSpan(start, start + 1)); } - case u8'(': return Create>(TextSpan(start, start + 1)); - case u8')': return Create>(TextSpan(start, start + 1)); - case u8'=': { - if (Peek() == u8'=') { + case '(': return Create>(TextSpan(start, start + 1)); + case ')': return Create>(TextSpan(start, start + 1)); + case '=': { + if (Peek() == '=') { Progress(); // == return Create>(TextSpan(start, start + 2)); @@ -159,14 +159,14 @@ namespace MalachScript::Parser { // = return Create>(TextSpan(start, start + 1)); } - case u8'!': { + case '!': { auto n = Peek(); - if (n == u8'=') { + if (n == '=') { Progress(); // != return Create>(TextSpan(start, start + 2)); } - if (n == u8'i' && Peek(2) == u8's') { + if (n == 'i' && Peek(2) == 's') { Progress(2); // !is return Create>(TextSpan(start, start + 3)); @@ -174,9 +174,9 @@ namespace MalachScript::Parser { // ! return Create>(TextSpan(start, start + 1)); } - case u8'?': return Create>(TextSpan(start, start + 1)); - case u8':': { - if (Peek() == u8':') { + case '?': return Create>(TextSpan(start, start + 1)); + case ':': { + if (Peek() == ':') { Progress(); // :: return Create>(TextSpan(start, start + 2)); @@ -184,14 +184,14 @@ namespace MalachScript::Parser { // : return Create>(TextSpan(start, start + 1)); } - case u8'&': { + case '&': { auto n = Peek(); - if (n == u8'=') { + if (n == '=') { Progress(); // &= return Create>(TextSpan(start, start + 2)); } - if (n == u8'&') { + if (n == '&') { Progress(); // && return Create>(TextSpan(start, start + 2)); @@ -199,20 +199,19 @@ namespace MalachScript::Parser { // & return Create>(TextSpan(start, start + 1)); } - case u8',': return Create>(TextSpan(start, start + 1)); - case u8'{': - return Create>(TextSpan(start, start + 1)); - case u8'}': + case ',': return Create>(TextSpan(start, start + 1)); + case '{': return Create>(TextSpan(start, start + 1)); + case '}': return Create>(TextSpan(start, start + 1)); - case u8';': return Create>(TextSpan(start, start + 1)); - case u8'|': { + case ';': return Create>(TextSpan(start, start + 1)); + case '|': { auto n = Peek(); - if (n == u8'=') { + if (n == '=') { Progress(); // |= return Create>(TextSpan(start, start + 2)); } - if (n == u8'|') { + if (n == '|') { Progress(); // || return Create>( @@ -221,14 +220,14 @@ namespace MalachScript::Parser { // | return Create>(TextSpan(start, start + 1)); } - case u8'^': { + case '^': { auto n = Peek(); - if (n == u8'=') { + if (n == '=') { Progress(); // ^= return Create>(TextSpan(start, start + 2)); } - if (n == u8'^') { + if (n == '^') { Progress(); // ^^ return Create>(TextSpan(start, start + 2)); @@ -236,21 +235,20 @@ namespace MalachScript::Parser { // ^ return Create>(TextSpan(start, start + 1)); } - case u8'~': return Create>(TextSpan(start, start + 1)); - case u8'.': return Create>(TextSpan(start, start + 1)); - case u8'[': - return Create>(TextSpan(start, start + 1)); - case u8']': + case '~': return Create>(TextSpan(start, start + 1)); + case '.': return Create>(TextSpan(start, start + 1)); + case '[': return Create>(TextSpan(start, start + 1)); + case ']': return Create>(TextSpan(start, start + 1)); - case u8'@': return Create>(TextSpan(start, start + 1)); + case '@': return Create>(TextSpan(start, start + 1)); - case u8' ': - case u8'\r': - case u8'\n': - case u8'\t': return Create>(TextSpan(start, start + 1)); + case ' ': + case '\r': + case '\n': + case '\t': return Create>(TextSpan(start, start + 1)); // Byte order mark - case u8'\xEF': { - if (Peek() == u8'\xBB' && Peek(2) == u8'\xBF') { + case '\xEF': { + if (Peek() == '\xBB' && Peek(2) == '\xBF') { Progress(2); return Create>(TextSpan(start, start + 3)); } @@ -258,22 +256,22 @@ namespace MalachScript::Parser { {std::string(1, c)}); return Create>(TextSpan(start, start + 1)); } - case u8'0': - case u8'1': - case u8'2': - case u8'3': - case u8'4': - case u8'5': - case u8'6': - case u8'7': - case u8'8': - case u8'9': return LexNumerical(c); - case u8'\'': return LexString(u8'\'', false); - case u8'"': { + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': return LexNumerical(c); + case '\'': return LexString('\'', false); + case '"': { if (Peek() == '"' && Peek(2) == '\"') { - return LexString(u8'"', true); + return LexString('"', true); } - return LexString(u8'"', false); + return LexString('"', false); } default: @@ -285,7 +283,7 @@ namespace MalachScript::Parser { } } - LexToken* Lexer::LexNumerical(char8_t c) { + LexToken* Lexer::LexNumerical(char c) { auto initialValue = LexDecimalValue(c); auto numericalSystem = 10; // Default to decimal system. if (initialValue == 0) { @@ -361,12 +359,12 @@ namespace MalachScript::Parser { while (true) { auto v = (ParseInt)LexDecimalValue(Peek()); if (v == 255) { - if (!isDecimal && Peek() == u8'.') { + if (!isDecimal && Peek() == '.') { isDecimal = true; Progress(); continue; } - if (isDecimal && (Peek() == u8'e' || Peek() == u8'E')) { + if (isDecimal && (Peek() == 'e' || Peek() == 'E')) { isDecimal = false; isExponent = true; Progress(); @@ -439,7 +437,7 @@ namespace MalachScript::Parser { } return Create(TextSpan(start - 1, _position), value); } - StringLiteral* Lexer::LexString(char8_t opening, bool heredoc) { + StringLiteral* Lexer::LexString(char opening, bool heredoc) { auto openingPos = _position; Progress(); if (heredoc) { @@ -456,12 +454,12 @@ namespace MalachScript::Parser { } else if (current == opening) { break; } - if (current == u8'\0') { + if (current == '\0') { LogError(Diagnostics::DiagnosticType::ExpectedEndOfString, TextSpan(start, start + offset), {"EndOfFile"}); break; } - if (!heredoc && (current == u8'\n' || current == u8'\r')) { + if (!heredoc && (current == '\n' || current == '\r')) { LogError(Diagnostics::DiagnosticType::ExpectedEndOfString, TextSpan(start, start + offset), {"Newline"}); break; @@ -486,139 +484,139 @@ namespace MalachScript::Parser { Progress(offset - 1); auto hash = Identifier::Hash(str); switch (hash) { - case Identifier::Hash(u8"and"): + case Identifier::Hash("and"): return Create>(TextSpan(start, _position)); - case Identifier::Hash(u8"abstract"): + case Identifier::Hash("abstract"): return Create>(TextSpan(start, _position)); - case Identifier::Hash(u8"auto"): + case Identifier::Hash("auto"): return Create>(TextSpan(start, _position)); - case Identifier::Hash(u8"bool"): + case Identifier::Hash("bool"): return Create>(TextSpan(start, _position)); - case Identifier::Hash(u8"break"): + case Identifier::Hash("break"): return Create>(TextSpan(start, _position)); - case Identifier::Hash(u8"case"): + case Identifier::Hash("case"): return Create>(TextSpan(start, _position)); - case Identifier::Hash(u8"cast"): + case Identifier::Hash("cast"): return Create>(TextSpan(start, _position)); - case Identifier::Hash(u8"catch"): + case Identifier::Hash("catch"): return Create>(TextSpan(start, _position)); - case Identifier::Hash(u8"class"): + case Identifier::Hash("class"): return Create>(TextSpan(start, _position)); - case Identifier::Hash(u8"const"): + case Identifier::Hash("const"): return Create>(TextSpan(start, _position)); - case Identifier::Hash(u8"continue"): + case Identifier::Hash("continue"): return Create>(TextSpan(start, _position)); - case Identifier::Hash(u8"default"): + case Identifier::Hash("default"): return Create>(TextSpan(start, _position)); - case Identifier::Hash(u8"do"): + case Identifier::Hash("do"): return Create>(TextSpan(start, _position)); - case Identifier::Hash(u8"double"): + case Identifier::Hash("double"): return Create>(TextSpan(start, _position)); - case Identifier::Hash(u8"else"): + case Identifier::Hash("else"): return Create>(TextSpan(start, _position)); - case Identifier::Hash(u8"enum"): + case Identifier::Hash("enum"): return Create>(TextSpan(start, _position)); - case Identifier::Hash(u8"explicit"): + case Identifier::Hash("explicit"): return Create>(TextSpan(start, _position)); - case Identifier::Hash(u8"external"): + case Identifier::Hash("external"): return Create>(TextSpan(start, _position)); - case Identifier::Hash(u8"false"): + case Identifier::Hash("false"): return Create>(TextSpan(start, _position)); - case Identifier::Hash(u8"final"): + case Identifier::Hash("final"): return Create>(TextSpan(start, _position)); - case Identifier::Hash(u8"float"): + case Identifier::Hash("float"): return Create>(TextSpan(start, _position)); - case Identifier::Hash(u8"for"): + case Identifier::Hash("for"): return Create>(TextSpan(start, _position)); - case Identifier::Hash(u8"from"): + case Identifier::Hash("from"): return Create>(TextSpan(start, _position)); - case Identifier::Hash(u8"funcdef"): + case Identifier::Hash("funcdef"): return Create>(TextSpan(start, _position)); - case Identifier::Hash(u8"function"): + case Identifier::Hash("function"): return Create>(TextSpan(start, _position)); - case Identifier::Hash(u8"get"): + case Identifier::Hash("get"): return Create>(TextSpan(start, _position)); - case Identifier::Hash(u8"if"): + case Identifier::Hash("if"): return Create>(TextSpan(start, _position)); - case Identifier::Hash(u8"import"): + case Identifier::Hash("import"): return Create>(TextSpan(start, _position)); - case Identifier::Hash(u8"in"): + case Identifier::Hash("in"): return Create>(TextSpan(start, _position)); - case Identifier::Hash(u8"inout"): + case Identifier::Hash("inout"): return Create>(TextSpan(start, _position)); - case Identifier::Hash(u8"int"): + case Identifier::Hash("int"): return Create>(TextSpan(start, _position)); - case Identifier::Hash(u8"interface"): + case Identifier::Hash("interface"): return Create>(TextSpan(start, _position)); - case Identifier::Hash(u8"int8"): + case Identifier::Hash("int8"): return Create>(TextSpan(start, _position)); - case Identifier::Hash(u8"int16"): + case Identifier::Hash("int16"): return Create>(TextSpan(start, _position)); - case Identifier::Hash(u8"int32"): + case Identifier::Hash("int32"): return Create>(TextSpan(start, _position)); - case Identifier::Hash(u8"int64"): + case Identifier::Hash("int64"): return Create>(TextSpan(start, _position)); - case Identifier::Hash(u8"is"): + case Identifier::Hash("is"): return Create>(TextSpan(start, _position)); - case Identifier::Hash(u8"mixin"): + case Identifier::Hash("mixin"): return Create>(TextSpan(start, _position)); - case Identifier::Hash(u8"namespace"): + case Identifier::Hash("namespace"): return Create>(TextSpan(start, _position)); - case Identifier::Hash(u8"not"): + case Identifier::Hash("not"): return Create>(TextSpan(start, _position)); - case Identifier::Hash(u8"null"): + case Identifier::Hash("null"): return Create>(TextSpan(start, _position)); - case Identifier::Hash(u8"or"): + case Identifier::Hash("or"): return Create>(TextSpan(start, _position)); - case Identifier::Hash(u8"out"): + case Identifier::Hash("out"): return Create>(TextSpan(start, _position)); - case Identifier::Hash(u8"override"): + case Identifier::Hash("override"): return Create>(TextSpan(start, _position)); - case Identifier::Hash(u8"private"): + case Identifier::Hash("private"): return Create>(TextSpan(start, _position)); - case Identifier::Hash(u8"property"): + case Identifier::Hash("property"): return Create>(TextSpan(start, _position)); - case Identifier::Hash(u8"protected"): + case Identifier::Hash("protected"): return Create>(TextSpan(start, _position)); - case Identifier::Hash(u8"return"): + case Identifier::Hash("return"): return Create>(TextSpan(start, _position)); - case Identifier::Hash(u8"set"): + case Identifier::Hash("set"): return Create>(TextSpan(start, _position)); - case Identifier::Hash(u8"shared"): + case Identifier::Hash("shared"): return Create>(TextSpan(start, _position)); - case Identifier::Hash(u8"super"): + case Identifier::Hash("super"): return Create>(TextSpan(start, _position)); - case Identifier::Hash(u8"switch"): + case Identifier::Hash("switch"): return Create>(TextSpan(start, _position)); - case Identifier::Hash(u8"this"): + case Identifier::Hash("this"): return Create>(TextSpan(start, _position)); - case Identifier::Hash(u8"true"): + case Identifier::Hash("true"): return Create>(TextSpan(start, _position)); - case Identifier::Hash(u8"try"): + case Identifier::Hash("try"): return Create>(TextSpan(start, _position)); - case Identifier::Hash(u8"typedef"): + case Identifier::Hash("typedef"): return Create>(TextSpan(start, _position)); - case Identifier::Hash(u8"uint"): + case Identifier::Hash("uint"): return Create>(TextSpan(start, _position)); - case Identifier::Hash(u8"uint8"): + case Identifier::Hash("uint8"): return Create>(TextSpan(start, _position)); - case Identifier::Hash(u8"uint16"): + case Identifier::Hash("uint16"): return Create>(TextSpan(start, _position)); - case Identifier::Hash(u8"uint32"): + case Identifier::Hash("uint32"): return Create>(TextSpan(start, _position)); - case Identifier::Hash(u8"uint64"): + case Identifier::Hash("uint64"): return Create>(TextSpan(start, _position)); - case Identifier::Hash(u8"void"): + case Identifier::Hash("void"): return Create>(TextSpan(start, _position)); - case Identifier::Hash(u8"while"): + case Identifier::Hash("while"): return Create>(TextSpan(start, _position)); - case Identifier::Hash(u8"xor"): + case Identifier::Hash("xor"): return Create>(TextSpan(start, _position)); default: return Create(TextSpan(start, _position), Identifier(str.data(), offset, hash)); } } - bool Lexer::IsAlphaNumericalOrUnderscore(char8_t c) { + bool Lexer::IsAlphaNumericalOrUnderscore(char c) { if (c >= 'a' && c <= 'z') { return true; } diff --git a/src/Parser/Lexer/Lexer.hpp b/src/Parser/Lexer/Lexer.hpp index 782da5b..7b159e2 100644 --- a/src/Parser/Lexer/Lexer.hpp +++ b/src/Parser/Lexer/Lexer.hpp @@ -9,22 +9,22 @@ namespace MalachScript::Parser { class Lexer { public: - Lexer(const char8_t* scriptName, const char8_t* script, Diagnostics::Logger* diag) - : Lexer(std::u8string_view(scriptName), std::u8string_view(script), diag) {} - Lexer(std::u8string_view scriptName, std::u8string_view script, Diagnostics::Logger* diag) + Lexer(const char* scriptName, const char* script, Diagnostics::Logger* diag) + : Lexer(std::string_view(scriptName), std::string_view(script), diag) {} + Lexer(std::string_view scriptName, std::string_view script, Diagnostics::Logger* diag) : _scriptName(scriptName), _script(script), _scriptLength(script.size()), _diagnostics(diag) {} const LexToken* Lex(); private: - std::u8string_view _scriptName; - std::u8string_view _script; + std::string_view _scriptName; + std::string_view _script; size_t _position = -1; size_t _scriptLength; Diagnostics::Logger* _diagnostics; Utils::MemoryPool<4096> _allocator; - inline char8_t Consume() { + inline char Consume() { if (++_position >= _scriptLength) { return '\0'; } @@ -33,7 +33,7 @@ namespace MalachScript::Parser { inline void Progress(size_t steps = 1) { _position += steps; } - inline char8_t Peek(size_t offset = 1) { + inline char Peek(size_t offset = 1) { auto pos = _position + offset; if (pos >= _scriptLength) { return '\0'; @@ -42,16 +42,16 @@ namespace MalachScript::Parser { } LexToken* LexNext(); - LexToken* LexNumerical(char8_t); + LexToken* LexNumerical(char); LexToken* LexDecimal(uint64_t initial); IntegerLiteral* LexHexadecimal(); IntegerLiteral* LexOctal(); IntegerLiteral* LexBinary(); - StringLiteral* LexString(char8_t opening, bool heredoc); + StringLiteral* LexString(char opening, bool heredoc); LexToken* LexKeywordOrIdentifier(); - static bool IsAlphaNumericalOrUnderscore(char8_t c); + static bool IsAlphaNumericalOrUnderscore(char c); template inline T* Create(parameters... args) { return _allocator.Create(args...); diff --git a/src/Parser/Lexer/NumericalLexers.cpp b/src/Parser/Lexer/NumericalLexers.cpp index f001810..c75ac3f 100644 --- a/src/Parser/Lexer/NumericalLexers.cpp +++ b/src/Parser/Lexer/NumericalLexers.cpp @@ -1,66 +1,66 @@ #include "NumericalLexers.hpp" #include -uint8_t LexDecimalValue(char8_t c) { +uint8_t LexDecimalValue(char c) { switch (c) { - case u8'0': return 0; - case u8'1': return 1; - case u8'2': return 2; - case u8'3': return 3; - case u8'4': return 4; - case u8'5': return 5; - case u8'6': return 6; - case u8'7': return 7; - case u8'8': return 8; - case u8'9': return 9; + case '0': return 0; + case '1': return 1; + case '2': return 2; + case '3': return 3; + case '4': return 4; + case '5': return 5; + case '6': return 6; + case '7': return 7; + case '8': return 8; + case '9': return 9; default: return 255; } } -uint8_t LexHexadecimalValue(char8_t c) { +uint8_t LexHexadecimalValue(char c) { switch (c) { - case u8'0': return 0; - case u8'1': return 1; - case u8'2': return 2; - case u8'3': return 3; - case u8'4': return 4; - case u8'5': return 5; - case u8'6': return 6; - case u8'7': return 7; - case u8'8': return 8; - case u8'9': return 9; - case u8'a': - case u8'A': return 10; - case u8'b': - case u8'B': return 11; - case u8'c': - case u8'C': return 12; - case u8'd': - case u8'D': return 13; - case u8'e': - case u8'E': return 14; - case u8'f': - case u8'F': return 15; + case '0': return 0; + case '1': return 1; + case '2': return 2; + case '3': return 3; + case '4': return 4; + case '5': return 5; + case '6': return 6; + case '7': return 7; + case '8': return 8; + case '9': return 9; + case 'a': + case 'A': return 10; + case 'b': + case 'B': return 11; + case 'c': + case 'C': return 12; + case 'd': + case 'D': return 13; + case 'e': + case 'E': return 14; + case 'f': + case 'F': return 15; default: return 255; } } -uint8_t LexOctalValue(char8_t c) { +uint8_t LexOctalValue(char c) { switch (c) { - case u8'0': return 0; - case u8'1': return 1; - case u8'2': return 2; - case u8'3': return 3; - case u8'4': return 4; - case u8'5': return 5; - case u8'6': return 6; - case u8'7': return 7; + case '0': return 0; + case '1': return 1; + case '2': return 2; + case '3': return 3; + case '4': return 4; + case '5': return 5; + case '6': return 6; + case '7': return 7; default: return 255; } } -uint8_t LexBinaryValue(char8_t c) { +uint8_t LexBinaryValue(char c) { switch (c) { - case u8'0': return 0; - case u8'1': return 1; + case '0': return 0; + case '1': return 1; default: return 255; } } diff --git a/src/Parser/Lexer/NumericalLexers.hpp b/src/Parser/Lexer/NumericalLexers.hpp index 8335dc7..ab6a850 100644 --- a/src/Parser/Lexer/NumericalLexers.hpp +++ b/src/Parser/Lexer/NumericalLexers.hpp @@ -3,9 +3,9 @@ #include -uint8_t LexDecimalValue(char8_t c); -uint8_t LexHexadecimalValue(char8_t c); -uint8_t LexOctalValue(char8_t c); -uint8_t LexBinaryValue(char8_t c); +uint8_t LexDecimalValue(char c); +uint8_t LexHexadecimalValue(char c); +uint8_t LexOctalValue(char c); +uint8_t LexBinaryValue(char c); #endif // MALACHSCRIPT_NUMERICALLEXERS_HPP diff --git a/src/Parser/Parser.cpp b/src/Parser/Parser.cpp index 06f09a3..06d566b 100644 --- a/src/Parser/Parser.cpp +++ b/src/Parser/Parser.cpp @@ -38,7 +38,7 @@ namespace MalachScript::Parser { using namespace Diagnostics; - const ParsedScriptStatement* Parser::Parse(const LexToken* firstToken, std::u8string_view scriptName, + const ParsedScriptStatement* Parser::Parse(const LexToken* firstToken, std::string_view scriptName, Logger* diagnostics) { const log_func& log = [diagnostics, scriptName](DiagnosticLevel level, DiagnosticType type, const TextSpan& span, const std::vector& formats) { @@ -252,7 +252,7 @@ namespace MalachScript::Parser { accessModifier = AccessModifier::Protected; PROGRESS_TOKEN(current); } - ScopedPtr typeStatement = nullptr; + ScopedPtr typeStatement = nullptr; bool returnsReference = false; if (current->GetKind() == LexTokenKind::TildeSymbol) { // TODO: Handle destructor @@ -295,7 +295,8 @@ namespace MalachScript::Parser { return true; } - bool Parser::ParseType(ScopedPtr& out, const LexToken*& currentToken, const log_func& log) { + bool Parser::ParseType(ScopedPtr& out, const LexToken*& currentToken, + const log_func& log) { const auto* current = currentToken; auto start = current->GetSpan().GetStart(); bool isConst = false; @@ -420,7 +421,7 @@ namespace MalachScript::Parser { return true; } while (true) { - ScopedPtr typeStatement = nullptr; + ScopedPtr typeStatement = nullptr; TypeMod typeMod = TypeMod::None; Identifier identifier; const ParsedStatement* defaultExpression = nullptr; @@ -480,7 +481,7 @@ namespace MalachScript::Parser { access = AccessModifier::Protected; PROGRESS_TOKEN(current); } - ScopedPtr typeStatement = nullptr; + ScopedPtr typeStatement = nullptr; if (!ParseType(typeStatement, current, log)) { return false; } @@ -623,7 +624,7 @@ namespace MalachScript::Parser { access = AccessModifier::Protected; PROGRESS_TOKEN(current); } - ScopedPtr typeStatement = nullptr; + ScopedPtr typeStatement = nullptr; if (!ParseType(typeStatement, current, log)) { return false; } diff --git a/src/Parser/Parser.hpp b/src/Parser/Parser.hpp index 065e341..daa9870 100644 --- a/src/Parser/Parser.hpp +++ b/src/Parser/Parser.hpp @@ -11,7 +11,7 @@ namespace MalachScript::Parser { class Parser { public: - static const ParsedScriptStatement* Parse(const LexToken* firstToken, std::u8string_view scriptName, + static const ParsedScriptStatement* Parse(const LexToken* firstToken, std::string_view scriptName, Diagnostics::Logger* diagnostics); private: @@ -110,7 +110,8 @@ namespace MalachScript::Parser { static bool ParsePrimType(Identifier& out, const LexToken*& currentToken, const log_func&); static bool ParseDataType(Identifier& out, const LexToken*& currentToken, const log_func&); static bool ParseScope(std::vector& out, const LexToken*& currentToken, const log_func&); - static bool ParseType(ScopedPtr& out, const LexToken*& currentToken, const log_func&); + static bool ParseType(ScopedPtr& out, const LexToken*& currentToken, + const log_func&); static bool ParseAssign(ScopedPtr& out, const LexToken*& currentToken, const log_func&); // InitList inline static bool ParsePreOp(PreOperator& op, const LexToken*& token, const log_func&) { diff --git a/src/Parser/ParserDefines.hpp b/src/Parser/ParserDefines.hpp index e3b674a..ea79f7b 100644 --- a/src/Parser/ParserDefines.hpp +++ b/src/Parser/ParserDefines.hpp @@ -5,6 +5,6 @@ using ParseInt = uintmax_t; using ParseFloat = long double; -using ParseString = std::u8string; +using ParseString = std::string; #endif // MALACHSCRIPT_PARSERDEFINES_HPP diff --git a/src/Parser/Statements/ParsedStatement.hpp b/src/Parser/Statements/ParsedStatement.hpp index d3d3cf4..813ce86 100644 --- a/src/Parser/Statements/ParsedStatement.hpp +++ b/src/Parser/Statements/ParsedStatement.hpp @@ -1,6 +1,7 @@ #ifndef MALACHSCRIPT_PARSEDSTATEMENT_HPP #define MALACHSCRIPT_PARSEDSTATEMENT_HPP +#include #include #include #include @@ -8,6 +9,7 @@ #include "../../CoreData/AccessModifier.hpp" #include "../../CoreData/ClassAttr.hpp" #include "../../CoreData/FuncAttr.hpp" +#include "../../CoreData/Identifier.hpp" #include "../../CoreData/TypeMod.hpp" #include "../../TextSpan.hpp" #include "ParsedStatementKind.hpp" @@ -46,11 +48,12 @@ namespace MalachScript::Parser { class ParsedClassStatement : public ParsedStatementImpl { public: ParsedClassStatement(TextSpan span, ClassAttr classAttr, Identifier identifier, - std::vector inherits, const std::vector& body) + const std::vector& inherits, const std::vector& body) : ParsedStatementImpl(span), _classAttr(classAttr), _identifier(identifier), _inherits(inherits), _body(body.size()) { - for (size_t i = 0; i < body.size(); i++) + for (size_t i = 0; i < body.size(); i++) { _body[i] = std::unique_ptr(body[i]); + } } [[nodiscard]] ClassAttr GetClassAttr() const noexcept { return _classAttr; } @@ -269,21 +272,21 @@ namespace MalachScript::Parser { std::vector> _statements; }; - class ParsedVarStatement : public ParsedStatementImpl { + class ParsedVarStatement : public ParsedStatementImpl { public: - ParsedVarStatement(const TextSpan& span, AccessModifier access, const ParsedStatement* typeStatement, + ParsedVarStatement(const TextSpan& span, AccessModifier access, const ParsedTypeStatement* typeStatement, Identifier identifier) : ParsedStatementImpl(span), _access(access), _typeStatement(typeStatement), _identifier(identifier) {} [[nodiscard]] AccessModifier GetAccess() const noexcept { return _access; } - [[nodiscard]] const std::unique_ptr& GetTypeStatement() const noexcept { + [[nodiscard]] const std::unique_ptr& GetTypeStatement() const noexcept { return _typeStatement; } [[nodiscard]] const Identifier& GetIdentifier() const noexcept { return _identifier; } private: AccessModifier _access; - std::unique_ptr _typeStatement; + std::unique_ptr _typeStatement; Identifier _identifier; }; @@ -468,7 +471,6 @@ namespace MalachScript::Parser { std::unique_ptr _expression; std::vector> _statements; }; - } #endif // MALACHSCRIPT_PARSEDSTATEMENT_HPP diff --git a/src/Parser/Statements/ParsedStatementKind.hpp b/src/Parser/Statements/ParsedStatementKind.hpp index 4a30edd..83080f3 100644 --- a/src/Parser/Statements/ParsedStatementKind.hpp +++ b/src/Parser/Statements/ParsedStatementKind.hpp @@ -13,6 +13,7 @@ namespace MalachScript::Parser { Func, VirtProp, StatBlock, + Var, If, Assign, BinaryExpression, @@ -46,6 +47,7 @@ namespace MalachScript::Parser { case ParsedStatementKind::Func: return "Func"; case ParsedStatementKind::VirtProp: return "VirtProp"; case ParsedStatementKind::StatBlock: return "StatBlock"; + case ParsedStatementKind::Var: return "Var"; case ParsedStatementKind::If: return "If"; case ParsedStatementKind::Assign: return "Assign"; case ParsedStatementKind::BinaryExpression: return "BinaryExpression"; diff --git a/src/Parser/Statements/ParsedStatementStringifier.hpp b/src/Parser/Statements/ParsedStatementStringifier.hpp index ca1e150..6fbbab6 100644 --- a/src/Parser/Statements/ParsedStatementStringifier.hpp +++ b/src/Parser/Statements/ParsedStatementStringifier.hpp @@ -193,6 +193,7 @@ namespace MalachScript::Parser { case ParsedStatementKind::Try: break; case ParsedStatementKind::Switch: break; case ParsedStatementKind::Case: break; + case ParsedStatementKind::Var: break; } } }; diff --git a/src/ScriptEngine.cpp b/src/ScriptEngine.cpp new file mode 100644 index 0000000..e7a5d32 --- /dev/null +++ b/src/ScriptEngine.cpp @@ -0,0 +1 @@ +#include "ScriptEngine.hpp" diff --git a/src/ScriptEngine.hpp b/src/ScriptEngine.hpp new file mode 100644 index 0000000..33be9bb --- /dev/null +++ b/src/ScriptEngine.hpp @@ -0,0 +1,11 @@ +#ifndef MALACHSCRIPT_SCRIPTENGINE_HPP +#define MALACHSCRIPT_SCRIPTENGINE_HPP + +namespace MalachScript { + class ScriptEngine { + public: + private: + }; +} + +#endif // MALACHSCRIPT_SCRIPTENGINE_HPP diff --git a/src/Utils/TreePrinter.hpp b/src/Utils/TreePrinter.hpp new file mode 100644 index 0000000..f29f916 --- /dev/null +++ b/src/Utils/TreePrinter.hpp @@ -0,0 +1,13 @@ +#ifndef MALACHSCRIPT_TREEPRINTER_HPP +#define MALACHSCRIPT_TREEPRINTER_HPP +#include + +class MalachScript::Utils { + class TreePrinter { + public: + private: + std::stringstream _stream; + }; +}; + +#endif // MALACHSCRIPT_TREEPRINTER_HPP diff --git a/tests/LexerTests/IdentifierLexTests.cpp b/tests/LexerTests/IdentifierLexTests.cpp index 240916b..514677e 100644 --- a/tests/LexerTests/IdentifierLexTests.cpp +++ b/tests/LexerTests/IdentifierLexTests.cpp @@ -6,7 +6,7 @@ using namespace MalachScript::Parser; #define KEYWORD_TEST(script, symbol) \ TEST_CASE("Lex " script) { \ MalachScript::Diagnostics::Logger diag; \ - auto lexer = Lexer(u8##script, u8##script, &diag); \ + auto lexer = Lexer(script, script, &diag); \ const auto* token = lexer.Lex(); \ CHECK(diag.GetMessages().empty()); \ CHECK(token->GetKind() == LexTokenKind::symbol); \ @@ -79,10 +79,8 @@ KEYWORD_TEST("while", WhileKeyword); KEYWORD_TEST("xor", XorKeyword); namespace doctest { - template <> struct StringMaker { - static String convert(const std::u8string& value) { - return String(reinterpret_cast(value.data())); - } + template <> struct StringMaker { + static String convert(const std::string& value) { return String(reinterpret_cast(value.data())); } }; template <> struct StringMaker { static String convert(LexTokenKind value) { return String(std::to_string((uint32_t)value).c_str()); } @@ -93,12 +91,12 @@ namespace doctest { #define IDENTIFIER_TEST(identifier) \ TEST_CASE("Lex identifier " identifier) { \ MalachScript::Diagnostics::Logger diag; \ - auto lexer = Lexer(u8##identifier, u8##identifier, &diag); \ + auto lexer = Lexer(identifier, identifier, &diag); \ const auto* token = lexer.Lex(); \ CHECK(diag.GetMessages().empty()); \ REQUIRE(token->GetKind() == LexTokenKind::Identifier); \ auto value = ((IdentifierToken*)token)->GetValue().GetString(); \ - CHECK(value == std::u8string(reinterpret_cast(identifier))); \ + CHECK(value == std::string(reinterpret_cast(identifier))); \ CHECK(token->GetNext()->GetKind() == LexTokenKind::EndOfFile); \ } diff --git a/tests/LexerTests/LexerIntegrationTests.cpp b/tests/LexerTests/LexerIntegrationTests.cpp index 7a72e69..689fdd1 100644 --- a/tests/LexerTests/LexerIntegrationTests.cpp +++ b/tests/LexerTests/LexerIntegrationTests.cpp @@ -6,7 +6,7 @@ using namespace MalachScript::Parser; #define LEX_TEST(script, ...) \ TEST_CASE("Lex: " script) { \ MalachScript::Diagnostics::Logger diag; \ - auto lexer = Lexer(u8##script, u8##script, &diag); \ + auto lexer = Lexer(script, script, &diag); \ const auto* token = lexer.Lex(); \ CHECK(diag.GetMessages().empty()); \ std::vector vec = {__VA_ARGS__, LexTokenKind::EndOfFile}; \ diff --git a/tests/LexerTests/NumericalLexTests.cpp b/tests/LexerTests/NumericalLexTests.cpp index 482794a..c543587 100644 --- a/tests/LexerTests/NumericalLexTests.cpp +++ b/tests/LexerTests/NumericalLexTests.cpp @@ -6,7 +6,7 @@ using namespace MalachScript::Parser; #define INTEGER_TEST(script, expected) \ TEST_CASE("Lex " script) { \ MalachScript::Diagnostics::Logger diag; \ - auto lexer = Lexer(u8##script, u8##script, &diag); \ + auto lexer = Lexer(script, script, &diag); \ const auto* token = lexer.Lex(); \ CHECK(diag.GetMessages().empty()); \ REQUIRE(token->GetKind() == LexTokenKind::IntegerLiteral); \ @@ -18,7 +18,7 @@ using namespace MalachScript::Parser; #define FLOAT_TEST(script, expected) \ TEST_CASE("Lex " script) { \ MalachScript::Diagnostics::Logger diag; \ - auto lexer = Lexer(u8##script, u8##script, &diag); \ + auto lexer = Lexer(script, script, &diag); \ const auto* token = lexer.Lex(); \ CHECK(diag.GetMessages().empty()); \ REQUIRE(token->GetKind() == LexTokenKind::FloatLiteral); \ diff --git a/tests/LexerTests/StringLexTests.cpp b/tests/LexerTests/StringLexTests.cpp index 384c13e..28d32f8 100644 --- a/tests/LexerTests/StringLexTests.cpp +++ b/tests/LexerTests/StringLexTests.cpp @@ -6,12 +6,12 @@ using namespace MalachScript::Parser; #define STRING_TEST(str, constraint) \ TEST_CASE("Lex string " constraint str constraint) { \ MalachScript::Diagnostics::Logger diag; \ - auto lexer = Lexer(u8##str, u8##constraint str constraint, &diag); \ + auto lexer = Lexer(str, constraint str constraint, &diag); \ const auto* token = lexer.Lex(); \ CHECK(diag.GetMessages().empty()); \ REQUIRE(token->GetKind() == LexTokenKind::StringLiteral); \ auto value = ((const StringLiteral*)token)->GetValue(); \ - CHECK(value == std::u8string(reinterpret_cast(str))); \ + CHECK(value == std::string(reinterpret_cast(str))); \ CHECK(token->GetNext()->GetKind() == LexTokenKind::EndOfFile); \ } @@ -23,14 +23,14 @@ STRING_TEST("\"\"foo bar\"\"", "\"\"\""); TEST_CASE("Lex multiline string") { MalachScript::Diagnostics::Logger diag; - auto lexer = Lexer(u8"multiline", u8R"("""foo + auto lexer = Lexer("multiline", R"("""foo bar""")", &diag); const auto* token = lexer.Lex(); CHECK(diag.GetMessages().empty()); REQUIRE(token->GetKind() == LexTokenKind::StringLiteral); auto value = (dynamic_cast(token))->GetValue(); - CHECK(value == std::u8string(reinterpret_cast(R"(foo + CHECK(value == std::string(reinterpret_cast(R"(foo bar)"))); CHECK(token->GetNext()->GetKind() == LexTokenKind::EndOfFile); } \ No newline at end of file diff --git a/tests/LexerTests/SymbolLexTests.cpp b/tests/LexerTests/SymbolLexTests.cpp index f3ae2d6..4dd43da 100644 --- a/tests/LexerTests/SymbolLexTests.cpp +++ b/tests/LexerTests/SymbolLexTests.cpp @@ -7,7 +7,7 @@ using namespace MalachScript::Parser; #define SYMBOL_TEST(script, symbol) \ TEST_CASE("Lex " script) { \ MalachScript::Diagnostics::Logger diag; \ - auto lexer = Lexer(u8##script, u8##script, &diag); \ + auto lexer = Lexer(script, script, &diag); \ const auto* token = lexer.Lex(); \ CHECK(diag.GetMessages().empty()); \ CHECK(token->GetKind() == LexTokenKind::symbol); \ @@ -71,10 +71,10 @@ SYMBOL_TEST(" ", Whitespace) #undef SYMBOL_TEST TEST_CASE("Lex whitespace") { - auto whitespace = {u8" ", u8"\t", u8"\n", u8"\r", u8"\xef\xbb\xbf"}; + auto whitespace = {" ", "\t", "\n", "\r", "\xef\xbb\xbf"}; for (const auto* v : whitespace) { MalachScript::Diagnostics::Logger diag; - auto lexer = Lexer(u8"whitespace", v, &diag); + auto lexer = Lexer("whitespace", v, &diag); const auto* token = lexer.Lex(); CHECK(diag.GetMessages().empty()); CHECK(token->GetKind() == LexTokenKind::Whitespace); diff --git a/tests/ParserTests/ClassTests.cpp b/tests/ParserTests/ClassTests.cpp index a5e3cbf..2fff150 100644 --- a/tests/ParserTests/ClassTests.cpp +++ b/tests/ParserTests/ClassTests.cpp @@ -13,7 +13,7 @@ using namespace MalachScript; vec[i]->SetNext(vec[i + 1]); \ } \ Diagnostics::Logger diags; \ - auto* script = Parser::Parser::Parse(vec.front(), u8"scriptname", &diags); \ + auto* script = Parser::Parser::Parse(vec.front(), "scriptname", &diags); \ REQUIRE(diags.GetMessages().empty()); \ asserts; \ delete vec[0]; \ @@ -24,7 +24,7 @@ using namespace MalachScript; PARSER_TEST("Parse basic class without body", PARSER_TEST_TOKENS(new Parser::LexTokenImpl(TextSpan(0, 0)), - new Parser::IdentifierToken(TextSpan(0, 0), u8"foobar"), + new Parser::IdentifierToken(TextSpan(0, 0), "foobar"), new Parser::LexTokenImpl(TextSpan(0, 0))), { REQUIRE(script->GetStatements().size() == 1); @@ -34,7 +34,7 @@ PARSER_TEST("Parse basic class without body", PARSER_TEST("Parse basic class without body with whitespaces", PARSER_TEST_TOKENS(new Parser::LexTokenImpl(TextSpan(0, 0)), new Parser::LexTokenImpl(TextSpan(0, 0)), - new Parser::IdentifierToken(TextSpan(0, 0), u8"foobar"), + new Parser::IdentifierToken(TextSpan(0, 0), "foobar"), new Parser::LexTokenImpl(TextSpan(0, 0)), new Parser::LexTokenImpl(TextSpan(0, 0))), { @@ -45,7 +45,7 @@ PARSER_TEST("Parse basic class without body with whitespaces", PARSER_TEST( "Parse basic class with empty body", PARSER_TEST_TOKENS(new Parser::LexTokenImpl(TextSpan(0, 0)), - new Parser::IdentifierToken(TextSpan(0, 0), u8"foobar"), + new Parser::IdentifierToken(TextSpan(0, 0), "foobar"), new Parser::LexTokenImpl(TextSpan(0, 0)), new Parser::LexTokenImpl(TextSpan(0, 0))), { diff --git a/tests/ParserTests/FunctionTests.cpp b/tests/ParserTests/FunctionTests.cpp index 47c4efd..57521fc 100644 --- a/tests/ParserTests/FunctionTests.cpp +++ b/tests/ParserTests/FunctionTests.cpp @@ -13,7 +13,7 @@ using namespace MalachScript; vec[i]->SetNext(vec[i + 1]); \ } \ Diagnostics::Logger diags; \ - auto* script = Parser::Parser::Parse(vec.front(), u8"scriptname", &diags); \ + auto* script = Parser::Parser::Parse(vec.front(), "scriptname", &diags); \ REQUIRE(diags.GetMessages().empty()); \ asserts; \ delete vec[0]; \ @@ -25,7 +25,7 @@ using namespace MalachScript; PARSER_TEST("Parse ``void foobar();``", PARSER_TEST_TOKENS(new Parser::LexTokenImpl(TextSpan(0, 0)), new Parser::LexTokenImpl(TextSpan(0, 0)), - new Parser::IdentifierToken(TextSpan(0, 0), u8"foobar"), + new Parser::IdentifierToken(TextSpan(0, 0), "foobar"), new Parser::LexTokenImpl(TextSpan(0, 0)), new Parser::LexTokenImpl(TextSpan(0, 0)), new Parser::LexTokenImpl(TextSpan(0, 0))), @@ -41,9 +41,9 @@ PARSER_TEST("Parse ``void foobar();``", CHECK_FALSE(type->IsArray()); CHECK_FALSE(type->IsHandle()); auto& id = type->GetScopedIdentifier(); - CHECK(id.GetIdentifier().GetString() == u8"void"); + CHECK(id.GetIdentifier().GetString() == "void"); CHECK_FALSE(funcStat->ReturnsReference()); - CHECK(funcStat->GetIdentifier().GetString() == u8"foobar"); + CHECK(funcStat->GetIdentifier().GetString() == "foobar"); auto paramList = (const MalachScript::Parser::ParsedParamListStatement*)funcStat->GetParamList().get(); CHECK(paramList->GetParameters().empty()); CHECK_FALSE(funcStat->IsConst()); @@ -52,13 +52,13 @@ PARSER_TEST("Parse ``void foobar();``", }) PARSER_TEST("Parse scoped function without body.", - PARSER_TEST_TOKENS(new Parser::IdentifierToken(TextSpan(0, 0), u8"foo"), + PARSER_TEST_TOKENS(new Parser::IdentifierToken(TextSpan(0, 0), "foo"), new Parser::LexTokenImpl(TextSpan(0, 0)), - new Parser::IdentifierToken(TextSpan(0, 0), u8"bar"), + new Parser::IdentifierToken(TextSpan(0, 0), "bar"), new Parser::LexTokenImpl(TextSpan(0, 0)), - new Parser::IdentifierToken(TextSpan(0, 0), u8"baz"), + new Parser::IdentifierToken(TextSpan(0, 0), "baz"), new Parser::LexTokenImpl(TextSpan(0, 0)), - new Parser::IdentifierToken(TextSpan(0, 0), u8"foobar"), + new Parser::IdentifierToken(TextSpan(0, 0), "foobar"), new Parser::LexTokenImpl(TextSpan(0, 0)), new Parser::LexTokenImpl(TextSpan(0, 0)), new Parser::LexTokenImpl(TextSpan(0, 0))), @@ -74,11 +74,11 @@ PARSER_TEST("Parse scoped function without body.", CHECK_FALSE(type->IsArray()); CHECK_FALSE(type->IsHandle()); auto& id = type->GetScopedIdentifier(); - CHECK(id.GetIdentifier().GetString() == u8"baz"); - CHECK(id.GetScope()[1].GetString() == u8"bar"); - CHECK(id.GetScope()[0].GetString() == u8"foo"); + CHECK(id.GetIdentifier().GetString() == "baz"); + CHECK(id.GetScope()[1].GetString() == "bar"); + CHECK(id.GetScope()[0].GetString() == "foo"); CHECK_FALSE(funcStat->ReturnsReference()); - CHECK(funcStat->GetIdentifier().GetString() == u8"foobar"); + CHECK(funcStat->GetIdentifier().GetString() == "foobar"); auto paramList = (const MalachScript::Parser::ParsedParamListStatement*)funcStat->GetParamList().get(); CHECK(paramList->GetParameters().empty()); CHECK_FALSE(funcStat->IsConst()); @@ -87,24 +87,24 @@ PARSER_TEST("Parse scoped function without body.", }) PARSER_TEST("Parse scoped function with parameters without body.", - PARSER_TEST_TOKENS(new Parser::IdentifierToken(TextSpan(0, 0), u8"foo"), + PARSER_TEST_TOKENS(new Parser::IdentifierToken(TextSpan(0, 0), "foo"), new Parser::LexTokenImpl(TextSpan(0, 0)), - new Parser::IdentifierToken(TextSpan(0, 0), u8"bar"), + new Parser::IdentifierToken(TextSpan(0, 0), "bar"), new Parser::LexTokenImpl(TextSpan(0, 0)), - new Parser::IdentifierToken(TextSpan(0, 0), u8"baz"), + new Parser::IdentifierToken(TextSpan(0, 0), "baz"), new Parser::LexTokenImpl(TextSpan(0, 0)), - new Parser::IdentifierToken(TextSpan(0, 0), u8"foobar"), + new Parser::IdentifierToken(TextSpan(0, 0), "foobar"), new Parser::LexTokenImpl(TextSpan(0, 0)), new Parser::LexTokenImpl(TextSpan(0, 0)), new Parser::LexTokenImpl(TextSpan(0, 0)), - new Parser::IdentifierToken(TextSpan(0, 0), u8"par1"), + new Parser::IdentifierToken(TextSpan(0, 0), "par1"), new Parser::LexTokenImpl(TextSpan(0, 0)), new Parser::LexTokenImpl(TextSpan(0, 0)), new Parser::LexTokenImpl(TextSpan(0, 0)), - new Parser::IdentifierToken(TextSpan(0, 0), u8"par2"), + new Parser::IdentifierToken(TextSpan(0, 0), "par2"), new Parser::LexTokenImpl(TextSpan(0, 0)), new Parser::LexTokenImpl(TextSpan(0, 0))), @@ -120,11 +120,11 @@ PARSER_TEST("Parse scoped function with parameters without body.", CHECK_FALSE(type->IsArray()); CHECK_FALSE(type->IsHandle()); auto& id = type->GetScopedIdentifier(); - CHECK(id.GetIdentifier().GetString() == u8"baz"); - CHECK(id.GetScope()[1].GetString() == u8"bar"); - CHECK(id.GetScope()[0].GetString() == u8"foo"); + CHECK(id.GetIdentifier().GetString() == "baz"); + CHECK(id.GetScope()[1].GetString() == "bar"); + CHECK(id.GetScope()[0].GetString() == "foo"); CHECK_FALSE(funcStat->ReturnsReference()); - CHECK(funcStat->GetIdentifier().GetString() == u8"foobar"); + CHECK(funcStat->GetIdentifier().GetString() == "foobar"); auto paramList = (const MalachScript::Parser::ParsedParamListStatement*)funcStat->GetParamList().get(); CHECK(paramList->GetParameters().size() == 2); @@ -133,9 +133,9 @@ PARSER_TEST("Parse scoped function with parameters without body.", CHECK_FALSE(par1.GetTypeStatement()->IsArray()); CHECK_FALSE(par1.GetTypeStatement()->IsHandle()); auto& par1TypeId = par1.GetTypeStatement()->GetScopedIdentifier(); - CHECK(par1TypeId.GetIdentifier().GetString() == u8"int"); + CHECK(par1TypeId.GetIdentifier().GetString() == "int"); CHECK(par1.GetTypeMod() == TypeMod::None); - CHECK(par1.GetIdentifier().GetString() == u8"par1"); + CHECK(par1.GetIdentifier().GetString() == "par1"); CHECK(par1.GetDefaultExpression() == nullptr); auto& par2 = *paramList->GetParameters()[1]; @@ -143,9 +143,9 @@ PARSER_TEST("Parse scoped function with parameters without body.", CHECK_FALSE(par2.GetTypeStatement()->IsArray()); CHECK_FALSE(par2.GetTypeStatement()->IsHandle()); auto& par2TypeId = par2.GetTypeStatement()->GetScopedIdentifier(); - CHECK(par2TypeId.GetIdentifier().GetString() == u8"bool"); + CHECK(par2TypeId.GetIdentifier().GetString() == "bool"); CHECK(par2.GetTypeMod() == TypeMod::None); - CHECK(par2.GetIdentifier().GetString() == u8"par2"); + CHECK(par2.GetIdentifier().GetString() == "par2"); CHECK(par2.GetDefaultExpression() == nullptr); CHECK_FALSE(funcStat->IsConst()); @@ -154,20 +154,20 @@ PARSER_TEST("Parse scoped function with parameters without body.", }) PARSER_TEST("Parse scoped function with reference parameters without body.", - PARSER_TEST_TOKENS(new Parser::IdentifierToken(TextSpan(0, 0), u8"foo"), + PARSER_TEST_TOKENS(new Parser::IdentifierToken(TextSpan(0, 0), "foo"), new Parser::LexTokenImpl(TextSpan(0, 0)), - new Parser::IdentifierToken(TextSpan(0, 0), u8"bar"), + new Parser::IdentifierToken(TextSpan(0, 0), "bar"), new Parser::LexTokenImpl(TextSpan(0, 0)), - new Parser::IdentifierToken(TextSpan(0, 0), u8"baz"), + new Parser::IdentifierToken(TextSpan(0, 0), "baz"), new Parser::LexTokenImpl(TextSpan(0, 0)), - new Parser::IdentifierToken(TextSpan(0, 0), u8"foobar"), + new Parser::IdentifierToken(TextSpan(0, 0), "foobar"), new Parser::LexTokenImpl(TextSpan(0, 0)), new Parser::LexTokenImpl(TextSpan(0, 0)), new Parser::LexTokenImpl(TextSpan(0, 0)), new Parser::LexTokenImpl(TextSpan(0, 0)), new Parser::LexTokenImpl(TextSpan(0, 0)), - new Parser::IdentifierToken(TextSpan(0, 0), u8"par1"), + new Parser::IdentifierToken(TextSpan(0, 0), "par1"), new Parser::LexTokenImpl(TextSpan(0, 0)), @@ -175,7 +175,7 @@ PARSER_TEST("Parse scoped function with reference parameters without body.", new Parser::LexTokenImpl(TextSpan(0, 0)), new Parser::LexTokenImpl(TextSpan(0, 0)), new Parser::LexTokenImpl(TextSpan(0, 0)), - new Parser::IdentifierToken(TextSpan(0, 0), u8"par2"), + new Parser::IdentifierToken(TextSpan(0, 0), "par2"), new Parser::LexTokenImpl(TextSpan(0, 0)), new Parser::LexTokenImpl(TextSpan(0, 0))), @@ -191,11 +191,11 @@ PARSER_TEST("Parse scoped function with reference parameters without body.", CHECK_FALSE(type->IsArray()); CHECK_FALSE(type->IsHandle()); auto& id = type->GetScopedIdentifier(); - CHECK(id.GetIdentifier().GetString() == u8"baz"); - CHECK(id.GetScope()[1].GetString() == u8"bar"); - CHECK(id.GetScope()[0].GetString() == u8"foo"); + CHECK(id.GetIdentifier().GetString() == "baz"); + CHECK(id.GetScope()[1].GetString() == "bar"); + CHECK(id.GetScope()[0].GetString() == "foo"); CHECK_FALSE(funcStat->ReturnsReference()); - CHECK(funcStat->GetIdentifier().GetString() == u8"foobar"); + CHECK(funcStat->GetIdentifier().GetString() == "foobar"); auto paramList = (const MalachScript::Parser::ParsedParamListStatement*)funcStat->GetParamList().get(); CHECK(paramList->GetParameters().size() == 2); @@ -204,9 +204,9 @@ PARSER_TEST("Parse scoped function with reference parameters without body.", CHECK_FALSE(par1.GetTypeStatement()->IsArray()); CHECK_FALSE(par1.GetTypeStatement()->IsHandle()); auto& par1TypeId = par1.GetTypeStatement()->GetScopedIdentifier(); - CHECK(par1TypeId.GetIdentifier().GetString() == u8"int"); + CHECK(par1TypeId.GetIdentifier().GetString() == "int"); CHECK(par1.GetTypeMod() == TypeMod::RefIn); - CHECK(par1.GetIdentifier().GetString() == u8"par1"); + CHECK(par1.GetIdentifier().GetString() == "par1"); CHECK(par1.GetDefaultExpression() == nullptr); auto& par2 = *paramList->GetParameters()[1]; @@ -214,9 +214,9 @@ PARSER_TEST("Parse scoped function with reference parameters without body.", CHECK_FALSE(par2.GetTypeStatement()->IsArray()); CHECK_FALSE(par2.GetTypeStatement()->IsHandle()); auto& par2TypeId = par2.GetTypeStatement()->GetScopedIdentifier(); - CHECK(par2TypeId.GetIdentifier().GetString() == u8"bool"); + CHECK(par2TypeId.GetIdentifier().GetString() == "bool"); CHECK(par2.GetTypeMod() == TypeMod::RefOut); - CHECK(par2.GetIdentifier().GetString() == u8"par2"); + CHECK(par2.GetIdentifier().GetString() == "par2"); CHECK(par2.GetDefaultExpression() == nullptr); CHECK_FALSE(funcStat->IsConst()); diff --git a/tests/ParserTests/ParserIntegrationTests.cpp b/tests/ParserTests/ParserIntegrationTests.cpp index be4e7f2..63c09a5 100644 --- a/tests/ParserTests/ParserIntegrationTests.cpp +++ b/tests/ParserTests/ParserIntegrationTests.cpp @@ -7,9 +7,9 @@ using namespace MalachScript; #define PARSE_TEST(name, scriptText, asserts) \ TEST_CASE(name) { \ Diagnostics::Logger diags; \ - auto lexer = Parser::Lexer(u8##name, u8##scriptText, &diags); \ + auto lexer = Parser::Lexer(name, scriptText, &diags); \ auto token = lexer.Lex(); \ - auto script = Parser::Parser::Parse(token, u8##name, &diags); \ + auto script = Parser::Parser::Parse(token, name, &diags); \ asserts; \ delete script; \ } @@ -42,7 +42,7 @@ PARSE_TEST("Parse class with virtprop", "class foobar { private bool foo { get; REQUIRE(firstClassStatement->GetKind() == Parser::ParsedStatementKind::VirtProp); auto virtPropStatement = dynamic_cast(firstClassStatement); REQUIRE(virtPropStatement->GetAccess() == MalachScript::AccessModifier::Private); - REQUIRE(virtPropStatement->GetIdentifier().GetString() == u8"foo"); + REQUIRE(virtPropStatement->GetIdentifier().GetString() == "foo"); REQUIRE(virtPropStatement->HasGet()); REQUIRE(virtPropStatement->HasSet()); REQUIRE(virtPropStatement->GetGetStatement() == nullptr); diff --git a/tests/ParserTests/VirtPropTests.cpp b/tests/ParserTests/VirtPropTests.cpp index fda3eea..4c8d4c4 100644 --- a/tests/ParserTests/VirtPropTests.cpp +++ b/tests/ParserTests/VirtPropTests.cpp @@ -13,7 +13,7 @@ using namespace MalachScript; vec[i]->SetNext(vec[i + 1]); \ } \ Diagnostics::Logger diags; \ - auto* script = Parser::Parser::Parse(vec.front(), u8"scriptname", &diags); \ + auto* script = Parser::Parser::Parse(vec.front(), "scriptname", &diags); \ REQUIRE(diags.GetMessages().empty()); \ asserts; \ delete vec[0]; \ @@ -25,10 +25,10 @@ using namespace MalachScript; PARSER_TEST( "Parse class foobar { bool foo { get; set; } }", PARSER_TEST_TOKENS(new Parser::LexTokenImpl(TextSpan(0, 0)), - new Parser::IdentifierToken(TextSpan(0, 0), u8"foobar"), + new Parser::IdentifierToken(TextSpan(0, 0), "foobar"), new Parser::LexTokenImpl(TextSpan(0, 0)), - new Parser::IdentifierToken(TextSpan(0, 0), u8"bool"), - new Parser::IdentifierToken(TextSpan(0, 0), u8"foo"), + new Parser::IdentifierToken(TextSpan(0, 0), "bool"), + new Parser::IdentifierToken(TextSpan(0, 0), "foo"), new Parser::LexTokenImpl(TextSpan(0, 0)), new Parser::LexTokenImpl(TextSpan(0, 0)), new Parser::LexTokenImpl(TextSpan(0, 0)), @@ -46,7 +46,7 @@ PARSER_TEST( auto virtPropStatement = dynamic_cast(firstClassStatement); REQUIRE(virtPropStatement->GetAccess() == MalachScript::AccessModifier::Public); - REQUIRE(virtPropStatement->GetIdentifier().GetString() == u8"foo"); + REQUIRE(virtPropStatement->GetIdentifier().GetString() == "foo"); REQUIRE(virtPropStatement->HasGet()); REQUIRE(virtPropStatement->HasSet()); REQUIRE_FALSE(virtPropStatement->IsGetConst()); @@ -58,10 +58,10 @@ PARSER_TEST( PARSER_TEST( "Parse class foobar { bool foo { get const; set const; } }", PARSER_TEST_TOKENS(new Parser::LexTokenImpl(TextSpan(0, 0)), - new Parser::IdentifierToken(TextSpan(0, 0), u8"foobar"), + new Parser::IdentifierToken(TextSpan(0, 0), "foobar"), new Parser::LexTokenImpl(TextSpan(0, 0)), - new Parser::IdentifierToken(TextSpan(0, 0), u8"bool"), - new Parser::IdentifierToken(TextSpan(0, 0), u8"foo"), + new Parser::IdentifierToken(TextSpan(0, 0), "bool"), + new Parser::IdentifierToken(TextSpan(0, 0), "foo"), new Parser::LexTokenImpl(TextSpan(0, 0)), new Parser::LexTokenImpl(TextSpan(0, 0)), new Parser::LexTokenImpl(TextSpan(0, 0)), @@ -81,7 +81,7 @@ PARSER_TEST( auto virtPropStatement = dynamic_cast(firstClassStatement); REQUIRE(virtPropStatement->GetAccess() == MalachScript::AccessModifier::Public); - REQUIRE(virtPropStatement->GetIdentifier().GetString() == u8"foo"); + REQUIRE(virtPropStatement->GetIdentifier().GetString() == "foo"); REQUIRE(virtPropStatement->HasGet()); REQUIRE(virtPropStatement->HasSet()); REQUIRE(virtPropStatement->IsGetConst()); @@ -93,10 +93,10 @@ PARSER_TEST( PARSER_TEST( "Parse class foobar { bool foo { get const override; set const override; } }", PARSER_TEST_TOKENS(new Parser::LexTokenImpl(TextSpan(0, 0)), - new Parser::IdentifierToken(TextSpan(0, 0), u8"foobar"), + new Parser::IdentifierToken(TextSpan(0, 0), "foobar"), new Parser::LexTokenImpl(TextSpan(0, 0)), - new Parser::IdentifierToken(TextSpan(0, 0), u8"bool"), - new Parser::IdentifierToken(TextSpan(0, 0), u8"foo"), + new Parser::IdentifierToken(TextSpan(0, 0), "bool"), + new Parser::IdentifierToken(TextSpan(0, 0), "foo"), new Parser::LexTokenImpl(TextSpan(0, 0)), new Parser::LexTokenImpl(TextSpan(0, 0)), new Parser::LexTokenImpl(TextSpan(0, 0)), @@ -118,7 +118,7 @@ PARSER_TEST( auto virtPropStatement = dynamic_cast(firstClassStatement); REQUIRE(virtPropStatement->GetAccess() == MalachScript::AccessModifier::Public); - REQUIRE(virtPropStatement->GetIdentifier().GetString() == u8"foo"); + REQUIRE(virtPropStatement->GetIdentifier().GetString() == "foo"); REQUIRE(virtPropStatement->HasGet()); REQUIRE(virtPropStatement->HasSet()); REQUIRE(virtPropStatement->IsGetConst()); @@ -145,48 +145,47 @@ PARSER_TEST( PARSER_TEST( "Virtprops with bodies", - PARSER_TEST_TOKENS(new Parser::LexTokenImpl(TextSpan(0, 0)), - new Parser::IdentifierToken(TextSpan(0, 0), u8"foobar"), - new Parser::LexTokenImpl(TextSpan(0, 0)), - new Parser::IdentifierToken(TextSpan(0, 0), u8"int"), - new Parser::IdentifierToken(TextSpan(0, 0), u8"i"), - new Parser::LexTokenImpl(TextSpan(0, 0)), + PARSER_TEST_TOKENS( + new Parser::LexTokenImpl(TextSpan(0, 0)), + new Parser::IdentifierToken(TextSpan(0, 0), "foobar"), + new Parser::LexTokenImpl(TextSpan(0, 0)), + new Parser::IdentifierToken(TextSpan(0, 0), "int"), new Parser::IdentifierToken(TextSpan(0, 0), "i"), + new Parser::LexTokenImpl(TextSpan(0, 0)), - new Parser::IdentifierToken(TextSpan(0, 0), u8"bool"), - new Parser::IdentifierToken(TextSpan(0, 0), u8"foo"), - new Parser::LexTokenImpl(TextSpan(0, 0)), - new Parser::LexTokenImpl(TextSpan(0, 0)), - new Parser::LexTokenImpl(TextSpan(0, 0)), - new Parser::LexTokenImpl(TextSpan(0, 0)), - new Parser::LexTokenImpl(TextSpan(0, 0)), - new Parser::LexTokenImpl(TextSpan(0, 0)), - new Parser::LexTokenImpl(TextSpan(0, 0)), - new Parser::LexTokenImpl(TextSpan(0, 0)), - new Parser::LexTokenImpl(TextSpan(0, 0)), - new Parser::LexTokenImpl(TextSpan(0, 0)), - new Parser::LexTokenImpl(TextSpan(0, 0)), + new Parser::IdentifierToken(TextSpan(0, 0), "bool"), new Parser::IdentifierToken(TextSpan(0, 0), "foo"), + new Parser::LexTokenImpl(TextSpan(0, 0)), + new Parser::LexTokenImpl(TextSpan(0, 0)), + new Parser::LexTokenImpl(TextSpan(0, 0)), + new Parser::LexTokenImpl(TextSpan(0, 0)), + new Parser::LexTokenImpl(TextSpan(0, 0)), + new Parser::LexTokenImpl(TextSpan(0, 0)), + new Parser::LexTokenImpl(TextSpan(0, 0)), + new Parser::LexTokenImpl(TextSpan(0, 0)), + new Parser::LexTokenImpl(TextSpan(0, 0)), + new Parser::LexTokenImpl(TextSpan(0, 0)), + new Parser::LexTokenImpl(TextSpan(0, 0)), new Parser::LexTokenImpl(TextSpan(0, 0)), new Parser::LexTokenImpl(TextSpan(0, 0)), - new Parser::LexTokenImpl(TextSpan(0, 0)), + new Parser::LexTokenImpl(TextSpan(0, 0)), - new Parser::LexTokenImpl(TextSpan(0, 0)), - new Parser::LexTokenImpl(TextSpan(0, 0)), - new Parser::LexTokenImpl(TextSpan(0, 0)), - new Parser::LexTokenImpl(TextSpan(0, 0)), - new Parser::IntegerLiteral(TextSpan(0, 0), 1), - new Parser::LexTokenImpl(TextSpan(0, 0)), - new Parser::IntegerLiteral(TextSpan(0, 0), 1), - new Parser::LexTokenImpl(TextSpan(0, 0)), - new Parser::IdentifierToken(TextSpan(0, 0), u8"i"), - new Parser::LexTokenImpl(TextSpan(0, 0)), - new Parser::LexTokenImpl(TextSpan(0, 0)), - new Parser::IdentifierToken(TextSpan(0, 0), u8"i"), - new Parser::LexTokenImpl(TextSpan(0, 0)), - new Parser::LexTokenImpl(TextSpan(0, 0)), + new Parser::LexTokenImpl(TextSpan(0, 0)), + new Parser::LexTokenImpl(TextSpan(0, 0)), + new Parser::LexTokenImpl(TextSpan(0, 0)), + new Parser::LexTokenImpl(TextSpan(0, 0)), + new Parser::IntegerLiteral(TextSpan(0, 0), 1), + new Parser::LexTokenImpl(TextSpan(0, 0)), + new Parser::IntegerLiteral(TextSpan(0, 0), 1), + new Parser::LexTokenImpl(TextSpan(0, 0)), + new Parser::IdentifierToken(TextSpan(0, 0), "i"), + new Parser::LexTokenImpl(TextSpan(0, 0)), + new Parser::LexTokenImpl(TextSpan(0, 0)), + new Parser::IdentifierToken(TextSpan(0, 0), "i"), + new Parser::LexTokenImpl(TextSpan(0, 0)), + new Parser::LexTokenImpl(TextSpan(0, 0)), - new Parser::LexTokenImpl(TextSpan(0, 0)), - new Parser::LexTokenImpl(TextSpan(0, 0)), - new Parser::LexTokenImpl(TextSpan(0, 0))), + new Parser::LexTokenImpl(TextSpan(0, 0)), + new Parser::LexTokenImpl(TextSpan(0, 0)), + new Parser::LexTokenImpl(TextSpan(0, 0))), { REQUIRE(script->GetStatements().size() == 1); auto firstStatement = script->GetStatements()[0].get(); @@ -197,7 +196,7 @@ PARSER_TEST( auto virtPropStatement = dynamic_cast(firstClassStatement); REQUIRE(virtPropStatement->GetAccess() == MalachScript::AccessModifier::Public); - REQUIRE(virtPropStatement->GetIdentifier().GetString() == u8"foo"); + REQUIRE(virtPropStatement->GetIdentifier().GetString() == "foo"); REQUIRE(virtPropStatement->HasGet()); REQUIRE(virtPropStatement->HasSet()); REQUIRE_FALSE(virtPropStatement->IsGetConst());