code cleanup

pya2l/a2lparser.py

@@ -351,7 +351,11 @@ def parse(
         self.db = model.A2LDatabase(str(db_fn), debug=self.debug)
         self.logger.info(f"Importing {a2l_fn!r} [{encoding}] ==> DB {db_fn!r}.")
 
-        keyword_counter, values, tables = ext.parse(str(a2l_fn), encoding, loglevel.upper())
+        keyword_counter, values, tables, aml_data = ext.parse(str(a2l_fn), encoding, loglevel.upper())
+        aml_section = model.AMLSection()
+        aml_section.text = aml_data.text
+        aml_section.parsed = aml_data.parsed
+        self.db.session.add(aml_section)
         self.counter = 0
         progress_columns = (
             SpinnerColumn(style="white"),

pya2l/a2lparser_wrapper.cpp

@@ -12,7 +12,6 @@ namespace py = pybind11;
 
 std::string ValueContainer::s_encoding{ "ascii" };
 
-// AmlData parse_aml(const std::string& aml_file_name);
 
 auto convert_loglevel(const std::string& level) -> spdlog::level::level_enum {
     spdlog::level::level_enum result = spdlog::level::level_enum::warn;
@@ -32,7 +31,6 @@ auto convert_loglevel(const std::string& level) -> spdlog::level::level_enum {
 	} else if (level == "DEBUG") {
 		result = spdlog::level::debug;
 	}
-
 	return result;
 }
 
@@ -45,7 +43,7 @@ inline auto unicode_decode(std::string_view value, const char * encoding) -> py:
     return py::reinterpret_steal<py::str>(py_s);
 }
 
-auto parse(const std::string& file_name, const std::string& encoding, const std::string& log_level) -> std::tuple<std::size_t, const ValueContainer, const std::vector<A2LParser::value_table_t>> {
+auto parse(const std::string& file_name, const std::string& encoding, const std::string& log_level) -> std::tuple<std::size_t, const ValueContainer, const std::vector<A2LParser::value_table_t>, AmlData> {
 	auto logger = create_logger("a2l", convert_loglevel(log_level));
 	Preprocessor p{ convert_loglevel(log_level) };
 	std::vector<A2LParser::value_table_t> converted_tables{};
@@ -84,7 +82,7 @@ auto parse(const std::string& file_name, const std::string& encoding, const std:
 		converted_tables.emplace_back(tpt, namet, result);
 	}
 	auto aml_data = parse_aml(fns.aml);
-    return {counter, values, converted_tables};
+    return {counter, values, converted_tables, aml_data};
 }
 
 template<typename... Ts>
@@ -96,6 +94,14 @@ struct Overload : Ts... {
 PYBIND11_MODULE(a2lparser_ext, m) {
     m.def("parse", &parse, py::return_value_policy::move);
 
+	py::class_<AmlData>(m, "AmlData")
+		.def(py::init<const std::string&, const std::string&>())
+		.def_property_readonly("text", &AmlData::get_text)
+		.def_property_readonly("parsed", [](const AmlData& self) {
+			return py::bytes(self.parsed);
+		})
+	;
+
     py::class_<ValueContainer>(m, "ValueContainer")
         .def(py::init<std::string_view>(), py::arg("name"))
         .def("get_name", &ValueContainer::get_name)

pya2l/aml/marshal.cpp

@@ -20,14 +20,14 @@ void dumps(std::stringstream& ss, std::shared_ptr<Type> tp_);
 // AMLPredefinedType
 inline void dumps(std::stringstream& ss, const AMLPredefinedType& pdt) {
     ss << to_binary<std::string>("PD");
-    auto value = static_cast<std::uint8_t>(pdt.get_pdt());	
+    auto value = static_cast<std::uint8_t>(pdt.get_pdt());
     ss << to_binary(value);
 	const auto& arr_spec = pdt.get_array_spec();
 	const std::size_t array_size = std::size(arr_spec);
 	ss << to_binary(array_size);
 	for (std::uint32_t arr : arr_spec) {
 		ss << to_binary<std::uint32_t>(arr);
-	}	
+	}
 }
 
 // Referrer.
@@ -58,27 +58,24 @@ inline void dumps(std::stringstream& ss, std::shared_ptr<BlockDefinition> block)
 inline void dumps(std::stringstream& ss, const Member& mem) {
     auto tp = mem.get_type();
     if (mem.is_empty()) {
-        std::cout << "mem-e\n";
         ss << false_value();
         return;
     }
     ss << true_value();
     if (tp != nullptr) {
         ss << to_binary<std::string>("T");
-
         if (tp->get_type().valueless_by_exception() == true) {
-            std::cout << "sh\n";
         } else {
             dumps(ss, tp);
-        }        
+        }
     }
-    else {       
+    else {
         const auto blk = mem.get_block();
         if (blk) {
             dumps(ss, blk);
         } else {
-            std::cout << "sb\n";
-        } 
+            // FIX-ME!
+        }
     }
 }
 
@@ -183,15 +180,13 @@ inline void dumps(std::stringstream& ss, const StructOrReferrer& sr) {
 			const auto mem = sm.get_member();
             if (mem) {
                 if (mem->is_empty()) {
-                    std::cout << "empty\n";
                     ss << false_value();
                 } else {
                     ss << true_value();
                     dumps(ss, *mem);
-                }				
+                }
 			} else {
-			    std::cout << "Signal NULL\n";
-                ss << null_pointer();               
+                ss << null_pointer();
 			}
         }
     } else if (std::holds_alternative<Referrer>(sr)) {
@@ -233,7 +228,7 @@ inline void dumps(std::stringstream& ss, std::shared_ptr<Type> tp_) {
         [&ss, &tp](auto&& arg) {
             using T = std::decay_t<decltype(arg)>;
             if constexpr (std::is_same_v<T, std::monostate>) {
-                std::cout << "std::monostate!? " << '\n';
+                // std::cout << "std::monostate!? " << '\n';
             } else if constexpr (std::is_same_v<T, AMLPredefinedType>) {
                 dumps(ss, arg);
             } else if constexpr (std::is_same_v<T, EnumerationOrReferrer>) {
@@ -252,7 +247,7 @@ inline void dumps(std::stringstream& ss, std::shared_ptr<Type> tp_) {
 
 // Typedefinition
 inline void dumps(std::stringstream& ss, std::shared_ptr<TypeDefinition> type_def) {
-    auto tp = type_def->get_type();   
+    auto tp = type_def->get_type();
     dumps(ss, tp);
 }
 

pya2l/aml/parser.hpp

@@ -6,6 +6,15 @@
 struct AmlData {
     std::string text;
     std::string parsed;
+
+	const std::string get_text() const noexcept {
+		return text;
+	}
+
+	const std::string get_parsed() const noexcept {
+		return parsed;
+	}
+
 };
 
 AmlData parse_aml(const std::string& aml_file_name);