winrt-runtime 4.0.0__tar.gz → 4.0.1__tar.gz

{winrt_runtime-4.0.0/python/winrt_runtime.egg-info → winrt_runtime-4.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: winrt-runtime
-Version: 4.0.0
+Version: 4.0.1
 Summary: The runtime that every PyWinRT projection package runs on
 License-Expression: MIT
 Project-URL: Documentation, https://pywinrt.readthedocs.io

{winrt_runtime-4.0.0 → winrt_runtime-4.0.1/python/winrt_runtime.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: winrt-runtime
-Version: 4.0.0
+Version: 4.0.1
 Summary: The runtime that every PyWinRT projection package runs on
 License-Expression: MIT
 Project-URL: Documentation, https://pywinrt.readthedocs.io

{winrt_runtime-4.0.0 → winrt_runtime-4.0.1}/src/structs.cpp

@@ -995,7 +995,34 @@ namespace py::interp
     bool make_struct_type(
         projection& proj, type_entry& entry, table::type_view const& record)
     {
-        auto const layout = proj.table->get_struct_layout(record);
+        entry.fields.resize(record.field_count());
+
+        // A struct in a struct is resolved into the field before anything is
+        // laid out. Releasing one has to know what it holds and is not a place
+        // that can import a package, and the table cannot measure a struct of
+        // another namespace: it holds only an external record naming it, with
+        // no fields, so the size has to come from the entry that defines it.
+        for (uint32_t i = 0; i < record.field_count(); i++)
+        {
+            auto& field = entry.fields[i];
+
+            field.code = record.field(i).code();
+            field.type = record.field(i).type();
+
+            if (field.code == table::type_code::struct_
+                && !resolve(proj, field.type, field.info))
+            {
+                return false;
+            }
+        }
+
+        auto const layout = proj.table->get_struct_layout(
+            record,
+            [&entry](uint32_t position)
+            {
+                auto const& info = *entry.fields[position].info;
+                return table::value_layout{info.size, info.align};
+            });
 
         entry.numerics_kind = numerics::classify(entry.winrt_name);
 
@@ -1012,7 +1039,6 @@ namespace py::interp
         entry.align = layout.align;
         entry.blob_offset
             = align_up(static_cast<uint32_t>(sizeof(PyObject)), layout.align);
-        entry.fields.resize(record.field_count());
 
         std::vector<PyGetSetDef> getsets;
 
@@ -1021,9 +1047,7 @@ namespace py::interp
             auto const record_field = record.field(i);
             auto& field = entry.fields[i];
 
-            field.code = record_field.code();
             field.offset = layout.offsets[i];
-            field.type = record_field.type();
             field.declaring = &entry;
 
             pyobj_handle interned{
@@ -1048,14 +1072,6 @@ namespace py::interp
                 entry.owns_resources = true;
                 break;
             case table::type_code::struct_:
-                // A struct in a struct is resolved into the field now rather
-                // than on first use, because releasing one has to know what
-                // it holds and is not a place that can import a package.
-                if (!resolve(proj, field.type, field.info))
-                {
-                    return false;
-                }
-
                 if (field.info->owns_resources)
                 {
                     entry.owns_resources = true;

{winrt_runtime-4.0.0 → winrt_runtime-4.0.1}/src/table.cpp

@@ -359,9 +359,10 @@ namespace py::table
         return type_view{this, index};
     }
 
-    struct_layout file::get_struct_layout(type_view type) const
+    struct_layout file::get_struct_layout(
+        type_view type, struct_field_measure const& measure_struct) const
     {
-        struct_layout result{0, 1, {}};
+        struct_layout result{0, 1, {}, true};
         uint32_t offset = 0;
         auto const count = type.field_count();
 
@@ -372,9 +373,29 @@ namespace py::table
             auto const field = type.field(i);
             value_layout layout;
 
-            if (field.code() == type_code::struct_)
+            if (field.code() == type_code::struct_ && measure_struct)
             {
-                auto const nested = get_struct_layout(this->type(field.type()));
+                layout = measure_struct(i);
+            }
+            else if (field.code() == type_code::struct_)
+            {
+                auto const record = this->type(field.type());
+
+                // An external record is a name and nothing else, so measuring
+                // it here would find no fields and call the struct empty.
+                if (record.is_external())
+                {
+                    result.measured = false;
+                    return result;
+                }
+
+                auto const nested = get_struct_layout(record);
+                if (!nested.measured)
+                {
+                    result.measured = false;
+                    return result;
+                }
+
                 layout = {nested.size, nested.align};
             }
             else
@@ -1097,10 +1118,14 @@ namespace py::cpp::_winrt
                     return pyobj_handle{};
                 }
 
+                // A field at or after one this table cannot measure has no
+                // offset that the table alone can say.
                 if (!set_item(
                         item.get(),
                         "offset",
-                        PyLong_FromUnsignedLong(layout.offsets[i])))
+                        i < layout.offsets.size()
+                            ? PyLong_FromUnsignedLong(layout.offsets[i])
+                            : Py_NewRef(Py_None)))
                 {
                     return pyobj_handle{};
                 }
@@ -1290,12 +1315,20 @@ namespace py::cpp::_winrt
                 return pyobj_handle{};
             }
 
-            if (!set_item(result.get(), "size", PyLong_FromUnsignedLong(layout.size)))
+            if (!set_item(
+                    result.get(),
+                    "size",
+                    layout.measured ? PyLong_FromUnsignedLong(layout.size)
+                                    : Py_NewRef(Py_None)))
             {
                 return pyobj_handle{};
             }
 
-            if (!set_item(result.get(), "align", PyLong_FromUnsignedLong(layout.align)))
+            if (!set_item(
+                    result.get(),
+                    "align",
+                    layout.measured ? PyLong_FromUnsignedLong(layout.align)
+                                    : Py_NewRef(Py_None)))
             {
                 return pyobj_handle{};
             }

{winrt_runtime-4.0.0 → winrt_runtime-4.0.1}/src/table.h

@@ -15,6 +15,7 @@
 
 #include <cstddef>
 #include <cstdint>
+#include <functional>
 #include <stdexcept>
 #include <string>
 #include <string_view>
@@ -441,14 +442,26 @@ namespace py::table
      * Offsets are never written into the table, because a pointer is not the
      * same width on every architecture the same table serves, so they are
      * computed here from the field type codes.
+     *
+     * A struct field whose struct belongs to another namespace cannot be
+     * measured from this table, which holds only an external record naming
+     * it. Without a measure for it the layout stops there: @c measured is
+     * false, and @c offsets has an entry only for the fields before it.
      */
     struct struct_layout
     {
         uint32_t size;
         uint32_t align;
         std::vector<uint32_t> offsets;
+        bool measured;
     };
 
+    /**
+     * The size and alignment of the struct field at @p position of the struct
+     * being laid out, from what knows the field's type better than the table.
+     */
+    using struct_field_measure = std::function<value_layout(uint32_t position)>;
+
     /**
      * One namespace's table, over bytes it does not own.
      */
@@ -541,8 +554,11 @@ namespace py::table
             return guid_count_;
         }
 
-        /// Computes the layout of the struct @p type declares.
-        struct_layout get_struct_layout(type_view type) const;
+        /// Computes the layout of the struct @p type declares, measuring each
+        /// struct field with @p measure_struct if one is given and from this
+        /// table otherwise.
+        struct_layout get_struct_layout(
+            type_view type, struct_field_measure const& measure_struct = {}) const;
 
         // The accessors below are what the views are made of. They are public
         // because the views are separate classes, not because anything outside

winrt_runtime-4.0.1/version.txt

@@ -0,0 +1 @@
+4.0.1

winrt_runtime-4.0.0/version.txt

@@ -1 +0,0 @@
-4.0.0