refactor: trying to go non-heap

Author: sillydan1

src/cli/detcheck/main.cpp

@@ -24,8 +24,8 @@
 #include <plugin_system/plugin_system.h>
 #include <timer>
 
-auto get_ntta(const std::vector<std::string>& plugin_dirs, const std::vector<std::string>& ignore_list, const std::string& parser, const std::vector<std::string>& input) -> std::unique_ptr<aaltitoad::ntta_t>;
-void find_deadlocks(const std::unique_ptr<aaltitoad::ntta_t>& ntta, const std::vector<std::string>& conditions, const std::optional<std::string>& condition_file, const std::vector<std::string> knowns, const std::optional<std::string>& known_file, const std::vector<std::string>& instance, const std::optional<std::string>& instance_file);
+auto get_ntta(const std::vector<std::string>& plugin_dirs, const std::vector<std::string>& ignore_list, const std::string& parser, const std::vector<std::string>& input) -> aaltitoad::ntta_t;
+void find_deadlocks(const aaltitoad::ntta_t& ntta, const std::vector<std::string>& conditions, const std::optional<std::string>& condition_file, const std::vector<std::string> knowns, const std::optional<std::string>& known_file, const std::vector<std::string>& instance, const std::optional<std::string>& instance_file);
 
 int main(int argc, char** argv) {
     bool show_help = false;
@@ -97,7 +97,7 @@ int main(int argc, char** argv) {
 
     auto automata = get_ntta(plugin_dirs, ignore, parser, input);
     if(list_instances) {
-        for(auto& c: automata->components)
+        for(auto& c: automata.components)
             std::cout << c.first << " ";
         std::cout << std::endl;
         return 0;
@@ -108,7 +108,7 @@ int main(int argc, char** argv) {
     return 0;
 }
 
-auto get_ntta(const std::vector<std::string>& plugin_dirs, const std::vector<std::string>& ignore_list, const std::string& parser, const std::vector<std::string>& input) -> std::unique_ptr<aaltitoad::ntta_t> {
+auto get_ntta(const std::vector<std::string>& plugin_dirs, const std::vector<std::string>& ignore_list, const std::string& parser, const std::vector<std::string>& input) -> aaltitoad::ntta_t {
     /// Load plugins
     auto available_plugins = aaltitoad::plugins::load(plugin_dirs);
 
@@ -124,9 +124,8 @@ auto get_ntta(const std::vector<std::string>& plugin_dirs, const std::vector<std
     aaltitoad::warnings::print_warnings(parse_result);
     if(!parse_result.has_value())
         throw std::logic_error("compilation failed");
-    auto automata = std::move(parse_result.value().ntta);
     spdlog::trace("model parsing took {0}ms", t.milliseconds_elapsed());
-    return automata;
+    return parse_result.value().ntta;
 }
 
 auto get_mentioned_symbols(const expr::syntax_tree_t& expression, const expr::symbol_table_t& symbols) -> expr::symbol_table_t {
@@ -149,9 +148,9 @@ auto get_mentioned_symbols(const expr::syntax_tree_t& expression, const expr::sy
     return mentioned;
 }
 
-void find_deadlocks(const std::unique_ptr<aaltitoad::ntta_t>& ntta, const std::vector<std::string>& conditions, const std::optional<std::string>& condition_file, const std::vector<std::string> knowns, const std::optional<std::string>& known_file, const std::vector<std::string>& instance, const std::optional<std::string>& instance_file) {
+void find_deadlocks(const aaltitoad::ntta_t& ntta, const std::vector<std::string>& conditions, const std::optional<std::string>& condition_file, const std::vector<std::string> knowns, const std::optional<std::string>& known_file, const std::vector<std::string>& instance, const std::optional<std::string>& instance_file) {
     ya::timer<unsigned int> t{};
-    aaltitoad::expression_driver c{ntta->symbols, ntta->external_symbols};
+    aaltitoad::expression_driver c{ntta.symbols, ntta.external_symbols};
     std::vector<expr::syntax_tree_t> extra_conditions{};
     for(auto& condition : conditions) {
         auto result = c.parse(condition);
@@ -196,9 +195,9 @@ void find_deadlocks(const std::unique_ptr<aaltitoad::ntta_t>& ntta, const std::v
     }
     for(auto& instance: instances) {
         spdlog::trace("looking for '{0}' in components", instance);
-        for(auto& location: ntta->components.at(instance).graph->nodes)
+        for(auto& location: ntta.components.at(instance).graph->nodes)
             for(auto& edge: location.second.outgoing_edges)
-                unknown_symbols += get_mentioned_symbols(edge->second.data.guard, ntta->symbols + ntta->external_symbols);
+                unknown_symbols += get_mentioned_symbols(edge->second.data.guard, ntta.symbols + ntta.external_symbols);
     }
     spdlog::trace("finding {0} mentioned symbols in {1} tta instances took {2}ms", unknown_symbols.size(), instances.size(), t.milliseconds_elapsed());
 
@@ -209,7 +208,7 @@ void find_deadlocks(const std::unique_ptr<aaltitoad::ntta_t>& ntta, const std::v
     aaltitoad::expression_driver d{known_symbols, unknown_symbols};
     for(auto& instance : instances) {
         spdlog::trace("looking for '{0}' in components", instance);
-        for(auto& location : ntta->components.at(instance).graph->nodes) {
+        for(auto& location : ntta.components.at(instance).graph->nodes) {
             t.start();
             if(location.second.outgoing_edges.empty())
                 continue;

src/cli/simulator/main.cpp

@@ -126,9 +126,9 @@ int main(int argc, char** argv) {
 
     /// Inject tockers - CLI Format: "name(argument)"
     for(auto& arg : tockers) {
-        auto tocker = instantiate_tocker(arg, available_plugins, *automata);
+        auto tocker = instantiate_tocker(arg, available_plugins, automata);
         if(tocker.has_value())
-            automata->tockers.emplace_back(std::move(tocker.value()));
+            automata.tockers.emplace_back(std::move(tocker.value()));
     }
 
     /// Run
@@ -141,15 +141,15 @@ int main(int argc, char** argv) {
         for (; i < ticks || ticks < 0; i++) {
             if(spdlog::get_level() <= spdlog::level::trace) {
                 std::stringstream ss{};
-                ss << "state:\n" << *automata;
+                ss << "state:\n" << automata;
                 spdlog::trace(ss.str());
             }
-            auto tock_changes = automata->tock();
+            auto tock_changes = automata.tock();
             if(!tock_changes.empty())
-                automata->apply(tock_changes[0]);
-            auto tick_changes = automata->tick();
+                automata.apply(tock_changes[0]);
+            auto tick_changes = automata.tick();
             if(!tick_changes.empty())
-                automata->apply(tick_changes[0]);
+                automata.apply(tick_changes[0]);
         }
 #ifdef NDEBUG
     } catch (std::exception& e) {

src/cli/verifier/main.cpp

@@ -139,13 +139,13 @@ int main(int argc, char** argv) {
             return 1;
         }
 
-        auto n = std::move(parse_result.value().ntta);
-        trace_log_ntta(*n);
+        auto n = parse_result.value().ntta;
+        trace_log_ntta(n);
         spdlog::debug("model parsing took {0}ms", t.milliseconds_elapsed());
 
         t.start();
         std::vector<ctl::syntax_tree_t> queries{};
-        aaltitoad::ctl_interpreter ctl_compiler{n->symbols, n->external_symbols};
+        aaltitoad::ctl_interpreter ctl_compiler{n.symbols, n.external_symbols};
         for(auto& q : query) {
             spdlog::trace("compiling query '{0}'", q);
             auto qq = ctl_compiler.compile(q);
@@ -155,19 +155,19 @@ int main(int argc, char** argv) {
         }
         for(auto& f : query_files) {
             spdlog::trace("loading queries in file {0}", f);
-            auto json_queries = aaltitoad::load_query_json_file(f, {n->symbols, n->external_symbols});
+            auto json_queries = aaltitoad::load_query_json_file(f, {n.symbols, n.external_symbols});
             queries.insert(queries.end(), json_queries.begin(), json_queries.end());
         }
         spdlog::debug("query parsing took {0}ms", t.milliseconds_elapsed());
 
         auto strategy = magic_enum::enum_cast<aaltitoad::pick_strategy>(pick_strategy).value_or(aaltitoad::pick_strategy::first);
         spdlog::debug("using pick strategy '{0}'", magic_enum::enum_name(strategy));
 
-        n->add_tocker(std::make_unique<aaltitoad::interesting_tocker>());
+        n.add_tocker(std::make_unique<aaltitoad::interesting_tocker>());
         spdlog::trace("starting reachability search for {0} queries", queries.size());
         t.start();
         aaltitoad::forward_reachability_searcher frs{strategy};
-        auto results = frs.is_reachable(*n, queries);
+        auto results = frs.is_reachable(n, queries);
         spdlog::info("reachability search took {0}ms", t.milliseconds_elapsed());
 
         // open the results file (std::cout by default)

src/parser/hawk/compiler.cpp

@@ -1,3 +1,20 @@
+/**
+ * aaltitoad - a verification engine for tick tock automata models
+   Copyright (C) 2023 Asger Gitz-Johansen
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
 #include "compiler.h"
 #include <overload>
 
@@ -12,17 +29,17 @@ namespace aaltitoad::hawk {
     }
 
     compiler::compiler(
-            std::unique_ptr<scanner>&& _scanner,
-            std::unique_ptr<parser>&& _parser,
-            std::unique_ptr<semantic_analyzer>&& _analyzer,
-            std::unique_ptr<optimizer>&& _optimizer,
-            std::unique_ptr<generator>&& _generator)
+            scanner& _scanner,
+            parser& _parser,
+            semantic_analyzer& _analyzer,
+            optimizer& _optimizer,
+            generator& _generator)
         : 
-            _scanner{std::move(_scanner)},
-            _parser{std::move(_parser)},
-            _analyzer{std::move(_analyzer)},
-            _optimizer{std::move(_optimizer)},
-            _generator{std::move(_generator)},
+            _scanner{_scanner},
+            _parser{_parser},
+            _analyzer{_analyzer},
+            _optimizer{_optimizer},
+            _generator{_generator},
             symbols{},
             _diagnostic_factory{} {
     }
@@ -36,18 +53,18 @@ namespace aaltitoad::hawk {
     }
 
     auto compiler::compile(const std::vector<std::string>& paths, const std::vector<std::string>& ignore_list) -> std::expected<ok, error_t> {
-        auto stream = _scanner->scan(*this, paths, ignore_list);
+        auto stream = _scanner.scan(*this, paths, ignore_list);
         if(!stream)
             return std::unexpected{stream.error()};
-        auto ast = _parser->parse(*this, stream.value());
+        auto ast = _parser.parse(*this, stream.value());
         if(!ast)
             return std::unexpected{ast.error()};
-        auto dast_r = _analyzer->analyze(*this, ast.value());
+        auto dast_r = _analyzer.analyze(*this, ast.value());
         if(!dast_r)
             return std::unexpected{dast_r.error()};
         auto dast = dast_r.value();
-        _optimizer->optimize(*this, dast);
-        auto ntta = _generator->generate(*this, dast);
+        _optimizer.optimize(*this, dast);
+        auto ntta = _generator.generate(*this, dast);
         if(!ntta)
             return std::unexpected(ntta.error());
         return ok{
@@ -67,4 +84,8 @@ namespace aaltitoad::hawk {
     error_t::error_t() : diagnostics{} {}
 
     error_t::error_t(const std::vector<Diagnostic>& diagnostics) : diagnostics{diagnostics} {}
+
+    void nothing_optimizer::optimize(compiler& ctx, parser::ok& ast) const {
+        
+    }
 }

src/parser/hawk/compiler.h

@@ -1,3 +1,20 @@
+/**
+ * aaltitoad - a verification engine for tick tock automata models
+   Copyright (C) 2023 Asger Gitz-Johansen
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
 #ifndef AALTITOAD_HAWK_COMPILER_H
 #define AALTITOAD_HAWK_COMPILER_H
 #include "ntta/tta.h"
@@ -58,6 +75,12 @@ namespace aaltitoad::hawk {
         virtual void optimize(compiler& ctx, parser::ok& ast) const = 0;
     };
 
+    class nothing_optimizer : public optimizer {
+    public:
+        ~nothing_optimizer() override = default;
+        void optimize(compiler& ctx, parser::ok& ast) const override;
+    };
+
     struct generator {
         generator() = default;
         virtual ~generator() = default;
@@ -71,24 +94,20 @@ namespace aaltitoad::hawk {
             std::vector<Diagnostic> diagnostics;
         };
 
-        compiler(
-                std::unique_ptr<scanner>&& scanner,
-                std::unique_ptr<parser>&& parser,
-                std::unique_ptr<semantic_analyzer>&& analyzer,
-                std::unique_ptr<optimizer>&& optimizer,
-                std::unique_ptr<generator>&& generator);
+        compiler(scanner& scanner);
+        compiler(scanner& scanner, parser& parser, semantic_analyzer& analyzer, optimizer& optimizer, generator& generator);
         void add_symbols(const expr::symbol_table_t& symbols);
         void clear_symbols();
         auto get_diagnostic_factory() -> diagnostic_factory&;
         auto diag(const diagnostic& d) -> Diagnostic;
         auto compile(const std::vector<std::string>& paths, const std::vector<std::string>& ignore_list) -> std::expected<ok, error_t>;
 
     private:
-        std::unique_ptr<scanner> _scanner;
-        std::unique_ptr<parser> _parser;
-        std::unique_ptr<semantic_analyzer> _analyzer;
-        std::unique_ptr<optimizer> _optimizer;
-        std::unique_ptr<generator> _generator;
+        scanner& _scanner;
+        parser& _parser;
+        semantic_analyzer& _analyzer;
+        optimizer& _optimizer;
+        generator& _generator;
         expr::symbol_table_t symbols;
         diagnostic_factory _diagnostic_factory;
     };

src/parser/hawk/huppaal/parser.cpp

@@ -65,23 +65,41 @@ namespace aaltitoad::hawk::huppaal {
         return std::regex_match(entry.path().c_str(), std::regex{ignore_regex});
     }
 
+    /* =========== */
+
     auto huppaal_parser::parse(compiler& ctx, const scanner::ok& stream) const noexcept -> std::expected<parser::ok, error_t> {
         return std::unexpected(error_t({ctx.diag(not_implemented_yet())}));
     }
 
-    parser::parser() : compiler{} {
-        
+    /* =========== */
+
+    auto huppaal_semantic_analyzer::analyze(compiler& ctx, const aaltitoad::hawk::parser::ok& ast) const noexcept -> std::expected<aaltitoad::hawk::parser::ok, error_t> {
+        return std::unexpected(error_t({ctx.diag(not_implemented_yet())}));
+    }
+
+    /* =========== */
+
+    auto huppaal_generator::generate(compiler& ctx, const aaltitoad::hawk::parser::ok& ast) const noexcept -> std::expected<ntta_t, error_t> {
+        return std::unexpected(error_t({ctx.diag(not_implemented_yet())}));
     }
 
+    /* =========== */
+
     auto parser::parse_files(const std::vector<std::string>& files, const std::vector<std::string>& ignore_patterns) -> plugin::parse_result {
-        auto compile_result = compiler->compile(files, ignore_patterns);
+        auto compiler = create_compiler();
+        auto compile_result = compiler.compile(files, ignore_patterns);
         if(!compile_result.has_value())
             return std::unexpected(plugin::parse_error{compile_result.error().diagnostics});
         return plugin::parse_ok{compile_result.value().ntta, compile_result.value().diagnostics};
     }
 
     auto parser::parse_model(const Buffer& buffer) -> plugin::parse_result {
-        return std::unexpected(plugin::parse_error({compiler->diag(not_implemented_yet())}));
+        auto compiler = create_compiler();
+        return std::unexpected(plugin::parse_error{std::vector<Diagnostic>{compiler.diag(not_implemented_yet())}});
+    }
+
+    auto parser::create_compiler() -> compiler {
+        return compiler{_scanner, _parser, _semantic_analyzer, _optimizer, _generator};
     }
 }
 

src/parser/hawk/huppaal/parser.h

@@ -24,7 +24,7 @@
 namespace aaltitoad::hawk::huppaal {
     auto create_parser() -> plugin::parser*;
 
-    class huppaal_scanner : public aaltitoad::hawk::scanner{
+    class huppaal_scanner : public aaltitoad::hawk::scanner {
     public:
         ~huppaal_scanner() override = default;
         auto scan(compiler& ctx,
@@ -41,14 +41,31 @@ namespace aaltitoad::hawk::huppaal {
         auto parse(compiler& ctx, const scanner::ok& stream) const noexcept -> std::expected<parser::ok, error_t> override;
     };
 
+    class huppaal_semantic_analyzer : public aaltitoad::hawk::semantic_analyzer {
+    public:
+        ~huppaal_semantic_analyzer() override = default;
+        auto analyze(compiler& ctx, const parser::ok& ast) const noexcept -> std::expected<parser::ok, error_t> override;
+    };
+
+    class huppaal_generator : public aaltitoad::hawk::generator {
+    public:
+        ~huppaal_generator() override = default;
+        auto generate(compiler& ctx, const parser::ok& ast) const noexcept -> std::expected<ntta_t, error_t> override;
+    };
+
     class parser : public plugin::parser {
     public:
-        parser();
         ~parser() override = default;
         auto parse_files(const std::vector<std::string>& files, const std::vector<std::string>& ignore_patterns) -> plugin::parse_result override;
         auto parse_model(const Buffer& buffer) -> plugin::parse_result override;
     private:
-        std::unique_ptr<compiler> compiler;
+        auto create_compiler() -> compiler;
+
+        huppaal_scanner _scanner;
+        huppaal_parser _parser;
+        huppaal_semantic_analyzer _semantic_analyzer;
+        nothing_optimizer _optimizer;
+        huppaal_generator _generator;
     };
 }
 

src/parser/hawk/scoped_template_builder/scoped_template_builder.cpp

@@ -256,7 +256,7 @@ namespace aaltitoad::hawk {
         builder.add_symbols(internal_symbols);
         builder.add_external_symbols(external_symbols);
         return plugin::parse_ok{
-            .ntta=std::unique_ptr<ntta_t>{builder.build_heap()},
+            .ntta=builder.build(),
             .diagnostics=diagnostics
         };
     }

src/plugin_system/parser.h

@@ -2,7 +2,6 @@
 #define AALTITOAD_PARSER_H
 #include "lsp.pb.h"
 #include "ntta/tta.h"
-#include <memory>
 #include <expected>
 
 namespace aaltitoad::plugin {