origin/calculator

CMakeLists.txt

@@ -0,0 +1,30 @@
+cmake_minimum_required(VERSION 3.14)
+project(CalcApp LANGUAGES CXX)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+add_subdirectory(src)
+
+add_executable(CalcApp main.cpp)
+
+target_link_libraries(CalcApp CalcLib)
+
+# Build plugins
+add_subdirectory(plugins)
+
+# Post-build: copy DLLs to ./plugins next to calc.exe
+add_custom_command(TARGET CalcApp POST_BUILD
+        COMMAND ${CMAKE_COMMAND} -E make_directory $<TARGET_FILE_DIR:CalcApp>/plugins
+)
+
+foreach (plugin ${PLUGIN_TARGETS})
+    add_custom_command(TARGET CalcApp POST_BUILD
+            COMMAND ${CMAKE_COMMAND} -E copy
+            $<TARGET_FILE:${plugin}>
+            $<TARGET_FILE_DIR:CalcApp>/plugins/
+    )
+endforeach ()
+
+enable_testing()
+add_subdirectory(tests)

README.md

@@ -0,0 +1,49 @@
+# Simple calculator app
+## Operators and functions are loaded from DLLs or SOs
+
+### Build: 
+1. `cmake -B ./build -S ./` (on windows you may want to also have `-g Ninja`)
+2. `cmake --build ./build`
+
+This will build all the dlls from ./plugins/ and calculator itself
+
+### Running
+
+Simply start the build/CalcApp.exe executable from build directory
+
+### Usage
+
+Calculator will try to calculate any expression that is passed in first line of stdin and then exit
+If any exception happened, that will be seen in console:
+
+### Supported syntax
+- Calculator comes with some plugins out of the box (see `plugins/` dir): basic math and some functions
+- Calculator supports parentheses, binary and unary operators, functions
+- Function's arguments should be passed in parentheses: `sin(3.14)`, not `sin 3.14`
+- Function may have any positive integer number of arguments that is `size_t` able to save: `max(1,2,3,4,5,...)`
+- Operators should be single characters
+
+### Creating your own dll:
+To create your very own function or operator you have to create a separate dll
+To make it, follow this steps:
+
+1. create a `*.cpp` file in `plugins/` folder
+2. include `#include "../src/plugin_interface.h"` in it
+3. Define required functional:
+   - your function: `anyname`
+   - FunctionInfo
+   - `PLUGIN_API const FunctionInfo* get_function_info()`
+   - If not understood, see example plugins in `plugins/` folder
+   - Rebuild the app to create shared library binary from your new .cpp
+
+#### Plugin name restrictions:
+- Not empty
+- Not be '(', ')', ',' - reserved syntax tokens
+- Shouldn't start with number
+- Operators may have only 1 char as a name
+- Plugins within categories (binary operator, unary operator, function) should not share a name inside a category. So, there may not be 2 unary '-' operators, but may be unary '-' and binary '-' and function "-"
+
+#### What's unary, binary and function?
+- If plugin is an operator with arity=2 -> binary operator like `1+2`
+- If plugin is an operator with arity=1 -> unary prefix operator `-1`, `(-1+2)`, `-(1+2)`
+- if plugin is a function it's implemented as prefix function with any arity: `sin(3.14)`, `pow(2, 4)`

main.cpp

@@ -0,0 +1,17 @@
+#include <iostream>
+#include <string>
+
+#include "src/Calculator.hpp"
+
+int main() {
+    try {
+        std::string input;
+        std::getline(std::cin, input);
+        Calculator calc;
+        std::cout << calc.evaluate(input) << std::endl;
+    } catch (const std::exception& e) {
+        std::cerr << "Error: " << e.what() << std::endl;
+        return 1;
+    }
+    return 0;
+}

plugins/CMakeLists.txt

@@ -0,0 +1,36 @@
+cmake_minimum_required(VERSION 3.14)
+
+# Automatically find all .cpp files in this directory
+file(GLOB PLUGIN_SOURCES CONFIGURE_DEPENDS "*.cpp")
+
+if (WIN32)
+    set(CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS ON)
+endif ()
+
+if(NOT PLUGIN_SOURCES)
+    message(STATUS "No plugin sources found in ${CMAKE_CURRENT_SOURCE_DIR}")
+    return()
+endif()
+
+set(PLUGIN_TARGETS "")
+
+foreach(source_file IN LISTS PLUGIN_SOURCES)
+    # Get filename without path and extension
+    get_filename_component(plugin_name ${source_file} NAME_WE)
+
+    # Create a shared library (DLL) for each plugin
+    add_library(${plugin_name} SHARED ${source_file})
+
+    set_target_properties(${plugin_name} PROPERTIES
+            PREFIX ""           # No "lib" prefix on Windows
+            OUTPUT_NAME "${plugin_name}"  # Explicit name
+            ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/static_plugins  # optional: control where .a goes
+    )
+
+    list(APPEND PLUGIN_TARGETS ${plugin_name})
+endforeach()
+
+# Expose PLUGIN_TARGETS to parent scope so main CMakeLists can copy them
+set(PLUGIN_TARGETS ${PLUGIN_TARGETS} PARENT_SCOPE)
+
+message(STATUS "Found ${CMAKE_CURRENT_SOURCE_DIR} plugins: ${PLUGIN_TARGETS}")

plugins/PLUGIN_STRUCTURE.md

@@ -0,0 +1,9 @@
+
+
+# Every calculator plugin should have 2 functions in ddlexport:
+1. `PLUGIN_API const FunctionInfo* get_function_info();` - возвращает имя функции или оператора.
+2. `PLUGIN API double name_eval(const double* args, size_t count)` - вычисляет значение функции от аргументов и возвращает результат, или выбрасывает исключение
+
+### See src/plugin_interface.h for FunctionInfo and PLUGIN_API definition
+- `extern "C"` disables name mangling
+- `__declspec(dllexport)` exports the symbol from .dll

plugins/add_plugin.cpp

@@ -0,0 +1,17 @@
+#include "../src/plugin_interface.h"
+
+//количество аргументов функции (оператора)
+#define ARGC 2
+
+PLUGIN_API PluginResult add_eval(const double* args, size_t count) {
+    if (count != ARGC) return PluginResult{0.0, "Should accept 2 arguments"};
+    return PluginResult{args[0] + args[1], nullptr};
+}
+
+static const FunctionInfo info = {
+        "+", ARGC, 60, Associativity::Left, true, add_eval
+    };
+
+PLUGIN_API const FunctionInfo* get_function_info() {
+    return &info;
+}

plugins/cos_plugin.cpp

@@ -0,0 +1,18 @@
+#include "../src/plugin_interface.h"
+#include <cmath>
+
+//количество аргументов функции (оператора)
+#define ARGC 1
+
+PLUGIN_API PluginResult cos_eval(const double* args, size_t count) {
+    if (count != ARGC) return PluginResult{0.0, "Should accept 1 argument"};
+    return PluginResult{std::cos(args[0]), nullptr};
+}
+
+static const FunctionInfo info = {
+    "cos", ARGC, 90, Associativity::Left, false, cos_eval
+};
+
+PLUGIN_API const FunctionInfo* get_function_info() {
+    return &info;
+}

plugins/div_plugin.cpp

@@ -0,0 +1,20 @@
+#include "../src/plugin_interface.h"
+
+#include <stdexcept>
+
+//количество аргументов функции (оператора)
+#define ARGC 2
+
+PLUGIN_API PluginResult div_eval(const double* args, size_t count) {
+    if (count != ARGC) return PluginResult{0.0, "Should accept 2 arguments"};
+    if (args[1] == 0.0) return PluginResult{0.0, "Division by zero"};
+    return PluginResult{args[0] / args[1], nullptr};
+}
+
+static const FunctionInfo info = {
+        "/", ARGC, 70, Associativity::Left, true, div_eval
+    };
+
+PLUGIN_API const FunctionInfo* get_function_info() {
+    return &info;
+}

plugins/ln_plugin.cpp

@@ -0,0 +1,21 @@
+#include "../src/plugin_interface.h"
+#include <cmath>
+
+//количество аргументов функции (оператора)
+#define ARGC 1
+
+PLUGIN_API PluginResult ln_eval(const double* args, size_t count) {
+    if (count != ARGC) return PluginResult{0.0, "Should accept 1 argument"};
+    if (args[0] <= 0.0) {
+        return PluginResult{0.0, "Argument must be positive"};
+    }
+    return PluginResult{std::log(args[0]), nullptr};
+}
+
+static const FunctionInfo info = {
+    "ln", ARGC, 90, Associativity::Left, false, ln_eval
+};
+
+PLUGIN_API const FunctionInfo* get_function_info() {
+    return &info;
+}

plugins/mul_plugin.cpp

@@ -0,0 +1,16 @@
+#include "../src/plugin_interface.h"
+
+//количество аргументов функции (оператора)
+#define ARGC 2
+PLUGIN_API PluginResult mul_eval(const double* args, size_t count) {
+    if (count != ARGC) return PluginResult{0.0, "Should accept 2 arguments"};
+    return PluginResult{args[0] * args[1], nullptr};
+}
+
+static const FunctionInfo info = {
+    "*", ARGC, 70, Associativity::Left, true, mul_eval
+};
+
+PLUGIN_API const FunctionInfo* get_function_info() {
+    return &info;
+}

plugins/pow_plugin.cpp

@@ -0,0 +1,20 @@
+#include "../src/plugin_interface.h"
+
+#include <cmath>
+#include <stdexcept>
+
+//количество аргументов функции (оператора)
+#define ARGC 2
+
+PLUGIN_API PluginResult pow_eval(const double* args, size_t) {
+    double base = args[0], exp = args[1];
+    return PluginResult{std::pow(base, exp), nullptr};
+}
+
+static const FunctionInfo info = {
+    "^", ARGC, 90, Associativity::Right, true, pow_eval
+};
+
+PLUGIN_API const FunctionInfo* get_function_info() {
+    return &info;
+}

plugins/sin_plugin.cpp

@@ -0,0 +1,16 @@
+#include <cmath>
+#include "../src/plugin_interface.h"
+
+//количество аргументов функции (оператора)
+#define ARGC 1
+
+PLUGIN_API PluginResult sin_eval(const double* args, size_t count) {
+    if (count != 1) return PluginResult{0.0, "Should accept 1 argument"};
+    return PluginResult{std::sin(args[0]), nullptr};
+}
+
+static const FunctionInfo info = {
+    "sin", ARGC, 90, Associativity::Left, false, sin_eval
+};
+
+PLUGIN_API const FunctionInfo* get_function_info() { return &info; }

plugins/sub_plugin.cpp

@@ -0,0 +1,17 @@
+#include "../src/plugin_interface.h"
+
+
+//количество аргументов функции (оператора)
+#define ARGC 2
+
+PLUGIN_API PluginResult sub_eval(const double* args, size_t) {
+    return PluginResult{args[0] - args[1], nullptr};
+}
+
+static const FunctionInfo info = {
+    "-", ARGC, 60, Associativity::Left, true, sub_eval
+};
+
+PLUGIN_API const FunctionInfo* get_function_info() {
+    return &info;
+}

plugins/tg_plugin.cpp

@@ -0,0 +1,20 @@
+#include "../src/plugin_interface.h"
+#include <cmath>
+#include <stdexcept>
+
+//количество аргументов функции (оператора)
+#define ARGC 1
+
+PLUGIN_API PluginResult tan_eval(const double* args, size_t count) {
+    if (count != ARGC) return PluginResult{0.0, "Should accept 1 argument"};
+    double x = args[0];
+    return PluginResult{std::tan(x), nullptr};
+}
+
+static const FunctionInfo info = {
+    "tg", ARGC, 90, Associativity::Left, false, tan_eval
+};
+
+PLUGIN_API const FunctionInfo* get_function_info() {
+    return &info;
+}

plugins/unary_minus.cpp

@@ -0,0 +1,20 @@
+#include "../src/plugin_interface.h"
+#include <cmath>
+#include <stdexcept>
+
+#define ARGC 1
+
+PLUGIN_API PluginResult uminus_eval(const double* args, size_t count) {
+    if (count != ARGC) {
+        return PluginResult{0.0, "Unary minus: expected 1 argument"};
+    }
+    return PluginResult{-args[0], nullptr};
+}
+
+static const FunctionInfo info = {
+    "-", ARGC, 80, Associativity::Right, true, uminus_eval
+};
+
+PLUGIN_API const FunctionInfo* get_function_info() {
+    return &info;
+}

src/CMakeLists.txt

@@ -0,0 +1,18 @@
+cmake_minimum_required(VERSION 3.14)
+project(CalcLib LANGUAGES CXX)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+add_library(CalcLib
+        Tokenizer.cpp
+        PluginManager.cpp
+        Token.hpp
+        Tokenizer.hpp
+        ShuntingYard.hpp
+        ShuntingYard.cpp
+        RpnEvaluator.hpp
+        RpnEvaluator.cpp
+        Calculator.hpp
+        Calculator.cpp
+)

src/Calculator.cpp

@@ -0,0 +1,11 @@
+#include "Calculator.hpp"
+#include "Tokenizer.hpp"
+#include "ShuntingYard.hpp"
+#include "RpnEvaluator.hpp"
+#include "PluginManager.hpp"
+
+double Calculator::evaluate(const std::string& expr) {
+    auto tokens = tokenize(expr);
+    auto rpn = shuntingYard(tokens, pm);
+    return evaluateRpn(rpn, pm);
+}

src/Calculator.hpp

@@ -0,0 +1,11 @@
+#pragma once
+
+#include <string>
+
+#include "PluginManager.hpp"
+
+class Calculator {
+    PluginManager pm;
+public:
+    double evaluate(const std::string& expression);
+};