This commit cleans and modernizes the code base of LIEF.

Among the changes:

- It removes the ``and, or, not`` keywords
- It updates the Documentation
- It moves the internal structures in the ``details::`` namespace

api/python/MachO/objects/pyThreadCommand.cpp

@@ -37,31 +37,60 @@ using setter_t = void (ThreadCommand::*)(T);
 template<>
 void create<ThreadCommand>(py::module& m) {
 
-  py::class_<ThreadCommand, LoadCommand>(m, "ThreadCommand")
+  py::class_<ThreadCommand, LoadCommand>(m, "ThreadCommand",
+      R"delim(
+      Class that represents the LC_THREAD / LC_UNIXTHREAD commands and that
+      can be used to get the binary entrypoint when the LC_MAIN (MainCommand) is not present
+
+      Generally speaking, this command aims at defining the original state
+      of the main thread which includes the registers' values
+      )delim")
 
     .def_property("flavor",
         static_cast<getter_t<uint32_t>>(&ThreadCommand::flavor),
         static_cast<setter_t<uint32_t>>(&ThreadCommand::flavor),
-        "",
-        py::return_value_policy::reference_internal)
+        R"delim(
+        Integer that defines a special *flavor* for the thread.
+
+        The meaning of this value depends on the :attr:`~lief.MachO.ThreadCommand.architecture`.
+        The list of the values can be found in the XNU kernel files:
+
+        - xnu/osfmk/mach/arm/thread_status.h  for the ARM/AArch64 architectures
+        - xnu/osfmk/mach/i386/thread_status.h for the x86/x86-64 architectures
+        )delim")
 
 
     .def_property("state",
         static_cast<getter_t<const std::vector<uint8_t>&>>(&ThreadCommand::state),
         static_cast<setter_t<const std::vector<uint8_t>&>>(&ThreadCommand::state),
-        "",
-        py::return_value_policy::reference_internal)
+        R"delim(
+        The actual thread state as a vector of bytes. Depending on the architecture(),
+        these data can be casted into x86_thread_state_t, x86_thread_state64_t, ...
+        )delim")
 
 
     .def_property("count",
         static_cast<getter_t<uint32_t>>(&ThreadCommand::count),
         static_cast<setter_t<uint32_t>>(&ThreadCommand::count),
-        "",
-        py::return_value_policy::reference_internal)
+        R"delim(
+        Size of the thread state data with 32-bits alignment.
+
+        This value should match len(:attr:`~lief.MachO.ThreadCommand.state`)
+        )delim")
 
     .def_property_readonly("pc",
         static_cast<getter_t<uint64_t>>(&ThreadCommand::pc),
-        py::return_value_policy::reference_internal)
+        R"delim(
+        Return the initial Program Counter regardless of the underlying architecture.
+        This value, when non null, can be used to determine the binary's entrypoint.
+
+        Underneath, it works by looking for the PC register value in the :attr:`~lief.MachO.ThreadCommand.state` data
+        )delim")
+
+    .def_property("architecture",
+        static_cast<getter_t<CPU_TYPES>>(&ThreadCommand::architecture),
+        static_cast<setter_t<CPU_TYPES>>(&ThreadCommand::architecture),
+        "The CPU architecture that is targeted by this ThreadCommand")
 
     .def("__eq__", &ThreadCommand::operator==)
     .def("__ne__", &ThreadCommand::operator!=)