Merge pull request #1 from Ultimaker/CURA-12556

Split formula engine from curator

Author: HellAholic

.gitignore

@@ -0,0 +1,37 @@
+# Prerequisites
+*.d
+
+# Compiled Object files
+*.slo
+*.lo
+*.o
+*.obj
+
+# Precompiled Headers
+*.gch
+*.pch
+
+# Compiled Dynamic libraries
+*.so
+*.dylib
+*.dll
+
+# Fortran module files
+*.mod
+*.smod
+
+# Compiled Static libraries
+*.lai
+*.la
+*.a
+*.lib
+
+# Executables
+*.exe
+*.out
+*.app
+
+build/
+cmake-build-*/
+.idea
+.vs

CMakeLists.txt

@@ -0,0 +1,110 @@
+cmake_minimum_required(VERSION 3.26)
+project(cura-formulae-engine)
+
+find_package(standardprojectsettings REQUIRED)
+option(ENABLE_TESTS "Build with unit test" ON)
+option(EXTENSIVE_WARNINGS "Build with all warnings" ON)
+option(ENABLE_APPS "Build apps example" ON)
+
+find_package(spdlog REQUIRED)
+find_package(lexy REQUIRED)
+find_package(zeus_expected REQUIRED)
+find_package(range-v3 REQUIRED)
+
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_EXTENSIONS OFF)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+if (NOT DEFINED CURA_FORMULA_VERSION_VERSION)
+    message(FATAL_ERROR "CURA_FORMULA_VERSION_VERSION is not defined!")
+endif ()
+message(STATUS "Configuring CuraFormuleaEngine version: ${CURA_FORMULA_VERSION_VERSION}")
+
+set(CURA_FORMULAE_ENGINE__SRC
+    src/eval.cpp
+    src/env/abs.cpp
+    src/env/map.cpp
+    src/env/math_ceil.cpp
+    src/env/math_cos.cpp
+    src/env/math_degrees.cpp
+    src/env/math_floor.cpp
+    src/env/math_log.cpp
+    src/env/math_radians.cpp
+    src/env/math_sin.cpp
+    src/env/math_sqrt.cpp
+    src/env/math_tan.cpp
+    src/env/max.cpp
+    src/env/min.cpp
+    src/env/round.cpp
+    src/env/str.cpp
+    src/env/sum.cpp
+    src/env/all.cpp
+    src/env/any.cpp
+    src/env/float_fn.cpp
+    src/env/int_fn.cpp
+    src/env/len.cpp
+    src/env/math_atan.cpp
+    src/env/env.cpp
+    src/ast/ast.cpp
+    src/ast/unary_expr/unary_expr.cpp
+    src/ast/unary_expr/neg_expr.cpp
+    src/ast/unary_expr/not_expr.cpp
+    src/ast/comp_chain_expr.cpp
+    src/ast/condition_expr.cpp
+    src/ast/expr_ptr.cpp
+    src/ast/fn_application_expr.cpp
+    src/ast/index_expr.cpp
+    src/ast/list_comprehension_expr.cpp
+    src/ast/list_expr.cpp
+    src/ast/slice_expr.cpp
+    src/ast/tuple_expr.cpp
+    src/ast/variable_expr.cpp
+    src/parser/parser.cpp
+    src/ast/binary_expr/binary_expr.cpp
+    src/ast/binary_expr/add_expr.cpp
+    src/ast/binary_expr/sub_expr.cpp
+    src/ast/binary_expr/div_expr.cpp
+    src/ast/binary_expr/mod_expr.cpp
+    src/ast/binary_expr/mul_expr.cpp
+    src/ast/binary_expr/or_expr.cpp
+    src/ast/binary_expr/pow_expr.cpp
+    src/ast/binary_expr/and_expr.cpp
+        src/ast/primary_expr/string_expr.cpp
+)
+
+add_library(cura-formulae-engine SHARED ${CURA_FORMULAE_ENGINE__SRC})
+
+target_link_libraries(cura-formulae-engine
+    PUBLIC
+    fmt::fmt
+    spdlog::spdlog
+    foonathan::lexy
+    zeus::expected
+    range-v3::range-v3
+)
+
+target_compile_definitions(cura-formulae-engine
+        INTERFACE
+        CURA_FORMULA_VERSION_VERSION="${CURA_FORMULA_VERSION_VERSION}"
+)
+
+target_include_directories(
+        cura-formulae-engine
+        PUBLIC
+        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+        $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
+        PRIVATE
+        ${CMAKE_CURRENT_SOURCE_DIR}/src
+)
+
+if (ENABLE_APPS)
+    add_subdirectory(apps)
+endif ()
+
+if (${EXTENSIVE_WARNINGS})
+    set_project_warnings(cura-formulae-engine)
+endif ()
+
+if (ENABLE_TESTS)
+    add_subdirectory(tests)
+endif ()

README.md

@@ -0,0 +1,25 @@
+# Cura Formulae Engine
+
+Cura Formulae Engine is a library designed to parse and evaluate Cura setting-expressions. These (python-like) expressions can be written to express complex logic for 3D printing settings and internal dependencies between settings.
+
+An example expression could be:
+
+```python
+min_layer_time if min_layer_time > 0 else 0
+```
+
+## Build
+
+Building Cura Formulae Engine requires Conan and CMake. You can use the following commands to build the project:
+
+```shell
+conan install . --build=missing --update
+source build/Release/generators/conanbuild.sh
+cmake --preset conan-release
+cmake --build --preset conan-release
+```
+
+Some additional CMake presets are available for different build configurations. You can specify these configurations by appending the following options to the `conan install` command:
+- tests: `-c tools.build:skip_test=False`
+- extensive warnings: `-o enable_extensive_warnings="True"`
+- with applications: `-o with_apps="True"`

apps/CMakeLists.txt

@@ -0,0 +1 @@
+add_subdirectory(cmdline_parser)

apps/cmdline_parser/CMakeLists.txt

@@ -0,0 +1,14 @@
+add_executable(cmdline_parser
+        cmdline_parser.cpp
+)
+if (MSVC)
+    target_compile_options(cmdline_parser PRIVATE /bigobj)
+endif ()
+
+enable_sanitizers(cmdline_parser)
+if (${EXTENSIVE_WARNINGS})
+    set_project_warnings(cmdline_parser)
+endif ()
+
+target_link_libraries(cmdline_parser PUBLIC cura-formulae-engine foonathan::lexy range-v3::range-v3)
+

apps/cmdline_parser/cmdline_parser.cpp

@@ -0,0 +1,46 @@
+#include <cura-formulae-engine/cura-formulae-engine.h>
+#include <spdlog/spdlog.h>
+
+#include <iostream>
+#include <string>
+#include <string_view>
+
+int main(int argc, const char** argv)
+{
+    spdlog::set_level(spdlog::level::info);
+    spdlog::info("Formula REPL, type 'exit' to quit.");
+
+    while (true)
+    {
+        std::cout << "> ";
+        std::string command;
+        std::getline(std::cin, command);
+        if (command == "exit")
+        {
+            break;
+        }
+
+        const auto input = std::string_view(command.begin(), command.end());
+        auto message = CuraFormulaeEngine::parser::parse(input);
+
+        if (!message.has_value())
+        {
+            spdlog::warn("Failed to parse input.");
+            continue;
+        }
+
+        const auto& expr = message.value();
+        const auto eval_result = expr.evaluate(&CuraFormulaeEngine::env::std_env);
+
+        if (!eval_result.has_value())
+        {
+            spdlog::warn("Expr {} results in eval error", expr.toString());
+            continue;
+        }
+
+        const auto& eval = eval_result.value();
+        spdlog::info("{} = {}", expr.toString(), eval.toString());
+    }
+
+    return 0;
+}

conandata.yml

@@ -0,0 +1 @@
+version: "1.0.0"

conanfile.py

@@ -0,0 +1,109 @@
+import os
+
+from conan import ConanFile
+from conan.errors import ConanInvalidConfiguration, ConanException
+from conan.tools.build import check_min_cppstd
+from conan.tools.cmake import CMake, CMakeDeps, CMakeToolchain, cmake_layout
+from conan.tools.env import VirtualRunEnv, VirtualBuildEnv, Environment
+from conan.tools.files import copy, update_conandata, AutoPackager
+from conan.tools.microsoft import check_min_vs, is_msvc_static_runtime, is_msvc
+from conan.tools.scm import Version
+
+required_conan_version = ">=2.7"
+
+class CuraFormulaeEngineConan(ConanFile):
+    name = "cura-formulae-engine"
+    author = "UltiMaker"
+    url = "https://github.com/Ultimaker/CuraFormlaeEngine"
+    homepage = "https://ultimaker.com"
+    description = "Formulae parser and evaluator engine used in Ultimaker Cura"
+    settings = "os", "compiler", "build_type", "arch"
+    options = {
+        "enable_extensive_warnings": [True, False],
+        "with_apps": [True, False],
+    }
+    default_options = {
+        "enable_extensive_warnings": False,
+        "with_apps": False,
+    }
+
+    def set_version(self):
+        if not self.version:
+            self.version = self.conan_data["version"]
+
+    @property
+    def _min_cppstd(self):
+        return 20
+
+    @property
+    def _compilers_minimum_version(self):
+        return {
+            "gcc": "11",
+            "clang": "14",
+            "apple-clang": "13",
+            "msvc": "192",
+            "visual_studio": "17",
+        }
+
+    def layout(self):
+        cmake_layout(self)
+        self.cpp.build.bin = []
+        self.cpp.package.bin = []
+        self.cpp.package.libs = ["cura-formulae-engine"]
+        self.cpp.build.bindirs = []
+        self.cpp.package.bindirs = ["bin"]
+        self.cpp.package.includedirs = ["include"]
+
+    def requirements(self):
+        self.requires("range-v3/[>=0.12.0]", transitive_headers=True)
+        self.requires("spdlog/[>=1.14.1]", transitive_headers=True)
+        self.requires("fmt/[>=11.0.2]", transitive_headers=True)
+        self.requires("foonathan-lexy/[>=2022.12.1]@ultimaker/stable", transitive_headers=True)
+        self.requires("zeus_expected/[>=1.1.1]", transitive_headers=True)
+
+    def build_requirements(self):
+        self.test_requires("standardprojectsettings/[>=0.2.0]")
+        if not self.conf.get("tools.build:skip_test", False, check_type=bool):
+            self.test_requires("catch2/[>=3.4.0]")
+
+    def export(self):
+        update_conandata(self, {"version": self.version})
+
+    def export_sources(self):
+        copy(self, "CMakeLists.txt", self.recipe_folder, self.export_sources_folder)
+        copy(self, "*", os.path.join(self.recipe_folder, "src"), os.path.join(self.export_sources_folder, "src"))
+        copy(self, "*", os.path.join(self.recipe_folder, "include"), os.path.join(self.export_sources_folder, "include"))
+        copy(self, "*", os.path.join(self.recipe_folder, "tests"), os.path.join(self.export_sources_folder, "tests"))
+
+    def generate(self):
+        tc = CMakeToolchain(self)
+        tc.variables["ENABLE_APPS"] = self.options.with_apps
+        tc.variables["EXTENSIVE_WARNINGS"] = self.options.enable_extensive_warnings
+        tc.variables["CURA_FORMULA_VERSION_VERSION"] = f'{self.version}'
+        tc.variables["ENABLE_TESTS"] = not self.conf.get("tools.build:skip_test", False, check_type=bool)
+
+        tc.variables["WITH_CLI"] = self.options.get_safe("with_cli", False)
+
+        if is_msvc(self):
+            tc.variables["USE_MSVC_RUNTIME_LIBRARY_DLL"] = not is_msvc_static_runtime(self)
+
+        tc.generate()
+
+        tc = CMakeDeps(self)
+        tc.generate()
+
+        tc = VirtualBuildEnv(self)
+        tc.generate()
+
+        tc = VirtualRunEnv(self)
+        tc.generate()
+
+    def build(self):
+        cmake = CMake(self)
+        cmake.configure()
+        cmake.build()
+
+    def package(self):
+        copy(self, pattern="LICENSE", dst=os.path.join(self.package_folder, "licenses"), src=self.source_folder)
+        packager = AutoPackager(self)
+        packager.run()