From d2d5f1e34835fa6df65e4bcea2671ec3def8336b Mon Sep 17 00:00:00 2001 From: ax-6 Date: Sun, 25 Feb 2024 21:10:47 +0800 Subject: [PATCH] Complete some project content. --- CMakeLists.txt | 3 +- aq/CMakeLists.txt | 13 +++ aq/aq.cc | 11 +-- aq/aq.h | 4 +- compiler/CMakeLists.txt | 5 ++ compiler/ast/decl.h | 19 +++- compiler/compiler.cc | 5 +- compiler/compiler.h | 2 +- compiler/lexer/CMakeLists.txt | 2 +- compiler/lexer/lexer.cc | 6 +- compiler/lexer/lexer.h | 1 + compiler/lexer/token_map.cc | 146 +++++++++++++++++++++++++++++++ compiler/lexer/token_map.h | 32 +++++++ compiler/test.cc | 10 --- compiler/token/keyword.h | 78 +++++++++++++++++ compiler/token/operator.h | 74 ++++++++++++++++ compiler/token/token.cc | 133 ---------------------------- compiler/token/token.h | 159 +++------------------------------- 18 files changed, 396 insertions(+), 307 deletions(-) create mode 100644 aq/CMakeLists.txt create mode 100644 compiler/lexer/token_map.cc create mode 100644 compiler/lexer/token_map.h delete mode 100644 compiler/test.cc create mode 100644 compiler/token/keyword.h create mode 100644 compiler/token/operator.h diff --git a/CMakeLists.txt b/CMakeLists.txt index e3ca099..9ed51d6 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -8,4 +8,5 @@ project(AQ CXX) include_directories(${PROJECT_SOURCE_DIR}) add_subdirectory(debugger) -add_subdirectory(compiler) \ No newline at end of file +add_subdirectory(compiler) +add_subdirectory(aq) \ No newline at end of file diff --git a/aq/CMakeLists.txt b/aq/CMakeLists.txt new file mode 100644 index 0000000..47a4067 --- /dev/null +++ b/aq/CMakeLists.txt @@ -0,0 +1,13 @@ +# Copyright 2024 AQ authors, All Rights Reserved. +# This program is licensed under the AQ License. You can find the AQ license in +# the root directory. + +cmake_minimum_required(VERSION 3.10) + +include_directories(${PROJECT_SOURCE_DIR}) + +set(SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/aq.cc) + +add_executable(aq_test ${SOURCES}) + +target_link_libraries(aq_test PRIVATE AqCompiler) \ No newline at end of file diff --git a/aq/aq.cc b/aq/aq.cc index e30dfef..bd7ec52 100644 --- a/aq/aq.cc +++ b/aq/aq.cc @@ -4,15 +4,16 @@ #include "aq/aq.h" -#include "compiler/lexer/lexer.h" -#include "compiler/lexer/token.h" +#include "compiler/compiler.h" namespace Aq { +int Start(int argc, char *argv[]) { + // TODO(Aq::Start): For testing purposes only, modifications will be made after other + // components have been developed. + Compiler compiler(argv[1]); -int main(int argc, char *argv[]) { - // TODO return 0; } } // namespace Aq -int main(int argc, char *argv[]) { return Aq::main(argc, argv); } \ No newline at end of file +int main(int argc, char *argv[]) { return Aq::Start(argc, argv); } \ No newline at end of file diff --git a/aq/aq.h b/aq/aq.h index 37235a0..e0366dd 100644 --- a/aq/aq.h +++ b/aq/aq.h @@ -1,7 +1,7 @@ #ifndef AQ_AQ_H_ #define AQ_AQ_H_ -namespace Aq{ -extern int main(); +namespace Aq { +extern int Start(int argc, char *argv[]); } #endif \ No newline at end of file diff --git a/compiler/CMakeLists.txt b/compiler/CMakeLists.txt index f08b1f7..be1f37a 100644 --- a/compiler/CMakeLists.txt +++ b/compiler/CMakeLists.txt @@ -8,10 +8,15 @@ include_directories(${PROJECT_SOURCE_DIR}) set(SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/compiler.cc) +add_subdirectory(token) add_subdirectory(lexer) +add_subdirectory(ast) +add_subdirectory(parser) add_library(AqCompiler STATIC ${SOURCES}) target_link_libraries(AqCompiler PRIVATE AqCompilerToken) target_link_libraries(AqCompiler PRIVATE AqCompilerLexer) +target_link_libraries(AqCompiler PRIVATE AqCompilerAst) +target_link_libraries(AqCompiler PRIVATE AqCompilerParser) target_link_libraries(AqCompiler PRIVATE AqDebugger) \ No newline at end of file diff --git a/compiler/ast/decl.h b/compiler/ast/decl.h index 555cfb9..80530d5 100644 --- a/compiler/ast/decl.h +++ b/compiler/ast/decl.h @@ -9,6 +9,23 @@ namespace Aq { // TODO: Decl AST -} +class Compiler::FuncDecl { + public: + FuncDecl(); + ~FuncDecl(); + + FuncDecl(const FuncDecl&) = default; + FuncDecl(FuncDecl&&) noexcept = default; + FuncDecl& operator=(const FuncDecl&) = default; + FuncDecl& operator=(FuncDecl&&) noexcept = default; + + private: + // Type* type; + // std::string name; + // std::vector args; + // Stmt* body; + // TODO: Add more. +}; +} // namespace Aq #endif \ No newline at end of file diff --git a/compiler/compiler.cc b/compiler/compiler.cc index 5c020d7..7c9032c 100644 --- a/compiler/compiler.cc +++ b/compiler/compiler.cc @@ -11,13 +11,14 @@ #include #include -#include "debugger/debugger.h" #include "compiler/lexer/lexer.h" #include "compiler/token/token.h" +#include "debugger/debugger.h" namespace Aq { Compiler::Compiler(const char* filename) { - // TODO: Waiting for improvements. + // TODO(Aq::Compiler): For testing purposes only, modifications will be made + // after other components have been developed. auto start = std::chrono::high_resolution_clock::now(); std::ifstream file; file.open(filename); diff --git a/compiler/compiler.h b/compiler/compiler.h index a6119ac..313d9aa 100644 --- a/compiler/compiler.h +++ b/compiler/compiler.h @@ -23,7 +23,7 @@ class Compiler { class Parser; - class Decl; + class FuncDecl; class Expr; class Stmt; class Type; diff --git a/compiler/lexer/CMakeLists.txt b/compiler/lexer/CMakeLists.txt index 46988ce..d44ae5e 100644 --- a/compiler/lexer/CMakeLists.txt +++ b/compiler/lexer/CMakeLists.txt @@ -6,7 +6,7 @@ cmake_minimum_required(VERSION 3.10) include_directories(${PROJECT_SOURCE_DIR}) -set(SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/lexer.cc) +set(SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/lexer.cc ${CMAKE_CURRENT_SOURCE_DIR}/token_map.cc) add_library(AqCompilerLexer STATIC ${SOURCES}) diff --git a/compiler/lexer/lexer.cc b/compiler/lexer/lexer.cc index 7f075a9..d150c60 100644 --- a/compiler/lexer/lexer.cc +++ b/compiler/lexer/lexer.cc @@ -8,6 +8,8 @@ #include "compiler/compiler.h" #include "compiler/token/token.h" +#include "compiler/token/keyword.h" +#include "compiler/token/operator.h" #include "debugger/debugger.h" namespace Aq { @@ -364,7 +366,7 @@ int Compiler::Lexer::LexToken(Token& return_token) { case Token::Type::IDENTIFIER: return_token.value.keyword = token_map_.GetKeywordValue(std::string(location, length)); - if (return_token.value.keyword == Token::KeywordType::NONE) { + if (return_token.value.keyword == Token::Keyword::NONE) { return_token.value.identifier = value; break; } @@ -382,7 +384,7 @@ int Compiler::Lexer::LexToken(Token& return_token) { case Token::Type::OPERATOR: return_token.value._operator = token_map_.GetOperatorValue(std::string(location, length)); - while (return_token.value._operator == Token::OperatorType::NONE && + while (return_token.value._operator == Token::Operator::NONE && length > 1) { length--; buffer_ptr_--; diff --git a/compiler/lexer/lexer.h b/compiler/lexer/lexer.h index 96189c2..4db06d9 100644 --- a/compiler/lexer/lexer.h +++ b/compiler/lexer/lexer.h @@ -9,6 +9,7 @@ #include "compiler/compiler.h" #include "compiler/token/token.h" +#include "compiler/lexer/token_map.h" namespace Aq { class Compiler::Lexer { diff --git a/compiler/lexer/token_map.cc b/compiler/lexer/token_map.cc new file mode 100644 index 0000000..a4555b9 --- /dev/null +++ b/compiler/lexer/token_map.cc @@ -0,0 +1,146 @@ +// Copyright 2024 AQ authors, All Rights Reserved. +// This program is licensed under the AQ License. You can find the AQ license in +// the root directory. + +#include "compiler/lexer/token_map.h" + +#include "compiler/compiler.h" +#include "compiler/token/token.h" +#include "compiler/token/keyword.h" +#include "compiler/token/operator.h" +#include "compiler/lexer/lex_map.h" +#include "debugger/debugger.h" + +namespace Aq { +Compiler::TokenMap::TokenMap() { + keyword_map_.Insert("auto", Token::Keyword::Auto); + keyword_map_.Insert("and", Token::Keyword::And); + keyword_map_.Insert("bitand", Token::Keyword::Bitand); + keyword_map_.Insert("bitor", Token::Keyword::Bitor); + keyword_map_.Insert("bool", Token::Keyword::Bool); + keyword_map_.Insert("break", Token::Keyword::Break); + keyword_map_.Insert("case", Token::Keyword::Case); + keyword_map_.Insert("catch", Token::Keyword::Catch); + keyword_map_.Insert("char", Token::Keyword::Char); + keyword_map_.Insert("class", Token::Keyword::Class); + keyword_map_.Insert("const", Token::Keyword::Const); + keyword_map_.Insert("continue", Token::Keyword::Continue); + keyword_map_.Insert("default", Token::Keyword::Default); + keyword_map_.Insert("do", Token::Keyword::Do); + keyword_map_.Insert("double", Token::Keyword::Double); + keyword_map_.Insert("else", Token::Keyword::Else); + keyword_map_.Insert("enum", Token::Keyword::Enum); + keyword_map_.Insert("export", Token::Keyword::Export); + keyword_map_.Insert("extern", Token::Keyword::Extern); + keyword_map_.Insert("false", Token::Keyword::False); + keyword_map_.Insert("float", Token::Keyword::Float); + keyword_map_.Insert("for", Token::Keyword::For); + keyword_map_.Insert("friend", Token::Keyword::Friend); + keyword_map_.Insert("goto", Token::Keyword::Goto); + keyword_map_.Insert("import", Token::Keyword::Import); + keyword_map_.Insert("inline", Token::Keyword::Inline); + keyword_map_.Insert("int", Token::Keyword::Int); + keyword_map_.Insert("long", Token::Keyword::Long); + keyword_map_.Insert("namespace", Token::Keyword::Namespace); + keyword_map_.Insert("new", Token::Keyword::New); + keyword_map_.Insert("not", Token::Keyword::Not); + keyword_map_.Insert("number", Token::Keyword::Number); + keyword_map_.Insert("operator", Token::Keyword::Operator); + keyword_map_.Insert("or", Token::Keyword::Or); + keyword_map_.Insert("private", Token::Keyword::Private); + keyword_map_.Insert("protected", Token::Keyword::Protected); + keyword_map_.Insert("public", Token::Keyword::Public); + keyword_map_.Insert("return", Token::Keyword::Return); + keyword_map_.Insert("short", Token::Keyword::Short); + keyword_map_.Insert("signed", Token::Keyword::Signed); + keyword_map_.Insert("sizeof", Token::Keyword::Sizeof); + keyword_map_.Insert("static", Token::Keyword::Static); + keyword_map_.Insert("string", Token::Keyword::String); + keyword_map_.Insert("struct", Token::Keyword::Struct); + keyword_map_.Insert("switch", Token::Keyword::Switch); + keyword_map_.Insert("template", Token::Keyword::Template); + keyword_map_.Insert("this", Token::Keyword::This); + keyword_map_.Insert("thread", Token::Keyword::Thread); + keyword_map_.Insert("true", Token::Keyword::True); + keyword_map_.Insert("try", Token::Keyword::Try); + keyword_map_.Insert("typedef", Token::Keyword::Typedef); + keyword_map_.Insert("typeid", Token::Keyword::Typeid); + keyword_map_.Insert("typename", Token::Keyword::Typename); + keyword_map_.Insert("union", Token::Keyword::Union); + keyword_map_.Insert("unsigned", Token::Keyword::Unsigned); + keyword_map_.Insert("using", Token::Keyword::Using); + keyword_map_.Insert("virtual", Token::Keyword::Virtual); + keyword_map_.Insert("void", Token::Keyword::Void); + keyword_map_.Insert("wchar_t", Token::Keyword::Wchar_t); + keyword_map_.Insert("while", Token::Keyword::While); + keyword_map_.Insert("xor", Token::Keyword::Xor); + + operator_map_.Insert("[", Token::Operator::l_square); + operator_map_.Insert("]", Token::Operator::r_square); + operator_map_.Insert("(", Token::Operator::l_paren); + operator_map_.Insert(")", Token::Operator::r_paren); + operator_map_.Insert("{", Token::Operator::l_brace); + operator_map_.Insert("}", Token::Operator::r_brace); + operator_map_.Insert(".", Token::Operator::period); + operator_map_.Insert("...", Token::Operator::ellipsis); + operator_map_.Insert("&", Token::Operator::amp); + operator_map_.Insert("&&", Token::Operator::ampamp); + operator_map_.Insert("&=", Token::Operator::ampequal); + operator_map_.Insert("*", Token::Operator::star); + operator_map_.Insert("*=", Token::Operator::starequal); + operator_map_.Insert("+", Token::Operator::plus); + operator_map_.Insert("++", Token::Operator::plusplus); + operator_map_.Insert("+=", Token::Operator::plusequal); + operator_map_.Insert("-", Token::Operator::minus); + operator_map_.Insert("->", Token::Operator::arrow); + operator_map_.Insert("--", Token::Operator::minusminus); + operator_map_.Insert("-=", Token::Operator::minusequal); + operator_map_.Insert("~", Token::Operator::tilde); + operator_map_.Insert("!", Token::Operator::exclaim); + operator_map_.Insert("!=", Token::Operator::exclaimequal); + operator_map_.Insert("/", Token::Operator::slash); + operator_map_.Insert("/=", Token::Operator::slashequal); + operator_map_.Insert("%", Token::Operator::percent); + operator_map_.Insert("%=", Token::Operator::percentequal); + operator_map_.Insert("<", Token::Operator::less); + operator_map_.Insert("<<", Token::Operator::lessless); + operator_map_.Insert("<=", Token::Operator::lessequal); + operator_map_.Insert("<<=", Token::Operator::lesslessequal); + operator_map_.Insert("<=>", Token::Operator::spaceship); + operator_map_.Insert(">", Token::Operator::greater); + operator_map_.Insert(">>", Token::Operator::greatergreater); + operator_map_.Insert(">=", Token::Operator::greaterequal); + operator_map_.Insert(">>=", Token::Operator::greatergreaterequal); + operator_map_.Insert("^", Token::Operator::caret); + operator_map_.Insert("^=", Token::Operator::caretequal); + operator_map_.Insert("|", Token::Operator::pipe); + operator_map_.Insert("||", Token::Operator::pipepipe); + operator_map_.Insert("|=", Token::Operator::pipeequal); + operator_map_.Insert("?", Token::Operator::question); + operator_map_.Insert(":", Token::Operator::colon); + operator_map_.Insert(";", Token::Operator::semi); + operator_map_.Insert("=", Token::Operator::equal); + operator_map_.Insert("==", Token::Operator::equalequal); + operator_map_.Insert(",", Token::Operator::comma); + operator_map_.Insert("#", Token::Operator::hash); + operator_map_.Insert("##", Token::Operator::hashhash); + operator_map_.Insert("#@", Token::Operator::hashat); + operator_map_.Insert(".*", Token::Operator::periodstar); + operator_map_.Insert("->*", Token::Operator::arrowstar); + operator_map_.Insert("::", Token::Operator::coloncolon); + operator_map_.Insert("@", Token::Operator::at); + operator_map_.Insert("<<<", Token::Operator::lesslessless); + operator_map_.Insert(">>>", Token::Operator::greatergreatergreater); + operator_map_.Insert("^^", Token::Operator::caretcaret); +} +Compiler::TokenMap::~TokenMap() = default; + +Compiler::Token::Keyword Compiler::TokenMap::GetKeywordValue( + std::string keyword) { + return keyword_map_.Find(keyword); +} +Compiler::Token::Operator Compiler::TokenMap::GetOperatorValue( + std::string _operator) { + return operator_map_.Find(_operator); +} +} // namespace Aq \ No newline at end of file diff --git a/compiler/lexer/token_map.h b/compiler/lexer/token_map.h new file mode 100644 index 0000000..434fec6 --- /dev/null +++ b/compiler/lexer/token_map.h @@ -0,0 +1,32 @@ +// Copyright 2024 AQ authors, All Rights Reserved. +// This program is licensed under the AQ License. You can find the AQ license in +// the root directory. + +#ifndef AQ_COMPILER_LEXER_TOKEN_MAP_H_ +#define AQ_COMPILER_LEXER_TOKEN_MAP_H_ + +#include "compiler/compiler.h" +#include "compiler/token/token.h" +#include "compiler/lexer/lex_map.h" + +namespace Aq { +class Compiler::TokenMap { + public: + TokenMap(); + ~TokenMap(); + + Token::Keyword GetKeywordValue(std::string keyword); + Token::Operator GetOperatorValue(std::string _operator); + + TokenMap(const TokenMap&) = default; + TokenMap(TokenMap&&) noexcept = default; + TokenMap& operator=(const TokenMap&) = default; + TokenMap& operator=(TokenMap&&) noexcept = default; + + private: + LexMap keyword_map_; + LexMap operator_map_; +}; +} // namespace Aq + +#endif \ No newline at end of file diff --git a/compiler/test.cc b/compiler/test.cc deleted file mode 100644 index 104688f..0000000 --- a/compiler/test.cc +++ /dev/null @@ -1,10 +0,0 @@ -// Copyright 2024 AQ authors, All Rights Reserved. -// This program is licensed under the AQ License. You can find the AQ license in -// the root directory. - -#include "compiler/compiler.h" - -int main(int argc, char* argv[]) { - Aq::Compiler compiler(argv[1]); - return 0; -} diff --git a/compiler/token/keyword.h b/compiler/token/keyword.h new file mode 100644 index 0000000..8637ddc --- /dev/null +++ b/compiler/token/keyword.h @@ -0,0 +1,78 @@ +// Copyright 2024 AQ authors, All Rights Reserved. +// This program is licensed under the AQ License. You can find the AQ license in +// the root directory. + +#ifndef AQ_COMPILER_TOKEN_KEYWORD_H_ +#define AQ_COMPILER_TOKEN_KEYWORD_H_ + +#include "compiler/compiler.h" +#include "compiler/token/token.h" + +namespace Aq { +enum class Compiler::Token::Keyword { + NONE = 0, + Auto, + And, + Bitand, + Bitor, + Bool, + Break, + Case, + Catch, + Char, + Class, + Const, + Continue, + Default, + Do, + Double, + Else, + Enum, + Export, + Extern, + False, + Float, + For, + Friend, + Goto, + Import, + Inline, + Int, + Long, + Namespace, + New, + Not, + Number, + Operator, + Or, + Private, + Protected, + Public, + Return, + Short, + Signed, + Sizeof, + Static, + String, + Struct, + Switch, + Template, + This, + Thread, + True, + Try, + Typedef, + Typeid, + Typename, + Union, + Unsigned, + Using, + Virtual, + Void, + Wchar_t, + While, + Xor, +}; +} + +#endif \ No newline at end of file diff --git a/compiler/token/operator.h b/compiler/token/operator.h new file mode 100644 index 0000000..0dd9449 --- /dev/null +++ b/compiler/token/operator.h @@ -0,0 +1,74 @@ +// Copyright 2024 AQ authors, All Rights Reserved. +// This program is licensed under the AQ License. You can find the AQ license in +// the root directory. + +#ifndef AQ_COMPILER_TOKEN_OPERATOR_H_ +#define AQ_COMPILER_TOKEN_OPERATOR_H_ + +#include "compiler/compiler.h" +#include "compiler/token/token.h" + +namespace Aq{ +enum class Compiler::Token::Operator { + NONE = 0, + l_square, + r_square, + l_paren, + r_paren, + l_brace, + r_brace, + period, + ellipsis, + amp, + ampamp, + ampequal, + star, + starequal, + plus, + plusplus, + plusequal, + minus, + arrow, + minusminus, + minusequal, + tilde, + exclaim, + exclaimequal, + slash, + slashequal, + percent, + percentequal, + less, + lessless, + lessequal, + lesslessequal, + spaceship, + greater, + greatergreater, + greaterequal, + greatergreaterequal, + caret, + caretequal, + pipe, + pipepipe, + pipeequal, + question, + colon, + semi, + equal, + equalequal, + comma, + hash, + hashhash, + hashat, + periodstar, + arrowstar, + coloncolon, + at, + lesslessless, + greatergreatergreater, + caretcaret, +}; +} + +#endif \ No newline at end of file diff --git a/compiler/token/token.cc b/compiler/token/token.cc index a7aa043..d888ab1 100644 --- a/compiler/token/token.cc +++ b/compiler/token/token.cc @@ -5,142 +5,9 @@ #include "compiler/token/token.h" #include "compiler/compiler.h" -#include "compiler/lexer/lex_map.h" #include "debugger/debugger.h" namespace Aq { Compiler::Token::Token() = default; Compiler::Token::~Token() = default; - -Compiler::TokenMap::TokenMap() { - keyword_map.Insert("auto", Token::KeywordType::Auto); - keyword_map.Insert("and", Token::KeywordType::And); - keyword_map.Insert("bitand", Token::KeywordType::Bitand); - keyword_map.Insert("bitor", Token::KeywordType::Bitor); - keyword_map.Insert("bool", Token::KeywordType::Bool); - keyword_map.Insert("break", Token::KeywordType::Break); - keyword_map.Insert("case", Token::KeywordType::Case); - keyword_map.Insert("catch", Token::KeywordType::Catch); - keyword_map.Insert("char", Token::KeywordType::Char); - keyword_map.Insert("class", Token::KeywordType::Class); - keyword_map.Insert("const", Token::KeywordType::Const); - keyword_map.Insert("continue", Token::KeywordType::Continue); - keyword_map.Insert("default", Token::KeywordType::Default); - keyword_map.Insert("do", Token::KeywordType::Do); - keyword_map.Insert("double", Token::KeywordType::Double); - keyword_map.Insert("else", Token::KeywordType::Else); - keyword_map.Insert("enum", Token::KeywordType::Enum); - keyword_map.Insert("export", Token::KeywordType::Export); - keyword_map.Insert("extern", Token::KeywordType::Extern); - keyword_map.Insert("false", Token::KeywordType::False); - keyword_map.Insert("float", Token::KeywordType::Float); - keyword_map.Insert("for", Token::KeywordType::For); - keyword_map.Insert("friend", Token::KeywordType::Friend); - keyword_map.Insert("goto", Token::KeywordType::Goto); - keyword_map.Insert("import", Token::KeywordType::Import); - keyword_map.Insert("inline", Token::KeywordType::Inline); - keyword_map.Insert("int", Token::KeywordType::Int); - keyword_map.Insert("long", Token::KeywordType::Long); - keyword_map.Insert("namespace", Token::KeywordType::Namespace); - keyword_map.Insert("new", Token::KeywordType::New); - keyword_map.Insert("not", Token::KeywordType::Not); - keyword_map.Insert("number", Token::KeywordType::Number); - keyword_map.Insert("operator", Token::KeywordType::Operator); - keyword_map.Insert("or", Token::KeywordType::Or); - keyword_map.Insert("private", Token::KeywordType::Private); - keyword_map.Insert("protected", Token::KeywordType::Protected); - keyword_map.Insert("public", Token::KeywordType::Public); - keyword_map.Insert("return", Token::KeywordType::Return); - keyword_map.Insert("short", Token::KeywordType::Short); - keyword_map.Insert("signed", Token::KeywordType::Signed); - keyword_map.Insert("sizeof", Token::KeywordType::Sizeof); - keyword_map.Insert("static", Token::KeywordType::Static); - keyword_map.Insert("string", Token::KeywordType::String); - keyword_map.Insert("struct", Token::KeywordType::Struct); - keyword_map.Insert("switch", Token::KeywordType::Switch); - keyword_map.Insert("template", Token::KeywordType::Template); - keyword_map.Insert("this", Token::KeywordType::This); - keyword_map.Insert("thread", Token::KeywordType::Thread); - keyword_map.Insert("true", Token::KeywordType::True); - keyword_map.Insert("try", Token::KeywordType::Try); - keyword_map.Insert("typedef", Token::KeywordType::Typedef); - keyword_map.Insert("typeid", Token::KeywordType::Typeid); - keyword_map.Insert("typename", Token::KeywordType::Typename); - keyword_map.Insert("union", Token::KeywordType::Union); - keyword_map.Insert("unsigned", Token::KeywordType::Unsigned); - keyword_map.Insert("using", Token::KeywordType::Using); - keyword_map.Insert("virtual", Token::KeywordType::Virtual); - keyword_map.Insert("void", Token::KeywordType::Void); - keyword_map.Insert("wchar_t", Token::KeywordType::Wchar_t); - keyword_map.Insert("while", Token::KeywordType::While); - keyword_map.Insert("xor", Token::KeywordType::Xor); - - operator_map.Insert("[", Token::OperatorType::l_square); - operator_map.Insert("]", Token::OperatorType::r_square); - operator_map.Insert("(", Token::OperatorType::l_paren); - operator_map.Insert(")", Token::OperatorType::r_paren); - operator_map.Insert("{", Token::OperatorType::l_brace); - operator_map.Insert("}", Token::OperatorType::r_brace); - operator_map.Insert(".", Token::OperatorType::period); - operator_map.Insert("...", Token::OperatorType::ellipsis); - operator_map.Insert("&", Token::OperatorType::amp); - operator_map.Insert("&&", Token::OperatorType::ampamp); - operator_map.Insert("&=", Token::OperatorType::ampequal); - operator_map.Insert("*", Token::OperatorType::star); - operator_map.Insert("*=", Token::OperatorType::starequal); - operator_map.Insert("+", Token::OperatorType::plus); - operator_map.Insert("++", Token::OperatorType::plusplus); - operator_map.Insert("+=", Token::OperatorType::plusequal); - operator_map.Insert("-", Token::OperatorType::minus); - operator_map.Insert("->", Token::OperatorType::arrow); - operator_map.Insert("--", Token::OperatorType::minusminus); - operator_map.Insert("-=", Token::OperatorType::minusequal); - operator_map.Insert("~", Token::OperatorType::tilde); - operator_map.Insert("!", Token::OperatorType::exclaim); - operator_map.Insert("!=", Token::OperatorType::exclaimequal); - operator_map.Insert("/", Token::OperatorType::slash); - operator_map.Insert("/=", Token::OperatorType::slashequal); - operator_map.Insert("%", Token::OperatorType::percent); - operator_map.Insert("%=", Token::OperatorType::percentequal); - operator_map.Insert("<", Token::OperatorType::less); - operator_map.Insert("<<", Token::OperatorType::lessless); - operator_map.Insert("<=", Token::OperatorType::lessequal); - operator_map.Insert("<<=", Token::OperatorType::lesslessequal); - operator_map.Insert("<=>", Token::OperatorType::spaceship); - operator_map.Insert(">", Token::OperatorType::greater); - operator_map.Insert(">>", Token::OperatorType::greatergreater); - operator_map.Insert(">=", Token::OperatorType::greaterequal); - operator_map.Insert(">>=", Token::OperatorType::greatergreaterequal); - operator_map.Insert("^", Token::OperatorType::caret); - operator_map.Insert("^=", Token::OperatorType::caretequal); - operator_map.Insert("|", Token::OperatorType::pipe); - operator_map.Insert("||", Token::OperatorType::pipepipe); - operator_map.Insert("|=", Token::OperatorType::pipeequal); - operator_map.Insert("?", Token::OperatorType::question); - operator_map.Insert(":", Token::OperatorType::colon); - operator_map.Insert(";", Token::OperatorType::semi); - operator_map.Insert("=", Token::OperatorType::equal); - operator_map.Insert("==", Token::OperatorType::equalequal); - operator_map.Insert(",", Token::OperatorType::comma); - operator_map.Insert("#", Token::OperatorType::hash); - operator_map.Insert("##", Token::OperatorType::hashhash); - operator_map.Insert("#@", Token::OperatorType::hashat); - operator_map.Insert(".*", Token::OperatorType::periodstar); - operator_map.Insert("->*", Token::OperatorType::arrowstar); - operator_map.Insert("::", Token::OperatorType::coloncolon); - operator_map.Insert("@", Token::OperatorType::at); - operator_map.Insert("<<<", Token::OperatorType::lesslessless); - operator_map.Insert(">>>", Token::OperatorType::greatergreatergreater); - operator_map.Insert("^^", Token::OperatorType::caretcaret); -} -Compiler::TokenMap::~TokenMap() = default; - -Compiler::Token::KeywordType Compiler::TokenMap::GetKeywordValue( - std::string keyword) { - return keyword_map.Find(keyword); -} -Compiler::Token::OperatorType Compiler::TokenMap::GetOperatorValue( - std::string _operator) { - return operator_map.Find(_operator); -} } // namespace Aq \ No newline at end of file diff --git a/compiler/token/token.h b/compiler/token/token.h index 1280050..1ad2f98 100644 --- a/compiler/token/token.h +++ b/compiler/token/token.h @@ -5,11 +5,13 @@ #ifndef AQ_COMPILER_TOKEN_TOKEN_H_ #define AQ_COMPILER_TOKEN_TOKEN_H_ +#include + #include "compiler/compiler.h" -#include "compiler/lexer/lex_map.h" namespace Aq { -struct Compiler::Token { +class Compiler::Token { + public: enum class Type { NONE, START, @@ -21,145 +23,22 @@ struct Compiler::Token { STRING, COMMENT }; - enum class KeywordType { - NONE = 0, - Auto, - And, - Bitand, - Bitor, - Bool, - Break, - Case, - Catch, - Char, - Class, - Const, - Continue, - Default, - Do, - Double, - Else, - Enum, - Export, - Extern, - False, - Float, - For, - Friend, - Goto, - Import, - Inline, - Int, - Long, - Namespace, - New, - Not, - Number, - Operator, - Or, - Private, - Protected, - Public, - Return, - Short, - Signed, - Sizeof, - Static, - String, - Struct, - Switch, - Template, - This, - Thread, - True, - Try, - Typedef, - Typeid, - Typename, - Union, - Unsigned, - Using, - Virtual, - Void, - Wchar_t, - While, - Xor, - }; - enum class OperatorType { - // TODO: Add more operators. - NONE = 0, - l_square, - r_square, - l_paren, - r_paren, - l_brace, - r_brace, - period, - ellipsis, - amp, - ampamp, - ampequal, - star, - starequal, - plus, - plusplus, - plusequal, - minus, - arrow, - minusminus, - minusequal, - tilde, - exclaim, - exclaimequal, - slash, - slashequal, - percent, - percentequal, - less, - lessless, - lessequal, - lesslessequal, - spaceship, - greater, - greatergreater, - greaterequal, - greatergreaterequal, - caret, - caretequal, - pipe, - pipepipe, - pipeequal, - question, - colon, - semi, - equal, - equalequal, - comma, - hash, - hashhash, - hashat, - periodstar, - arrowstar, - coloncolon, - at, - lesslessless, - greatergreatergreater, - caretcaret, - }; - struct ValueStr{ + enum class Keyword; + enum class Operator; + struct ValueStr { char* location; size_t length; }; union Value { ValueStr number; - KeywordType keyword; + Keyword keyword; ValueStr identifier; - OperatorType _operator; + Operator _operator; ValueStr character; ValueStr string; }; - Type type = Type::START; + Type type; Value value; Token(); @@ -170,23 +49,5 @@ struct Compiler::Token { Token& operator=(const Token&) = default; Token& operator=(Token&&) noexcept = default; }; - -class Compiler::TokenMap { - public: - TokenMap(); - ~TokenMap(); - - Token::KeywordType GetKeywordValue(std::string keyword); - Token::OperatorType GetOperatorValue(std::string _operator); - - TokenMap(const TokenMap&) = default; - TokenMap(TokenMap&&) noexcept = default; - TokenMap& operator=(const TokenMap&) = default; - TokenMap& operator=(TokenMap&&) noexcept = default; - - private: - LexMap keyword_map; - LexMap operator_map; -}; } // namespace Aq #endif \ No newline at end of file