style: reformat all files

mrunix00 · Dec 1, 2023 · d7101ed · d7101ed
1 parent c2b10b4
commit d7101ed
Show file tree

Hide file tree

Showing 25 changed files with 193 additions and 247 deletions.
diff --git a/.clang-format b/.clang-format
@@ -0,0 +1,66 @@
+# Generated from CLion C/C++ Code Style settings
+BasedOnStyle: LLVM
+AccessModifierOffset: -4
+AlignAfterOpenBracket: Align
+AlignConsecutiveAssignments: None
+AlignOperands: Align
+AllowAllArgumentsOnNextLine: false
+AllowAllConstructorInitializersOnNextLine: false
+AllowAllParametersOfDeclarationOnNextLine: false
+AllowShortBlocksOnASingleLine: Always
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: All
+AllowShortIfStatementsOnASingleLine: Always
+AllowShortLambdasOnASingleLine: All
+AllowShortLoopsOnASingleLine: true
+AlwaysBreakAfterReturnType: None
+AlwaysBreakTemplateDeclarations: Yes
+BreakBeforeBraces: Custom
+BraceWrapping:
+  AfterCaseLabel: false
+  AfterClass: false
+  AfterControlStatement: Never
+  AfterEnum: false
+  AfterFunction: false
+  AfterNamespace: false
+  AfterUnion: false
+  BeforeCatch: false
+  BeforeElse: false
+  IndentBraces: false
+  SplitEmptyFunction: false
+  SplitEmptyRecord: true
+BreakBeforeBinaryOperators: None
+BreakBeforeTernaryOperators: true
+BreakConstructorInitializers: BeforeColon
+BreakInheritanceList: BeforeColon
+ColumnLimit: 0
+CompactNamespaces: false
+ContinuationIndentWidth: 8
+IndentCaseLabels: true
+IndentPPDirectives: None
+IndentWidth: 4
+KeepEmptyLinesAtTheStartOfBlocks: true
+MaxEmptyLinesToKeep: 2
+NamespaceIndentation: All
+ObjCSpaceAfterProperty: false
+ObjCSpaceBeforeProtocolList: true
+PointerAlignment: Right
+ReflowComments: false
+SpaceAfterCStyleCast: true
+SpaceAfterLogicalNot: false
+SpaceAfterTemplateKeyword: false
+SpaceBeforeAssignmentOperators: true
+SpaceBeforeCpp11BracedList: false
+SpaceBeforeCtorInitializerColon: true
+SpaceBeforeInheritanceColon: true
+SpaceBeforeParens: ControlStatements
+SpaceBeforeRangeBasedForLoopColon: false
+SpaceInEmptyParentheses: false
+SpacesBeforeTrailingComments: 0
+SpacesInAngles: false
+SpacesInCStyleCastParentheses: false
+SpacesInContainerLiterals: false
+SpacesInParentheses: false
+SpacesInSquareBrackets: false
+TabWidth: 4
+UseTab: Never
diff --git a/src/builtin_functions/Function.h b/src/builtin_functions/Function.h
@@ -1,10 +1,13 @@
 #ifndef YASI_FUNCTION_H
 #define YASI_FUNCTION_H
 
+#include "../parser/SyntaxTreeNode.h"
+
 class Function {
 public:
-    virtual ~Function()= default;
-    virtual SyntaxTreeNode evaluate(const std::vector<SyntaxTreeNode>& args) = 0;
+    virtual ~Function() = default;
+    virtual SyntaxTreeNode evaluate(
+            const std::vector<SyntaxTreeNode> &args) = 0;
 };
 
 #endif
diff --git a/src/builtin_functions/add/add.cpp b/src/builtin_functions/add/add.cpp
@@ -4,15 +4,10 @@
 SyntaxTreeNode Add::evaluate(const std::vector<SyntaxTreeNode> &args) {
     int result = 0;
 
-    for (const auto& arg: args) {
+    for (const auto &arg: args) {
         auto evArg = Evaluate::evaluate(arg).token;
         result += std::stoi(evArg.token);
     }
 
-    return SyntaxTreeNode(
-            Token(
-                    Token::Integer,
-                    std::to_string(result)
-            )
-    );
+    return SyntaxTreeNode(Token(Token::Integer, std::to_string(result)));
 }
diff --git a/src/builtin_functions/add/add.h b/src/builtin_functions/add/add.h
@@ -6,7 +6,7 @@
 
 class Add : public Function {
 public:
-    SyntaxTreeNode evaluate(const std::vector<SyntaxTreeNode>& args) override;
+    SyntaxTreeNode evaluate(const std::vector<SyntaxTreeNode> &args) override;
 };
 
 #endif
diff --git a/src/builtin_functions/divide/Divide.cpp b/src/builtin_functions/divide/Divide.cpp
@@ -2,17 +2,12 @@
 #include "eval/eval.h"
 
 SyntaxTreeNode Divide::evaluate(const std::vector<SyntaxTreeNode> &args) {
-    int result =  std::stoi(Evaluate::evaluate(args[0]).token.token);
+    int result = std::stoi(Evaluate::evaluate(args[0]).token.token);
 
     for (int i = 1; i < args.size(); i++) {
         auto arg = Evaluate::evaluate(args[i]).token;
         result /= std::stoi(arg.token);
     }
 
-    return SyntaxTreeNode(
-            Token(
-                    Token::Integer,
-                    std::to_string(result)
-            )
-    );
+    return SyntaxTreeNode(Token(Token::Integer, std::to_string(result)));
 }
diff --git a/src/builtin_functions/divide/Divide.h b/src/builtin_functions/divide/Divide.h
@@ -6,8 +6,7 @@
 
 class Divide : public Function {
 public:
-    SyntaxTreeNode evaluate(const std::vector<SyntaxTreeNode>& args) override;
+    SyntaxTreeNode evaluate(const std::vector<SyntaxTreeNode> &args) override;
 };
 
-
 #endif
diff --git a/src/builtin_functions/multiply/multiply.cpp b/src/builtin_functions/multiply/multiply.cpp
@@ -9,10 +9,5 @@ SyntaxTreeNode Multiply::evaluate(const std::vector<SyntaxTreeNode> &args) {
         result *= std::stoi(evArg.token);
     }
 
-    return SyntaxTreeNode(
-            Token(
-                    Token::Integer,
-                    std::to_string(result)
-            )
-    );
+    return SyntaxTreeNode(Token(Token::Integer, std::to_string(result)));
 }
diff --git a/src/builtin_functions/multiply/multiply.h b/src/builtin_functions/multiply/multiply.h
@@ -6,7 +6,7 @@
 
 class Multiply : public Function {
 public:
-    SyntaxTreeNode evaluate(const std::vector<SyntaxTreeNode>& args) override;
+    SyntaxTreeNode evaluate(const std::vector<SyntaxTreeNode> &args) override;
 };
 
 #endif
diff --git a/src/builtin_functions/subtract/subtract.cpp b/src/builtin_functions/subtract/subtract.cpp
@@ -9,10 +9,5 @@ SyntaxTreeNode Subtract::evaluate(const std::vector<SyntaxTreeNode> &args) {
         result -= std::stoi(arg.token);
     }
 
-    return SyntaxTreeNode(
-            Token(
-                    Token::Integer,
-                    std::to_string(result)
-            )
-    );
+    return SyntaxTreeNode(Token(Token::Integer, std::to_string(result)));
 }
diff --git a/src/builtin_functions/subtract/subtract.h b/src/builtin_functions/subtract/subtract.h
@@ -6,7 +6,7 @@
 
 class Subtract : public Function {
 public:
-    SyntaxTreeNode evaluate(const std::vector<SyntaxTreeNode>& args) override;
+    SyntaxTreeNode evaluate(const std::vector<SyntaxTreeNode> &args) override;
 };
 
 #endif
diff --git a/src/eval/eval.cpp b/src/eval/eval.cpp
@@ -1,27 +1,25 @@
-#include <unordered_map>
 #include "eval.h"
 #include "../builtin_functions/add/add.h"
 #include "../builtin_functions/multiply/multiply.h"
 #include "../builtin_functions/subtract/subtract.h"
-#include "exceptions/SyntaxError.h"
 #include "builtin_functions/divide/Divide.h"
+#include "exceptions/SyntaxError.h"
+#include <unordered_map>
 
 SyntaxTreeNode Evaluate::evaluate(const SyntaxTreeNode &tree) {
     static std::unordered_map<std::string, Function *> builtin = {
             {"+", dynamic_cast<Function *>(new Add())},
             {"-", dynamic_cast<Function *>(new Subtract())},
             {"*", dynamic_cast<Function *>(new Multiply())},
-            {"/", dynamic_cast<Function *>(new Divide())}
-    };
+            {"/", dynamic_cast<Function *>(new Divide())}};
     if (tree.children.empty()) {
         return SyntaxTreeNode(tree.token);
     }
     if (builtin.find(tree.token.token) != builtin.end()) {
         return builtin.at(tree.token.token)->evaluate(tree.children);
     } else {
-        auto errorMessage = "Syntax error: name `"
-                            + tree.token.token +
-                            "` is not defined";
+        auto errorMessage =
+                "Syntax error: name `" + tree.token.token + "` is not defined";
         throw SyntaxError(errorMessage);
     }
 }
diff --git a/src/exceptions/SyntaxError.h b/src/exceptions/SyntaxError.h
@@ -9,8 +9,7 @@ class SyntaxError : public std::exception {
 public:
     std::string message;
 
-    explicit SyntaxError(std::string message)
-            : message(std::move(message)) {}
+    explicit SyntaxError(std::string message) : message(std::move(message)) {}
 };
 
 #endif
diff --git a/src/lexer/Lexer.cpp b/src/lexer/Lexer.cpp
@@ -1,15 +1,13 @@
-#include <cstring>
 #include "Lexer.h"
+#include <cstring>
 
 std::vector<Token> Lexer::tokenize(const std::string &line) {
     std::vector<Token> result;
     std::string currentToken;
 
     for (auto c: line) {
-        if (c != '(' && c != ')'
-            && (c != ' ' || currentToken[0] == '"')
-            && (c != '"' || currentToken[0] != '"')
-                ) {
+        if (c != '(' && c != ')' && (c != ' ' || currentToken[0] == '"') &&
+            (c != '"' || currentToken[0] != '"')) {
             currentToken.append(1, c);
             continue;
         }

diff --git a/src/lexer/Lexer.h b/src/lexer/Lexer.h
@@ -1,8 +1,8 @@
 #ifndef YASI_LEXER_H
 #define YASI_LEXER_H
 
-#include <utility>
 #include <iostream>
+#include <utility>
 #include <vector>
 
 class Token {
@@ -22,15 +22,11 @@ class Token {
     Token() : type(Token::Invalid) {}
 
     Token(TokenType type, std::string token)
-            : type(type),
-              token(std::move(token)) {}
+        : type(type), token(std::move(token)) {}
 
-    bool operator==(const Token &object) const {
-        return token == object.token;
-    }
+    bool operator==(const Token &object) const { return token == object.token; }
 };
 
-
 class Lexer {
 public:
     static std::vector<Token> tokenize(const std::string &line);

diff --git a/src/main.cpp b/src/main.cpp
@@ -1,10 +1,10 @@
-#include <cstdlib>
-#include <iostream>
-#include "read.hpp"
-#include "lexer/Lexer.h"
 #include "eval/eval.h"
-#include "parser/Parser.h"
 #include "exceptions/SyntaxError.h"
+#include "lexer/Lexer.h"
+#include "parser/Parser.h"
+#include "read.hpp"
+#include <cstdlib>
+#include <iostream>
 
 int main() {
     std::cout << "Yasi v0.0.0\n";
@@ -18,13 +18,11 @@ int main() {
         }
 
         try {
-            auto result = Evaluate::evaluate(
-                    Parser::parse(Lexer::tokenize(userInput))
-            );
+            auto result =
+                    Evaluate::evaluate(Parser::parse(Lexer::tokenize(userInput)));
             std::cout << result.token.token << '\n';
         } catch (SyntaxError &error) {
             std::cout << error.message << '\n';
         }
-
     }
 }
diff --git a/src/parser/Parser.cpp b/src/parser/Parser.cpp
@@ -1,5 +1,5 @@
-#include <stack>
 #include "Parser.h"
+#include <stack>
 
 SyntaxTreeNode Parser::parse(const std::vector<Token> &tokens) {
     std::stack<Token> operators_stack;
@@ -14,13 +14,11 @@ SyntaxTreeNode Parser::parse(const std::vector<Token> &tokens) {
         } else if (token.type == Token::ClosedBracket) {
             auto args = nodes_stack.top();
             nodes_stack.pop();
-            if (nodes_stack.empty()) nodes_stack.emplace();
-            nodes_stack.top().emplace_back(
-                    operators_stack.top(),
-                    args
-            );
-            operators_stack.pop(); // pop the operator
-            operators_stack.pop(); // pop the bracket
+            if (nodes_stack.empty())
+                nodes_stack.emplace();
+            nodes_stack.top().emplace_back(operators_stack.top(), args);
+            operators_stack.pop();// pop the operator
+            operators_stack.pop();// pop the bracket
         } else {
             nodes_stack.top().emplace_back(token);
         }

diff --git a/src/parser/SyntaxTreeNode.h b/src/parser/SyntaxTreeNode.h
@@ -1,20 +1,17 @@
 #ifndef YASI_SYNTAXTREENODE_H
 #define YASI_SYNTAXTREENODE_H
 
+#include "lexer/Lexer.h"
 #include <utility>
 #include <vector>
-#include "lexer/Lexer.h"
 
 class SyntaxTreeNode {
 public:
     Token token;
     std::vector<SyntaxTreeNode> children;
 
-    SyntaxTreeNode(
-            Token token,
-            const std::vector<SyntaxTreeNode> &children
-    ) : token(std::move(token)),
-        children(children) {}
+    SyntaxTreeNode(Token token, const std::vector<SyntaxTreeNode> &children)
+        : token(std::move(token)), children(children) {}
 
     explicit SyntaxTreeNode(Token token) : token(std::move(token)) {}
 

diff --git a/tests/add_test.cpp b/tests/add_test.cpp
@@ -1,12 +1,10 @@
-#include <gtest/gtest.h>
-#include "parser/SyntaxTreeNode.h"
 #include "builtin_functions/add/add.h"
+#include "parser/SyntaxTreeNode.h"
+#include <gtest/gtest.h>
 
 TEST(add_test, ShouldAddTwoNumbers) {
-    auto expression = {
-            SyntaxTreeNode(Token(Token::Integer, "1")),
-            SyntaxTreeNode(Token(Token::Integer, "2"))
-    };
+    auto expression = {SyntaxTreeNode(Token(Token::Integer, "1")),
+                       SyntaxTreeNode(Token(Token::Integer, "2"))};
 
     auto expectedResult = SyntaxTreeNode(Token(Token::Integer, "3"));
     auto actual = Add().evaluate(expression);
@@ -17,14 +15,9 @@ TEST(add_test, ShouldAddTwoNumbers) {
 TEST(add_test, ShouldEvaluateNestedAddition) {
     auto expression = {
             SyntaxTreeNode(Token(Token::Integer, "1")),
-            SyntaxTreeNode(
-                    Token(Token::Integer, "+"),
-                    {
-                            SyntaxTreeNode(Token(Token::Integer, "2")),
-                            SyntaxTreeNode(Token(Token::Integer, "3"))
-                    }
-            )
-    };
+            SyntaxTreeNode(Token(Token::Integer, "+"),
+                           {SyntaxTreeNode(Token(Token::Integer, "2")),
+                            SyntaxTreeNode(Token(Token::Integer, "3"))})};
 
     auto expectedResult = SyntaxTreeNode(Token(Token::Integer, "6"));
     auto actual = Add().evaluate(expression);