feat! breaking changes on necti sources.

Signed-off-by: Amlal El Mahrouss <amlal@nekernel.org>

1 files changed, 0 insertions, 893 deletions

diff --git a/dev/CompilerKit/src/Macro/CPlusPlusPreprocessor.cc b/dev/CompilerKit/src/Macro/CPlusPlusPreprocessor.cc
deleted file mode 100644
index ed53782..0000000
--- a/dev/CompilerKit/src/Macro/CPlusPlusPreprocessor.cc
+++ /dev/null
@@ -1,893 +0,0 @@
-/*
- *	========================================================
- *
- *	C++ Preprocessor Driver
- * 	Copyright (C) 2024-2025 Amlal El Mahrouss, Licensed under the Apache 2.0 license.
- *
- * 	========================================================
- */
-
-/// BUGS: 0
-
-#include <CompilerKit/ErrorID.h>
-#include <CompilerKit/Frontend.h>
-#include <algorithm>
-#include <filesystem>
-#include <fstream>
-#include <iostream>
-#include <stdexcept>
-#include <vector>
-
-#define kMacroPrefix '#'
-
-/// @author Amlal El Mahrouss (amlal@nekernel.org)
-/// @file CPlusPlusPreprocessor.cc
-/// @brief Preprocessor.
-
-typedef Int32 (*bpp_parser_fn_t)(CompilerKit::STLString& line, std::ifstream& hdr_file,
-                                 std::ofstream& pp_out);
-
-/////////////////////////////////////////////////////////////////////////////////////////
-
-// @brief Preprocessor internal types.
-
-/////////////////////////////////////////////////////////////////////////////////////////
-
-namespace Detail {
-enum {
-  kInvalid = 0,
-  kEqual   = 100,
-  kGreaterEqThan,
-  kLesserEqThan,
-  kGreaterThan,
-  kLesserThan,
-  kNotEqual,
-  kCount = 6,
-};
-
-struct bpp_macro_condition final {
-  int32_t                fType;
-  CompilerKit::STLString fTypeName;
-
-  void Print() {
-    std::cout << "type: " << fType << "\n";
-    std::cout << "type_name: " << fTypeName << "\n";
-  }
-};
-
-struct bpp_macro final {
-  std::vector<CompilerKit::STLString> fArgs;
-  CompilerKit::STLString              fName;
-  CompilerKit::STLString              fValue;
-
-  void Print() {
-    std::cout << "name: " << fName << "\n";
-    std::cout << "value: " << fValue << "\n";
-
-    for (auto& arg : fArgs) {
-      std::cout << "arg: " << arg << "\n";
-    }
-  }
-};
-}  // namespace Detail
-
-static std::vector<CompilerKit::STLString> kFiles;
-static std::vector<Detail::bpp_macro>      kMacros;
-static std::vector<CompilerKit::STLString> kIncludes;
-
-static CompilerKit::STLString kWorkingDir = "";
-
-/////////////////////////////////////////////////////////////////////////////////////////
-
-// @name bpp_parse_if_condition
-// @brief parse #if condition
-
-/////////////////////////////////////////////////////////////////////////////////////////
-
-int32_t bpp_parse_if_condition(Detail::bpp_macro_condition& cond, Detail::bpp_macro& macro,
-                               bool& inactive_code, bool& defined,
-                               CompilerKit::STLString& macro_str) {
-  if (cond.fType == Detail::kEqual) {
-    auto substr_macro = macro_str.substr(macro_str.find(macro.fName) + macro.fName.size());
-
-    if (substr_macro.find(macro.fValue) != CompilerKit::STLString::npos) {
-      if (macro.fValue == "0") {
-        defined       = false;
-        inactive_code = true;
-
-        return 1;
-      }
-
-      defined       = true;
-      inactive_code = false;
-
-      return 1;
-    }
-  } else if (cond.fType == Detail::kNotEqual) {
-    auto substr_macro = macro_str.substr(macro_str.find(macro.fName) + macro.fName.size());
-
-    if (substr_macro.find(macro.fName) != CompilerKit::STLString::npos) {
-      if (substr_macro.find(macro.fValue) != CompilerKit::STLString::npos) {
-        defined       = false;
-        inactive_code = true;
-
-        return 1;
-      }
-
-      defined       = true;
-      inactive_code = false;
-
-      return 1;
-    }
-
-    return 0;
-  }
-
-  auto substr_macro = macro_str.substr(macro_str.find(macro.fName) + macro.fName.size());
-
-  CompilerKit::STLString number;
-
-  for (auto& macro_num : kMacros) {
-    if (substr_macro.find(macro_num.fName) != CompilerKit::STLString::npos) {
-      for (size_t i = 0; i < macro_num.fName.size(); ++i) {
-        if (isdigit(macro_num.fValue[i])) {
-          number += macro_num.fValue[i];
-        } else {
-          number.clear();
-          break;
-        }
-      }
-
-      break;
-    }
-  }
-
-  size_t y = 2;
-
-  /* last try */
-  for (; y < macro_str.size(); y++) {
-    if (isdigit(macro_str[y])) {
-      for (size_t x = y; x < macro_str.size(); x++) {
-        if (macro_str[x] == ' ') break;
-
-        number += macro_str[x];
-      }
-
-      break;
-    }
-  }
-
-  size_t rhs = atol(macro.fValue.c_str());
-  size_t lhs = atol(number.c_str());
-
-  if (lhs == 0) {
-    number.clear();
-    ++y;
-
-    for (; y < macro_str.size(); y++) {
-      if (isdigit(macro_str[y])) {
-        for (size_t x = y; x < macro_str.size(); x++) {
-          if (macro_str[x] == ' ') break;
-
-          number += macro_str[x];
-        }
-
-        break;
-      }
-    }
-
-    lhs = atol(number.c_str());
-  }
-
-  if (cond.fType == Detail::kGreaterThan) {
-    if (lhs < rhs) {
-      defined       = true;
-      inactive_code = false;
-
-      return 1;
-    }
-
-    return 0;
-  }
-
-  if (cond.fType == Detail::kGreaterEqThan) {
-    if (lhs <= rhs) {
-      defined       = true;
-      inactive_code = false;
-
-      return 1;
-    }
-
-    return 0;
-  }
-
-  if (cond.fType == Detail::kLesserEqThan) {
-    if (lhs >= rhs) {
-      defined       = true;
-      inactive_code = false;
-
-      return 1;
-    }
-
-    return 0;
-  }
-
-  if (cond.fType == Detail::kLesserThan) {
-    if (lhs > rhs) {
-      defined       = true;
-      inactive_code = false;
-
-      return 1;
-    }
-
-    return 0;
-  }
-
-  return 0;
-}
-
-/////////////////////////////////////////////////////////////////////////////////////////
-
-// @brief stores every included file here.
-
-/////////////////////////////////////////////////////////////////////////////////////////
-
-std::vector<CompilerKit::STLString> kAllIncludes;
-
-/////////////////////////////////////////////////////////////////////////////////////////
-
-// @name bpp_parse_file
-// @brief parse file to preprocess it.
-
-/////////////////////////////////////////////////////////////////////////////////////////
-
-void bpp_parse_file(std::ifstream& hdr_file, std::ofstream& pp_out) {
-  CompilerKit::STLString hdr_line;
-  CompilerKit::STLString line_after_include;
-
-  bool inactive_code = false;
-  bool defined       = false;
-
-  try {
-    while (std::getline(hdr_file, hdr_line)) {
-      if (inactive_code) {
-        if (hdr_line.find("#endif") == CompilerKit::STLString::npos) {
-          continue;
-        } else if (hdr_line[0] == kMacroPrefix &&
-                   hdr_line.find("#endif") != CompilerKit::STLString::npos) {
-          inactive_code = false;
-        }
-      }
-
-      if (hdr_line.find("*/") != CompilerKit::STLString::npos) {
-        hdr_line.erase(hdr_line.find("*/"), strlen("*/"));
-      }
-
-      if (hdr_line.find("/*") != CompilerKit::STLString::npos) {
-        inactive_code = true;
-
-        // get rid of comment.
-        hdr_line.erase(hdr_line.find("/*"));
-      }
-
-      if (hdr_line[0] == kMacroPrefix && hdr_line.find("endif") != CompilerKit::STLString::npos) {
-        if (!defined && inactive_code) {
-          inactive_code = false;
-          defined       = false;
-
-          continue;
-        }
-
-        continue;
-      }
-
-      if (!defined && inactive_code) {
-        continue;
-      }
-
-      if (defined && inactive_code) {
-        continue;
-      }
-
-      for (auto macro : kMacros) {
-        if (CompilerKit::find_word(hdr_line, macro.fName)) {
-          if (hdr_line.substr(hdr_line.find(macro.fName)).find(macro.fName + '(') !=
-              CompilerKit::STLString::npos) {
-            if (!macro.fArgs.empty()) {
-              CompilerKit::STLString              symbol_val = macro.fValue;
-              std::vector<CompilerKit::STLString> args;
-
-              size_t x_arg_indx = 0;
-
-              CompilerKit::STLString line_after_define = hdr_line;
-              CompilerKit::STLString str_arg;
-
-              if (line_after_define.find("(") != CompilerKit::STLString::npos) {
-                line_after_define.erase(0, line_after_define.find("(") + 1);
-
-                for (auto& subc : line_after_define) {
-                  if (subc == ' ' || subc == '\t') continue;
-
-                  if (subc == ',' || subc == ')') {
-                    if (str_arg.empty()) continue;
-
-                    args.push_back(str_arg);
-
-                    str_arg.clear();
-
-                    continue;
-                  }
-
-                  str_arg.push_back(subc);
-                }
-              }
-
-              for (auto arg : macro.fArgs) {
-                if (symbol_val.find(macro.fArgs[x_arg_indx]) != CompilerKit::STLString::npos) {
-                  symbol_val.replace(symbol_val.find(macro.fArgs[x_arg_indx]),
-                                     macro.fArgs[x_arg_indx].size(), args[x_arg_indx]);
-                  ++x_arg_indx;
-                } else {
-                  throw std::runtime_error("cppdrv: Internal error.");
-                }
-              }
-
-              auto len = macro.fName.size();
-              len += symbol_val.size();
-              len += 2;  // ( and )
-
-              hdr_line.erase(hdr_line.find(")"), 1);
-
-              hdr_line.replace(hdr_line.find(hdr_line.substr(hdr_line.find(macro.fName + '('))),
-                               len, symbol_val);
-            } else {
-              auto value = macro.fValue;
-
-              hdr_line.replace(hdr_line.find(macro.fName), macro.fName.size(), value);
-            }
-          }
-        }
-      }
-
-      if (hdr_line[0] == kMacroPrefix && hdr_line.find("define ") != CompilerKit::STLString::npos) {
-        auto line_after_define = hdr_line.substr(hdr_line.find("define ") + strlen("define "));
-
-        CompilerKit::STLString macro_value;
-        CompilerKit::STLString macro_key;
-
-        std::size_t pos = 0UL;
-
-        std::vector<CompilerKit::STLString> args;
-        bool                                on_args = false;
-
-        for (auto& ch : line_after_define) {
-          ++pos;
-
-          if (ch == '(') {
-            on_args = true;
-            continue;
-          }
-
-          if (ch == ')') {
-            on_args = false;
-            continue;
-          }
-
-          if (ch == '\\') continue;
-
-          if (on_args) continue;
-
-          if (ch == ' ') {
-            for (size_t i = pos; i < line_after_define.size(); i++) {
-              macro_value += line_after_define[i];
-            }
-
-            break;
-          }
-
-          macro_key += ch;
-        }
-
-        CompilerKit::STLString str;
-
-        if (line_after_define.find("(") != CompilerKit::STLString::npos) {
-          line_after_define.erase(0, line_after_define.find("(") + 1);
-
-          for (auto& subc : line_after_define) {
-            if (subc == ',' || subc == ')') {
-              if (str.empty()) continue;
-
-              args.push_back(str);
-
-              str.clear();
-
-              continue;
-            }
-
-            str.push_back(subc);
-          }
-        }
-
-        Detail::bpp_macro macro;
-
-        macro.fArgs  = args;
-        macro.fName  = macro_key;
-        macro.fValue = macro_value;
-
-        kMacros.emplace_back(macro);
-
-        continue;
-      }
-
-      if (hdr_line[0] != kMacroPrefix) {
-        if (inactive_code) {
-          continue;
-        }
-
-        pp_out << hdr_line << std::endl;
-
-        continue;
-      }
-
-      if (hdr_line[0] == kMacroPrefix && hdr_line.find("ifndef") != CompilerKit::STLString::npos) {
-        auto line_after_ifndef = hdr_line.substr(hdr_line.find("ifndef") + strlen("ifndef") + 1);
-        CompilerKit::STLString macro;
-
-        for (auto& ch : line_after_ifndef) {
-          if (ch == ' ') {
-            break;
-          }
-
-          macro += ch;
-        }
-
-        if (macro == "0") {
-          defined       = true;
-          inactive_code = false;
-          continue;
-        }
-
-        if (macro == "1") {
-          defined       = false;
-          inactive_code = true;
-
-          continue;
-        }
-
-        bool found = false;
-
-        defined       = true;
-        inactive_code = false;
-
-        for (auto& macro_ref : kMacros) {
-          if (hdr_line.find(macro_ref.fName) != CompilerKit::STLString::npos) {
-            found = true;
-            break;
-          }
-        }
-
-        if (found) {
-          defined       = false;
-          inactive_code = true;
-
-          continue;
-        }
-      } else if (hdr_line[0] == kMacroPrefix &&
-                 hdr_line.find("else") != CompilerKit::STLString::npos) {
-        if (!defined && inactive_code) {
-          inactive_code = false;
-          defined       = true;
-
-          continue;
-        } else {
-          defined       = false;
-          inactive_code = true;
-
-          continue;
-        }
-      } else if (hdr_line[0] == kMacroPrefix &&
-                 hdr_line.find("ifdef") != CompilerKit::STLString::npos) {
-        auto line_after_ifdef = hdr_line.substr(hdr_line.find("ifdef") + strlen("ifdef") + 1);
-        CompilerKit::STLString macro;
-
-        for (auto& ch : line_after_ifdef) {
-          if (ch == ' ') {
-            break;
-          }
-
-          macro += ch;
-        }
-
-        if (macro == "0") {
-          defined       = false;
-          inactive_code = true;
-
-          continue;
-        }
-
-        if (macro == "1") {
-          defined       = true;
-          inactive_code = false;
-
-          continue;
-        }
-
-        defined       = false;
-        inactive_code = true;
-
-        for (auto& macro_ref : kMacros) {
-          if (hdr_line.find(macro_ref.fName) != CompilerKit::STLString::npos) {
-            defined       = true;
-            inactive_code = false;
-
-            break;
-          }
-        }
-      } else if (hdr_line[0] == kMacroPrefix &&
-                 hdr_line.find("if") != CompilerKit::STLString::npos) {
-        inactive_code = true;
-
-        std::vector<Detail::bpp_macro_condition> bpp_macro_condition_list = {
-            {
-                .fType     = Detail::kEqual,
-                .fTypeName = "==",
-            },
-            {
-                .fType     = Detail::kNotEqual,
-                .fTypeName = "!=",
-            },
-            {
-                .fType     = Detail::kLesserThan,
-                .fTypeName = "<",
-            },
-            {
-                .fType     = Detail::kGreaterThan,
-                .fTypeName = ">",
-            },
-            {
-                .fType     = Detail::kLesserEqThan,
-                .fTypeName = "<=",
-            },
-            {
-                .fType     = Detail::kGreaterEqThan,
-                .fTypeName = ">=",
-            },
-        };
-
-        int32_t good_to_go = 0;
-
-        for (auto& macro_condition : bpp_macro_condition_list) {
-          if (hdr_line.find(macro_condition.fTypeName) != CompilerKit::STLString::npos) {
-            for (auto& found_macro : kMacros) {
-              if (hdr_line.find(found_macro.fName) != CompilerKit::STLString::npos) {
-                good_to_go = bpp_parse_if_condition(macro_condition, found_macro, inactive_code,
-                                                    defined, hdr_line);
-
-                break;
-              }
-            }
-          }
-        }
-
-        if (good_to_go) continue;
-
-        auto line_after_if = hdr_line.substr(hdr_line.find("if") + strlen("if") + 1);
-        CompilerKit::STLString macro;
-
-        for (auto& ch : line_after_if) {
-          if (ch == ' ') {
-            break;
-          }
-
-          macro += ch;
-        }
-
-        if (macro == "0") {
-          defined       = false;
-          inactive_code = true;
-          continue;
-        }
-
-        if (macro == "1") {
-          defined       = true;
-          inactive_code = false;
-
-          continue;
-        }
-
-        // last try, is it defined to be one?
-        for (auto& macro_ref : kMacros) {
-          if (macro_ref.fName.find(macro) != CompilerKit::STLString::npos &&
-              macro_ref.fValue == "1") {
-            inactive_code = false;
-            defined       = true;
-
-            break;
-          }
-        }
-      } else if (hdr_line[0] == kMacroPrefix &&
-                 hdr_line.find("warning") != CompilerKit::STLString::npos) {
-        auto line_after_warning = hdr_line.substr(hdr_line.find("warning") + strlen("warning") + 1);
-        CompilerKit::STLString message;
-
-        for (auto& ch : line_after_warning) {
-          if (ch == '\r' || ch == '\n') {
-            break;
-          }
-
-          message += ch;
-        }
-
-        std::cout << "warn: " << message << std::endl;
-      } else if (hdr_line[0] == kMacroPrefix &&
-                 hdr_line.find("error") != CompilerKit::STLString::npos) {
-        auto line_after_warning = hdr_line.substr(hdr_line.find("error") + strlen("error") + 1);
-        CompilerKit::STLString message;
-
-        for (auto& ch : line_after_warning) {
-          if (ch == '\r' || ch == '\n') {
-            break;
-          }
-
-          message += ch;
-        }
-
-        throw std::runtime_error("error: " + message);
-      } else if (hdr_line[0] == kMacroPrefix &&
-                 hdr_line.find("include ") != CompilerKit::STLString::npos) {
-        line_after_include = hdr_line.substr(hdr_line.find("include ") + strlen("include "));
-
-      kIncludeFile:
-        auto it = std::find(kAllIncludes.cbegin(), kAllIncludes.cend(), line_after_include);
-
-        if (it != kAllIncludes.cend()) {
-          continue;
-        }
-
-        CompilerKit::STLString path;
-
-        kAllIncludes.push_back(line_after_include);
-
-        bool enable    = false;
-        bool not_local = false;
-
-        for (auto& ch : line_after_include) {
-          if (ch == ' ') continue;
-
-          if (ch == '<') {
-            not_local = true;
-            enable    = true;
-
-            continue;
-          }
-
-          if (ch == '\"') {
-            not_local = false;
-            enable    = true;
-            continue;
-          }
-
-          if (enable) {
-            path += ch;
-          }
-        }
-
-        if (not_local) {
-          bool open = false;
-
-          if (path.ends_with('>')) {
-            path.erase(path.find('>'));
-          }
-
-          if (path.ends_with('"')) {
-            path.erase(path.find('"'));
-          }
-
-          for (auto& include : kIncludes) {
-            CompilerKit::STLString header_path = include;
-            header_path.push_back('/');
-            header_path += path;
-
-            std::ifstream header(header_path);
-
-            if (!header.is_open()) continue;
-
-            open = true;
-
-            bpp_parse_file(header, pp_out);
-
-            break;
-          }
-
-          if (!open) {
-            throw std::runtime_error("cppdrv: no such include file: " + path);
-          }
-        } else {
-          std::ifstream header(path);
-
-          if (!header.is_open()) throw std::runtime_error("cppdrv: no such include file: " + path);
-
-          bpp_parse_file(header, pp_out);
-        }
-      } else {
-        std::cerr << ("cppdrv: unknown pre-processor directive, " + hdr_line) << "\n";
-        continue;
-      }
-    }
-  } catch (std::out_of_range& oor) {
-    return;
-  }
-}
-
-/////////////////////////////////////////////////////////////////////////////////////////
-
-// @brief main entrypoint of app.
-
-/////////////////////////////////////////////////////////////////////////////////////////
-
-NECTI_MODULE(CPlusPlusPreprocessorMain) {
-  try {
-    bool skip        = false;
-    bool double_skip = false;
-
-    Detail::bpp_macro macro_1;
-
-    macro_1.fName  = "__true";
-    macro_1.fValue = "1";
-
-    kMacros.push_back(macro_1);
-
-    Detail::bpp_macro macro_unreachable;
-
-    macro_unreachable.fName  = "__unreachable";
-    macro_unreachable.fValue = "__compilerkit_unreachable";
-
-    kMacros.push_back(macro_unreachable);
-
-    Detail::bpp_macro macro_unused;
-
-    macro_unreachable.fName  = "__unused";
-    macro_unreachable.fValue = "__compilerkit_unused";
-
-    kMacros.push_back(macro_unused);
-
-    Detail::bpp_macro macro_0;
-
-    macro_0.fName  = "__false";
-    macro_0.fValue = "0";
-
-    kMacros.push_back(macro_0);
-
-    Detail::bpp_macro macro_zka;
-
-    macro_zka.fName  = "__NECTI__";
-    macro_zka.fValue = "1";
-
-    kMacros.push_back(macro_zka);
-
-    Detail::bpp_macro macro_cxx;
-
-    macro_cxx.fName  = "__cplusplus";
-    macro_cxx.fValue = "202302L";
-
-    kMacros.push_back(macro_cxx);
-
-    Detail::bpp_macro macro_size_t;
-    macro_size_t.fName  = "__SIZE_TYPE__";
-    macro_size_t.fValue = "unsigned long long int";
-
-    kMacros.push_back(macro_size_t);
-
-    macro_size_t.fName  = "__UINT32_TYPE__";
-    macro_size_t.fValue = "unsigned int";
-
-    kMacros.push_back(macro_size_t);
-
-    macro_size_t.fName  = "__UINTPTR_TYPE__";
-    macro_size_t.fValue = "unsigned long long int";
-
-    kMacros.push_back(macro_size_t);
-
-    for (auto index = 1UL; index < argc; ++index) {
-      if (skip) {
-        skip = false;
-        continue;
-      }
-
-      if (double_skip) {
-        ++index;
-        double_skip = false;
-        continue;
-      }
-
-      if (argv[index][0] == '-') {
-        if (strcmp(argv[index], "-cpp-ver") == 0) {
-          printf("%s\n",
-                 "NeKernel Preprocessor Driver v1.11, (c) Amlal El Mahrouss 2024-2025 all rights "
-                 "reserved.");
-
-          return NECTI_SUCCESS;
-        }
-
-        if (strcmp(argv[index], "-cpp-help") == 0) {
-          printf("%s\n",
-                 "NeKernel Preprocessor Driver v1.11, (c) Amlal El Mahrouss 2024-2025 all rights "
-                 "reserved.");
-          printf("%s\n", "-cpp-working-dir <path>: set directory to working path.");
-          printf("%s\n", "-cpp-include-dir <path>: add directory to include path.");
-          printf("%s\n", "-cpp-def <name> <value>: define a macro.");
-          printf("%s\n", "-cpp-ver: print the version.");
-          printf("%s\n", "-cpp-help: show help (this current command).");
-
-          return NECTI_SUCCESS;
-        }
-
-        if (strcmp(argv[index], "-cpp-include-dir") == 0) {
-          CompilerKit::STLString inc = argv[index + 1];
-
-          skip = true;
-
-          kIncludes.push_back(inc);
-        }
-
-        if (strcmp(argv[index], "-cpp-working-dir") == 0) {
-          CompilerKit::STLString inc = argv[index + 1];
-          skip                       = true;
-          kWorkingDir                = inc;
-        }
-
-        if (strcmp(argv[index], "-cpp-def") == 0 && argv[index + 1] != nullptr &&
-            argv[index + 2] != nullptr) {
-          CompilerKit::STLString macro_key = argv[index + 1];
-
-          CompilerKit::STLString macro_value;
-          bool                   is_string = false;
-
-          for (int argv_find_len = 0; argv_find_len < strlen(argv[index]); ++argv_find_len) {
-            if (!isdigit(argv[index][argv_find_len])) {
-              is_string = true;
-              macro_value += "\"";
-
-              break;
-            }
-          }
-
-          macro_value += argv[index + 2];
-
-          if (is_string) macro_value += "\"";
-
-          Detail::bpp_macro macro;
-          macro.fName  = macro_key;
-          macro.fValue = macro_value;
-
-          kMacros.push_back(macro);
-
-          double_skip = true;
-        }
-
-        continue;
-      }
-
-      kFiles.emplace_back(argv[index]);
-    }
-
-    if (kFiles.empty()) return NECTI_EXEC_ERROR;
-
-    for (auto& file : kFiles) {
-      if (!std::filesystem::exists(file)) continue;
-
-      std::ifstream file_descriptor(file);
-      std::ofstream file_descriptor_pp(file + ".pp");
-
-      bpp_parse_file(file_descriptor, file_descriptor_pp);
-    }
-
-    return NECTI_SUCCESS;
-  } catch (const std::runtime_error& e) {
-    std::cout << e.what() << '\n';
-  }
-
-  return NECTI_EXEC_ERROR;
-}
-
-// Last rev 8-1-24