diff --git a/README.md b/README.md
index ba116b770..b74565434 100644
--- a/README.md
+++ b/README.md
@@ -37,12 +37,27 @@ native source
`Wrappable: yes` means the semantic contract has no known readiness blockers.
x2py does not currently generate or compile a runtime wrapper.
+The [generated target datatype mapping example](docs/semantics.md#generated-linux-x86_64-mapping-example)
+shows how the GitHub Actions C and Fortran scalar types map to NumPy dtypes.
### Fortran
Recognizable Fortran files do not require an explicit language. Parse the
checked basic-subroutine fixture:
+Input (`tests/data/fortran/general/basic_subroutine.f90`):
+
+
+```fortran
+module m1
+contains
+subroutine add1(n, x)
+ integer, intent(in) :: n
+ real(kind=8), intent(inout), dimension(n) :: x
+end subroutine add1
+end module m1
+```
+
```bash
python3 -m x2py tests/data/fortran/general/basic_subroutine.f90 --parse
@@ -105,6 +120,21 @@ python3 -m x2py solver.pyi --wrap-readiness
C inputs require explicit C mode. These commands parse the checked C API
fixture, inspect semantic IR, generate its `.pyi`, and check readiness:
+Input (`tests/data/c/general/math_api.h`):
+
+
+```c
+#ifndef X2PY_GENERAL_MATH_API_H
+#define X2PY_GENERAL_MATH_API_H
+
+double norm2(int n, const double x[static 1]);
+void scale(int n, double alpha, double x[static 1]);
+double dot(int n, const double *restrict x, const double *restrict y);
+void fill_identity3(double a[static 3][3]);
+
+#endif
+```
+
```bash
python3 -m x2py tests/data/c/general/math_api.h --language c --parse
@@ -167,6 +197,10 @@ python3 -m x2py include/api.h --language c --parse \
--compiler-arg=--sysroot=/opt/sdk
```
+Compiler-backed semantic, `.pyi`, and readiness stages also measure and cache
+target datatype facts. C probing covers primitive ABI widths and signedness;
+Fortran probing resolves kind expressions and measures intrinsic storage.
+
C projects can use a compilation database:
```bash
diff --git a/docs/c_parser.md b/docs/c_parser.md
index 258e756a2..2b6723c5f 100644
--- a/docs/c_parser.md
+++ b/docs/c_parser.md
@@ -114,8 +114,9 @@ Implemented:
for direct `.i` input where linemarkers provide it
- optional `preprocessing_recipe` JSON on `CFile` output for compiler streams
generated by the shared x2py CLI
-- compiler-derived standard-library ABI probing for `size_t`, `uint32_t`,
- `time_t`, and opaque `FILE` handles through `x2py.c_type_probe`
+- compiler-derived target ABI probing for every modeled arithmetic primitive,
+ `size_t`, `uint32_t`, `time_t`, and opaque `FILE` handles through
+ `x2py.c_type_probe`, with reusable memory and persistent caches
- C directory/file-list discovery for `.c`, `.h`, and direct `.i` inputs in
explicit C mode, while leaving Fortran directory scanning unchanged
- include resolution for quoted includes relative to the current file and
@@ -265,27 +266,31 @@ entry. Parsed declarations from compiler or direct `.i` input keep mapped
source locations; direct `.i` files also expose `preprocessed_source_path` and
mapped `original_source_paths` where available.
-## Standard Type ABI Probe
+## C Type ABI Probe
-Types introduced by standard headers are not portable primitive aliases.
-`size_t`, `uint32_t`, and `time_t` may depend on the compiler target, and
-`FILE` should remain an opaque library handle rather than exposing private
-library layout. Raw parsing therefore preserves unresolved typedef-name uses
-instead of hard-coding an ABI.
+C primitive spellings and types introduced by standard headers are target
+facts. Plain `char` signedness, `long` width, `long double` representation,
+`size_t`, and `time_t` can vary with compiler target and flags. `FILE` should
+remain an opaque library handle rather than exposing private library layout.
+Raw parsing therefore remains source-faithful instead of embedding an ABI.
-For C semantic conversion, `x2py.c_type_probe` compiles and runs a small
-C11 query program under an exact compiler and emits target-specific JSON:
+For direct compiler-backed C semantic, `.pyi`, and readiness stages, the shared
+CLI automatically compiles and runs a small C11 query under the selected
+compiler. The standalone command emits the same target-specific report:
```bash
-python -m x2py.c_type_probe --compiler /usr/bin/gcc-13 --std c11
+python3 -m x2py.c_type_probe --compiler /usr/bin/gcc-13 --std c11
```
The report records arithmetic category, underlying C spelling, bit width, and
-alignment for builtin C `int`, `size_t`, available `uint32_t`, and `time_t`; it
-records opaque handle and pointer ABI facts for `FILE`. It also retains the
-generated C source and exact compile/run commands. Semantic conversion keeps
-the name `Int` for builtin C `int` and stores the measured concrete dtype and
-probe fact separately.
+alignment for all modeled primitive integer, real, and complex types plus
+`size_t`, available `uint32_t`, and `time_t`. It records plain `char`
+signedness, real mantissa precision and exponent range, and opaque handle and
+pointer ABI facts for `FILE`. It also retains the generated C source and exact
+compile/run commands. Semantic conversion keeps the name `Int` for builtin C
+`int`, stores its measured concrete dtype separately, and maps other primitives
+to the measured target width. Unsupported measured widths produce an explicit
+semantic readiness blocker.
The probe must be run with the same target profile as the source being parsed.
It carries `-I`, `-D`, `-U`, and `--compiler-arg` options into the compile
@@ -295,12 +300,36 @@ is retained as provenance; the generated query is compiled as C11 because it
uses C11 `_Generic` and `_Alignof`. If a standard-selection flag affects the
target profile and is compatible with the probe source, pass it through
`--compiler-arg` so it is part of the actual compile command.
-The probe does not consume `compile_commands.json` directly; if parser
-preprocessing uses a compile database, pass the selected compiler and
-target-relevant flags from the matching entry to the probe explicitly.
-For cross targets, provide a runner, for example `--runner=qemu-aarch64
---runner=-L --runner=/opt/aarch64-sysroot`.
+Automatic results are cached in memory and persistently. The cache key includes
+the probe schema/source, resolved compiler binary identity, target flags,
+includes, defines, undefines, requested standard, working directory,
+target-related compiler environment, and runner executable/arguments. The
+default persistent location is `$XDG_CACHE_HOME/x2py/c_type_probe` or
+`~/.cache/x2py/c_type_probe`; `X2PY_CACHE_DIR`,
+`--c-type-probe-cache-dir`, and standalone `--cache-dir` override it. Use
+`--refresh-c-type-probe` on the shared CLI or standalone `--refresh` after an
+external target/sysroot change that does not alter the cache key.
+
+The probe does not consume `compile_commands.json` or custom preprocessing
+templates directly because one project may contain different target recipes.
+Generate a report with the selected compiler and target-relevant flags, then
+reuse it during semantic conversion:
+
+```bash
+python3 -m x2py.c_type_probe --compiler clang \
+ --compiler-arg=--target=aarch64-linux-gnu \
+ --compiler-arg=--sysroot=/opt/aarch64-sysroot \
+ --runner=qemu-aarch64 --runner=-L --runner=/opt/aarch64-sysroot \
+ > build/aarch64-c-types.json
+
+python3 -m x2py src/api.c --language c --semantics \
+ --compile-commands build/compile_commands.json \
+ --c-type-report build/aarch64-c-types.json
+```
+
+For direct shared-CLI cross-target probing, repeat
+`--c-type-probe-runner=...` for the runner command and arguments.
The C semantic converter accepts this report as target context. The parser
model remains source-faithful and does not embed host ABI assumptions.
diff --git a/docs/developper_guide.md b/docs/developper_guide.md
index 487c4b2fd..1a38c9f4e 100644
--- a/docs/developper_guide.md
+++ b/docs/developper_guide.md
@@ -79,11 +79,12 @@ When adding a user example:
`tests/tools/test_documentation_examples.py` executes explicitly marked
`bash` CLI examples and `python` API snippets from `README.md` and Markdown
-files under `docs/`. Bash examples must be `python3 -m x2py` commands; the
-test replaces `python3` with the active test interpreter and runs them without
-a shell. It rejects shell operators, output-writing options, and options that
-select custom executables or preprocessing command templates. Python snippets
-run with the active test interpreter.
+files under `docs/`. Bash examples must be `python3 -m x2py` or
+`python3 -m x2py.type_mapping_report` commands; the test replaces `python3`
+with the active test interpreter and runs them without a shell. It rejects
+shell operators, output-writing options, and options that select custom
+executables or preprocessing command templates. Python snippets run with the
+active test interpreter.
Mark a command that only needs to exit successfully:
@@ -116,6 +117,28 @@ mark placeholder commands, snippets that modify the checkout,
environment-dependent compiler recipes, or intentionally failing diagnostic
examples.
+When a command reads a checked fixture, include its source input in the user
+documentation and verify the displayed source against the fixture:
+
+````markdown
+
+```fortran
+module m1
+...
+end module m1
+```
+````
+
+Append a target profile to an exact marker only for compiler-generated output
+that is intentionally architecture-specific:
+
+```markdown
+
+```
+
+Off-target checks are skipped. The matching profile must still run the command
+and compare its complete output.
+
Run the documentation checks directly:
```bash
@@ -157,8 +180,9 @@ implementation files.
| C parse output | `c_parser/parser.py`, `c_parser/models.py`, `c_parser/lexer.py` | `tests/parser/c/test_c_declarations_and_declarators.py`, `tests/parser/c/test_c_fixture_suite.py`, `tests/parser/c/test_c_error_fixture_suite.py` |
| CLI stage selection and output | `x2py/cli.py`, `fortran_parser/cli.py` | `tests/parser/test_cli.py` |
| Compiler preprocessing | `x2py/preprocessing.py` | `tests/parser/test_preprocessing_cli.py`, `tests/parser/test_preprocessor_and_execution_boundaries.py`, `tests/parser/c/test_c_lexer_preprocessor.py` |
-| C standard type probing | `x2py/c_type_probe.py` | `tests/parser/test_c_standard_type_probe.py` |
-| Fortran type probing | `x2py/fortran_type_probe.py` | `tests/parser/test_fortran_type_probe.py` |
+| C target ABI probing and cache | `x2py/c_type_probe.py` | `tests/parser/test_c_standard_type_probe.py` |
+| Fortran target type probing and cache | `x2py/fortran_type_probe.py` | `tests/parser/test_fortran_type_probe.py` |
+| Generated target datatype mapping examples | `x2py/type_mapping_report.py` | `tests/tools/test_type_mapping_report.py`, `tests/tools/test_documentation_examples.py` |
| Fortran to semantic IR | `semantics/fortran2ir.py`, `semantics/models.py` | `tests/semantics/test_fortran2ir.py` |
| C to semantic IR | `semantics/c2ir.py`, `semantics/models.py` | `tests/semantics/test_c2ir.py`, `tests/semantics/test_c_semantic_readiness.py` |
| `.pyi` printing | `semantics/pyi_printer.py` | `tests/semantics/test_pyi_printer.py`, `tests/semantics/test_pyi_printer_modern_example.py` |
@@ -199,9 +223,12 @@ When changing `.pyi` syntax:
User-visible datatype names are semantic names, not raw parser spellings.
Mapping happens during parser-to-IR conversion:
-- Fortran intrinsic/kind mapping lives in `semantics/fortran2ir.py`.
+- Fortran intrinsic/kind mapping and compiler storage-fact application live in
+ `semantics/fortran2ir.py`.
- C primitive, typedef, and probe-aware mapping lives in `semantics/c2ir.py`.
- The shared dtype names and storage contracts live in `semantics/models.py`.
+- Compiler-measured mapping snapshots are generated by
+ `x2py/type_mapping_report.py`.
When changing datatype mapping:
@@ -213,6 +240,18 @@ When changing datatype mapping:
4. Update [semantics.md](semantics.md), plus
[tutorial.md](tutorial.md) or [examples.md](examples.md) when the visible
user workflow or examples change.
+5. Regenerate and update the exact target mapping snapshots in
+ [semantics.md](semantics.md). The executable documentation test must match
+ the complete output of:
+
+ ```bash
+ python3 -m x2py.type_mapping_report --language c
+ python3 -m x2py.type_mapping_report --language fortran
+ ```
+
+For Fortran, keep both modern and legacy spellings in the generated report.
+Legacy numeric `type*N` forms carry fixed total storage; compiler-dependent
+default, kind, `DOUBLE PRECISION`, and `DOUBLE COMPLEX` forms use probe facts.
### Readiness Internals
diff --git a/docs/examples.md b/docs/examples.md
index 8af9a5834..32e5ad76d 100644
--- a/docs/examples.md
+++ b/docs/examples.md
@@ -20,6 +20,120 @@ The most useful small, checked examples are:
| Generated Fortran semantic interface | `tests/pyi/fixtures/general/modern_pyi_example.pyi` |
| Generated C semantic interface | `tests/pyi/fixtures/c/general/math_api.pyi` |
+The core native inputs are included here so the command examples are
+self-contained.
+
+### Basic Fortran Input
+
+
+```fortran
+module m1
+contains
+subroutine add1(n, x)
+ integer, intent(in) :: n
+ real(kind=8), intent(inout), dimension(n) :: x
+end subroutine add1
+end module m1
+```
+
+### Basic C Input
+
+
+```c
+#ifndef X2PY_GENERAL_MATH_API_H
+#define X2PY_GENERAL_MATH_API_H
+
+double norm2(int n, const double x[static 1]);
+void scale(int n, double alpha, double x[static 1]);
+double dot(int n, const double *restrict x, const double *restrict y);
+void fill_identity3(double a[static 3][3]);
+
+#endif
+```
+
+### Rich Fortran Input
+
+
+Show tests/data/fortran/general/modern_pyi_example.f90
+
+
+```fortran
+module modern_math_physics
+ implicit none
+ private
+ public :: particle, vector3, counter, init_particle, kinetic_energy, scale_vector, dot3, fill_identity3, normalize_particle
+
+ integer :: counter
+ real(8) :: hidden_scale
+
+ type :: particle
+ integer :: id
+ real(8) :: mass
+ real(8), dimension(3) :: position
+ end type particle
+
+ type :: vector3
+ real(8), dimension(3) :: values
+ end type vector3
+
+ type :: hidden_state
+ integer :: code
+ end type hidden_state
+
+contains
+
+ subroutine init_particle(p, pid, mass, x, y, z)
+ type(particle), intent(out) :: p
+ integer, intent(in) :: pid
+ real(8), intent(in) :: mass, x, y, z
+ p%id = pid
+ p%mass = mass
+ p%position = [x, y, z]
+ end subroutine init_particle
+
+ function kinetic_energy(p, vx, vy, vz) result(e)
+ type(particle), intent(in) :: p
+ real(8), intent(in) :: vx, vy, vz
+ real(8) :: e
+ e = 0.5d0 * p%mass * (vx*vx + vy*vy + vz*vz)
+ end function kinetic_energy
+
+ subroutine scale_vector(v, alpha)
+ real(8), dimension(:), intent(inout) :: v
+ real(8), intent(in) :: alpha
+ v = alpha * v
+ end subroutine scale_vector
+
+ function dot3(a, b) result(s)
+ real(8), dimension(3), intent(in) :: a, b
+ real(8) :: s
+ s = a(1)*b(1) + a(2)*b(2) + a(3)*b(3)
+ end function dot3
+
+ subroutine fill_identity3(a)
+ real(8), dimension(3,3), intent(out) :: a
+ a = 0.0d0
+ a(1,1) = 1.0d0
+ a(2,2) = 1.0d0
+ a(3,3) = 1.0d0
+ end subroutine fill_identity3
+
+ subroutine normalize_particle(p)
+ type(particle), intent(inout) :: p
+ real(8) :: n
+ n = sqrt(dot3(p%position, p%position))
+ if (n > 0.0d0) p%position = p%position / n
+ end subroutine normalize_particle
+
+ subroutine hidden_proc(x)
+ integer, intent(in) :: x
+ end subroutine hidden_proc
+
+end module modern_math_physics
+```
+
+
+
## CLI Stage Examples
### Parse
diff --git a/docs/fortran_parser.md b/docs/fortran_parser.md
index 13d337886..0ef0ec8ed 100644
--- a/docs/fortran_parser.md
+++ b/docs/fortran_parser.md
@@ -325,6 +325,7 @@ print only the first `N` items in each repeated section.
Input Fortran (`tests/data/fortran/general/basic_subroutine.f90`):
+
```fortran
module m1
contains
@@ -726,7 +727,7 @@ Focused test files by implementation area:
`tests/parser/test_fortran_error_fixture_suite.py`
- Parser JSON shape:
`tests/parser/test_fortran_json_sanity.py`
-- Fortran compiler/type probing:
+- Cached Fortran compiler/type and intrinsic-storage probing:
`tests/parser/test_fortran_type_probe.py`
- Shared CLI behavior:
`tests/parser/test_cli.py`
@@ -961,7 +962,14 @@ dup_arg.f90:1:1: error[PARSE_DUPLICATE_ARGUMENT]: Duplicate argument name 'x' in
### 6.5 Star-kind declarations
Legacy `type*N` declarations, such as `real*8`, are accepted in both fixed-form
-and modern-extension files. The parser preserves the kind metadata:
+and modern-extension files. Numeric star declarations preserve their fixed
+total storage width for semantic conversion. This matters most for complex
+types: `complex*8` is an 8-byte `Complex64`, while modern `complex(kind=8)` is
+a compiler kind and is 16 bytes on the documented `gfortran` target.
+`DOUBLE PRECISION` and `DOUBLE COMPLEX` retain a compiler-dependent double-kind
+expression and use the cached Fortran type probe. For `CHARACTER*N` and
+`CHARACTER*(*)`, the star value is a length, not a kind or element storage
+width.
```fortran
subroutine accepted(x)
@@ -969,6 +977,9 @@ subroutine accepted(x)
end subroutine accepted
```
+See the [generated modern and legacy datatype mapping](semantics.md#generated-linux-x86_64-mapping-example)
+for the exact GitHub Actions target results.
+
### 6.6 Source-form metadata
The parser records source-form metadata from the filename and lexer, but does
@@ -1149,6 +1160,37 @@ Lower-level unit parsers are internal `FortranParser` methods.
Semantic conversion lives in `semantics/fortran2ir.py`. It accepts parsed `FortranFile`
(or selected `FortranModule`) structures and converts metadata into semantic IR
consumed by the `.pyi` printer and later wrapper/runtime stages.
+Compiler-backed shared-CLI semantic stages resolve compiler-dependent kind
+expressions, measure intrinsic storage with `storage_size`, attach those facts
+to semantic types, and reuse memory and persistent caches. For the maintained
+GitHub Actions `gfortran` profile, unqualified `integer`, `real`, and `complex`
+map to `Int32`, `Float32`, and `Complex64`; target-changing flags can change
+those mappings. The
+[generated target datatype mapping](semantics.md#generated-linux-x86_64-mapping-example)
+measures and verifies those storage facts.
+
+The Fortran probe cache key includes the generated expression source, resolved
+compiler binary identity, target flags, includes, macros, requested standard,
+working directory, target-related environment, and runner. The persistent
+location is `$XDG_CACHE_HOME/x2py/fortran_type_probe` or
+`~/.cache/x2py/fortran_type_probe`; `X2PY_CACHE_DIR`,
+`--fortran-type-probe-cache-dir`, and standalone `--cache-dir` override it.
+Use `--refresh-fortran-type-probe` or standalone `--refresh` after an external
+compiler/sysroot change that does not alter the cache key.
+
+The standalone probe can create a reusable report containing the exact
+compile-time and storage expressions needed by a source:
+
+```bash
+python3 -m x2py.fortran_type_probe --compiler gfortran \
+ --expr='selected_real_kind(12)' \
+ --expr='storage_size(real(0.0,kind=8))' \
+ > build/fortran-types.json
+```
+
+Pass that report with `--fortran-type-report` when automatic direct-compiler
+probing is not appropriate. A missing required expression is reported
+explicitly instead of falling back to an unrelated target mapping.
The semantic converter also supports compile-time specialization for values the
parser intentionally leaves symbolic. Use
diff --git a/docs/semantics.md b/docs/semantics.md
index 1579c5f54..a82a10703 100644
--- a/docs/semantics.md
+++ b/docs/semantics.md
@@ -36,45 +36,198 @@ and eventual NumPy-oriented wrapper code.
| Fortran spelling or kind | Semantic dtype | NumPy equivalent |
| --- | --- | --- |
-| `integer`, `integer(kind=4)`, `integer(int32)`, `integer(c_int)`, `integer(c_int32_t)` | `Int32` | `numpy.int32` |
-| `integer(kind=1)`, `integer(int8)`, `integer(c_signed_char)`, `integer(c_int8_t)` | `Int8` | `numpy.int8` |
-| `integer(kind=2)`, `integer(int16)`, `integer(c_short)`, `integer(c_int16_t)` | `Int16` | `numpy.int16` |
-| `integer(kind=8)`, `integer(int64)`, `integer(c_long_long)`, `integer(c_int64_t)` | `Int64` | `numpy.int64` |
-| `real`, `real(kind=8)`, `real(real64)`, `real(c_double)`, `real(kind(1.0d0))` | `Float64` | `numpy.float64` |
-| `real(kind=4)`, `real(real32)`, `real(c_float)`, `real(kind(1.0e0))` | `Float32` | `numpy.float32` |
-| `real(kind=16)`, `real(real128)`, `real(kind(1.0q0))` | `Float128` | `numpy.longdouble` |
-| `complex`, `complex(kind=8)`, `complex(real64)`, `complex(c_double_complex)` | `Complex128` | `numpy.complex128` |
-| `complex(kind=4)`, `complex(real32)`, `complex(c_float_complex)` | `Complex64` | `numpy.complex64` |
-| `complex(kind=16)`, `complex(real128)` | `Complex256` | `numpy.clongdouble` |
+| Unqualified `integer`, `real`, `complex` | Compiler-probed default storage | Matching NumPy numeric dtype |
+| Numeric kinds such as `kind=4/8/16` and `kind(...)` expressions | Compiler-probed kind storage | Matching NumPy numeric dtype |
+| `integer(int8/int16/int32/int64)` | `Int8` / `Int16` / `Int32` / `Int64` | Matching NumPy signed integer |
+| `real(real32/real64/real128)` | `Float32` / `Float64` / `Float128` | Matching NumPy real dtype |
+| `complex(real32/real64/real128)` | `Complex64` / `Complex128` / `Complex256` | Matching NumPy complex dtype |
+| `iso_c_binding` numeric kinds | Compiler-probed interoperable storage | Matching NumPy numeric dtype |
+| `double precision`, `double complex` | Compiler-probed double-kind storage | Matching NumPy real or complex dtype |
+| Legacy numeric `type*N`, such as `integer*8`, `real*8`, `complex*16`, `logical*1` | Fixed `N`-byte total storage | Matching NumPy dtype |
| `logical`, `logical(kind=1/2/4/8)`, `logical(c_bool)` | `Bool` | `numpy.bool_` |
-| `character`, `character(kind=1)`, `character(kind=c_char)` | `String` | `numpy.str_` or ABI byte storage |
+| `character`, `character(len=n)`, `character(kind=1)`, `character(kind=c_char)` | `String` | `numpy.str_` or ABI byte storage |
+| Legacy `character*N`, `character*(*)` | `String`; `N`/`*` is length, not kind | `numpy.str_` or ABI byte storage |
| `procedure(...)` | `Procedure` | Callback/interface policy |
+Compiler-backed Fortran semantic CLI stages measure the storage of every
+intrinsic type used by the source after resolving kind expressions. This is
+required because default and numeric kind mappings are processor-dependent and
+flags such as `-fdefault-real-8` can change them. Results are cached by exact
+compiler identity, target flags, expressions, environment, and runner.
+Legacy numeric `type*N` extensions carry fixed total storage and therefore do
+not need a compiler probe. In particular, `complex*8` is an 8-byte
+`Complex64`, while modern `complex(kind=8)` is a compiler kind that is
+`Complex128` on the documented `gfortran` target. `DOUBLE PRECISION` and
+`DOUBLE COMPLEX` remain compiler-dependent and use the cached probe.
+Direct converter calls without compiler facts retain the current GitHub
+Actions `gfortran` profile as a fallback. Explicit `iso_fortran_env` kinds are
+preferred when a portable source contract needs a fixed precision.
+
### C Types
| C spelling or parser type | Semantic dtype | NumPy equivalent |
| --- | --- | --- |
| `_Bool` / `CBool` | `Bool` | `numpy.bool_` |
-| `char`, `signed char` | `Int8` | `numpy.int8` |
-| `unsigned char` | `UInt8` | `numpy.uint8` |
-| `short`, `unsigned short` | `Int16`, `UInt16` | `numpy.int16`, `numpy.uint16` |
+| `char` | Target-probed `Int8` or `UInt8` | Matching NumPy integer |
+| `signed char`, `unsigned char` | Target-probed signed or unsigned width | Matching NumPy integer |
+| `short`, `unsigned short` | Target-probed signed or unsigned width | Matching NumPy integer |
| `int` / `CInt` | `Int` with concrete probed dtype | Matching signed NumPy integer for the target |
-| `unsigned int` | `UInt32` | `numpy.uint32` |
-| `long`, `long long` | `Int64` | `numpy.int64` |
-| `unsigned long`, `unsigned long long` | `UInt64` | `numpy.uint64` |
-| `float`, `double`, `long double` | `Float32`, `Float64`, `Float128` | `numpy.float32`, `numpy.float64`, `numpy.longdouble` |
-| `float _Complex`, `double _Complex`, `long double _Complex` | `Complex64`, `Complex128`, `Complex256` | `numpy.complex64`, `numpy.complex128`, `numpy.clongdouble` |
+| `unsigned int`, `long`, `unsigned long`, `long long`, `unsigned long long` | Target-probed integer width and signedness | Matching NumPy integer |
+| `float`, `double`, `long double` | Target-probed storage width | Matching NumPy real dtype |
+| `float _Complex`, `double _Complex`, `long double _Complex` | Target-probed storage width | Matching NumPy complex dtype |
| `int8_t`, `int16_t`, `int32_t`, `int64_t` | `Int8`, `Int16`, `Int32`, `Int64` | Matching signed NumPy integer |
| `uint8_t`, `uint16_t`, `uint32_t`, `uint64_t` | `UInt8`, `UInt16`, `UInt32`, `UInt64` | Matching unsigned NumPy integer |
| `size_t` | `SizeT` or probed unsigned width | `numpy.uintp` or matching `numpy.uint*` |
-C integer spellings are ABI-dependent. Ordinary C `int` keeps the stable
-semantic identity `Int`; its concrete dtype and the compiler fact used to
-derive it are stored on `SemanticType`. Without a supplied compiler report,
-the concrete dtype uses a clearly marked 32-bit fallback. The current semantic
-policy still maps parsed primitive `long` and `long long` to 64-bit semantic
-dtypes. Standard-library typedefs are refined through the compiler
-standard-type probe when facts are supplied.
+C primitive spellings are ABI-dependent. Compiler-backed C semantic CLI stages
+automatically probe the selected compiler target and use those facts for every
+modeled arithmetic primitive. Ordinary C `int` keeps the stable semantic
+identity `Int`; its concrete dtype and the compiler fact used to derive it are
+stored on `SemanticType`. Other primitive names and dtypes follow the measured
+target width and signedness. NumPy is the consumer-side dtype mapping, not the
+probe source: it describes the Python interpreter host and may differ from a
+selected compiler target or sysroot.
+
+Direct converter calls without a supplied report retain the documented
+fallback mappings. A supplied target fact whose width has no semantic dtype
+mapping produces `c_unsupported_primitive_abi` instead of silently using a
+different width.
+
+### Generated Linux x86_64 Mapping Example
+
+The following mapping snapshots are generated from the same compiler-backed
+code paths used by x2py. They target the `linux-x86_64` profile used by GitHub
+Actions. The executable documentation test reruns the commands and compares
+their complete output, so a compiler fact or semantic mapping change must
+update these examples.
+
+C uses `cc` to measure primitive storage, signedness, alignment, and floating
+precision:
+
+
+```bash
+python3 -m x2py.type_mapping_report --language c
+```
+
+
+```markdown
+Target profile: `linux-x86_64`
+
+| C type | Native target fact | Semantic dtype | NumPy dtype |
+| --- | --- | --- | --- |
+| `_Bool` | 8-bit bool | `Bool` | `numpy.bool_` |
+| `char` | signed 8-bit | `Int8` | `numpy.int8` |
+| `signed char` | signed 8-bit | `Int8` | `numpy.int8` |
+| `unsigned char` | unsigned 8-bit | `UInt8` | `numpy.uint8` |
+| `short` | signed 16-bit | `Int16` | `numpy.int16` |
+| `unsigned short` | unsigned 16-bit | `UInt16` | `numpy.uint16` |
+| `int` | signed 32-bit | `Int (Int32 storage)` | `numpy.int32` |
+| `unsigned int` | unsigned 32-bit | `UInt32` | `numpy.uint32` |
+| `long` | signed 64-bit | `Int64` | `numpy.int64` |
+| `unsigned long` | unsigned 64-bit | `UInt64` | `numpy.uint64` |
+| `long long` | signed 64-bit | `Int64` | `numpy.int64` |
+| `unsigned long long` | unsigned 64-bit | `UInt64` | `numpy.uint64` |
+| `float` | 32-bit storage, 24-bit precision | `Float32` | `numpy.float32` |
+| `double` | 64-bit storage, 53-bit precision | `Float64` | `numpy.float64` |
+| `long double` | 128-bit storage, 64-bit precision | `Float128` | `numpy.longdouble` |
+| `float _Complex` | 64-bit storage | `Complex64` | `numpy.complex64` |
+| `double _Complex` | 128-bit storage | `Complex128` | `numpy.complex128` |
+| `long double _Complex` | 256-bit storage | `Complex256` | `numpy.clongdouble` |
+| `size_t` | unsigned 64-bit | `UInt64` | `numpy.uint64` |
+```
+
+Fortran uses the same cached compiler probe as normal semantic conversion and
+the standard `storage_size` intrinsic to measure compiler-dependent modern and
+double-kind forms. The generated table also lists legacy spellings; numeric
+`type*N` rows use their fixed total storage, and character-star rows show
+length syntax rather than a different character kind:
+
+
+```bash
+python3 -m x2py.type_mapping_report --language fortran
+```
+
+
+```markdown
+Target profile: `linux-x86_64`
+
+| Fortran type | Native target fact | Semantic dtype | NumPy dtype |
+| --- | --- | --- | --- |
+| `integer` | 32-bit storage | `Int32` | `numpy.int32` |
+| `integer(kind=1)` | 8-bit storage | `Int8` | `numpy.int8` |
+| `integer(kind=2)` | 16-bit storage | `Int16` | `numpy.int16` |
+| `integer(kind=4)` | 32-bit storage | `Int32` | `numpy.int32` |
+| `integer(kind=8)` | 64-bit storage | `Int64` | `numpy.int64` |
+| `integer(int8)` | 8-bit storage | `Int8` | `numpy.int8` |
+| `integer(int16)` | 16-bit storage | `Int16` | `numpy.int16` |
+| `integer(int32)` | 32-bit storage | `Int32` | `numpy.int32` |
+| `integer(int64)` | 64-bit storage | `Int64` | `numpy.int64` |
+| `integer(c_signed_char)` | 8-bit storage | `Int8` | `numpy.int8` |
+| `integer(c_short)` | 16-bit storage | `Int16` | `numpy.int16` |
+| `integer(c_int)` | 32-bit storage | `Int32` | `numpy.int32` |
+| `integer(c_long)` | 64-bit storage | `Int64` | `numpy.int64` |
+| `integer(c_long_long)` | 64-bit storage | `Int64` | `numpy.int64` |
+| `integer(c_size_t)` | 64-bit storage | `Int64` | `numpy.int64` |
+| `integer(c_int8_t)` | 8-bit storage | `Int8` | `numpy.int8` |
+| `integer(c_int16_t)` | 16-bit storage | `Int16` | `numpy.int16` |
+| `integer(c_int32_t)` | 32-bit storage | `Int32` | `numpy.int32` |
+| `integer(c_int64_t)` | 64-bit storage | `Int64` | `numpy.int64` |
+| `real` | 32-bit storage | `Float32` | `numpy.float32` |
+| `real(kind=4)` | 32-bit storage | `Float32` | `numpy.float32` |
+| `real(kind=8)` | 64-bit storage | `Float64` | `numpy.float64` |
+| `real(kind=16)` | 128-bit storage | `Float128` | `numpy.longdouble` |
+| `real(real32)` | 32-bit storage | `Float32` | `numpy.float32` |
+| `real(real64)` | 64-bit storage | `Float64` | `numpy.float64` |
+| `real(real128)` | 128-bit storage | `Float128` | `numpy.longdouble` |
+| `real(c_float)` | 32-bit storage | `Float32` | `numpy.float32` |
+| `real(c_double)` | 64-bit storage | `Float64` | `numpy.float64` |
+| `real(c_long_double)` | 128-bit storage | `Float128` | `numpy.longdouble` |
+| `real(kind(1.0e0))` | 32-bit storage | `Float32` | `numpy.float32` |
+| `real(kind(1.0d0))` | 64-bit storage | `Float64` | `numpy.float64` |
+| `real(kind(1.0q0))` | 128-bit storage | `Float128` | `numpy.longdouble` |
+| `complex` | 64-bit storage | `Complex64` | `numpy.complex64` |
+| `complex(kind=4)` | 64-bit storage | `Complex64` | `numpy.complex64` |
+| `complex(kind=8)` | 128-bit storage | `Complex128` | `numpy.complex128` |
+| `complex(kind=16)` | 256-bit storage | `Complex256` | `numpy.clongdouble` |
+| `complex(real32)` | 64-bit storage | `Complex64` | `numpy.complex64` |
+| `complex(real64)` | 128-bit storage | `Complex128` | `numpy.complex128` |
+| `complex(real128)` | 256-bit storage | `Complex256` | `numpy.clongdouble` |
+| `complex(c_float_complex)` | 64-bit storage | `Complex64` | `numpy.complex64` |
+| `complex(c_double_complex)` | 128-bit storage | `Complex128` | `numpy.complex128` |
+| `complex(c_long_double_complex)` | 256-bit storage | `Complex256` | `numpy.clongdouble` |
+| `complex(kind=kind(1.0e0))` | 64-bit storage | `Complex64` | `numpy.complex64` |
+| `complex(kind=kind(1.0d0))` | 128-bit storage | `Complex128` | `numpy.complex128` |
+| `complex(kind=kind(1.0q0))` | 256-bit storage | `Complex256` | `numpy.clongdouble` |
+| `logical` | 32-bit storage | `Bool` | `numpy.bool_` |
+| `logical(kind=1)` | 8-bit storage | `Bool` | `numpy.bool_` |
+| `logical(kind=2)` | 16-bit storage | `Bool` | `numpy.bool_` |
+| `logical(kind=4)` | 32-bit storage | `Bool` | `numpy.bool_` |
+| `logical(kind=8)` | 64-bit storage | `Bool` | `numpy.bool_` |
+| `logical(c_bool)` | 8-bit storage | `Bool` | `numpy.bool_` |
+| `character` | 8-bit storage | `String` | `numpy.str_ / ABI bytes` |
+| `character(len=n)` | 8-bit storage | `String` | `numpy.str_ / ABI bytes` |
+| `character(kind=1)` | 8-bit storage | `String` | `numpy.str_ / ABI bytes` |
+| `character(kind=c_char)` | 8-bit storage | `String` | `numpy.str_ / ABI bytes` |
+| `integer*1` | 8-bit storage | `Int8` | `numpy.int8` |
+| `integer*2` | 16-bit storage | `Int16` | `numpy.int16` |
+| `integer*4` | 32-bit storage | `Int32` | `numpy.int32` |
+| `integer*8` | 64-bit storage | `Int64` | `numpy.int64` |
+| `real*4` | 32-bit storage | `Float32` | `numpy.float32` |
+| `real*8` | 64-bit storage | `Float64` | `numpy.float64` |
+| `real*16` | 128-bit storage | `Float128` | `numpy.longdouble` |
+| `double precision` | 64-bit storage | `Float64` | `numpy.float64` |
+| `complex*8` | 64-bit storage | `Complex64` | `numpy.complex64` |
+| `complex*16` | 128-bit storage | `Complex128` | `numpy.complex128` |
+| `complex*32` | 256-bit storage | `Complex256` | `numpy.clongdouble` |
+| `double complex` | 128-bit storage | `Complex128` | `numpy.complex128` |
+| `logical*1` | 8-bit storage | `Bool` | `numpy.bool_` |
+| `logical*2` | 16-bit storage | `Bool` | `numpy.bool_` |
+| `logical*4` | 32-bit storage | `Bool` | `numpy.bool_` |
+| `logical*8` | 64-bit storage | `Bool` | `numpy.bool_` |
+| `character*1` | 8-bit storage | `String` | `numpy.str_ / ABI bytes` |
+| `character*8` | 8-bit storage | `String` | `numpy.str_ / ABI bytes` |
+| `character*(*)` | 8-bit storage | `String` | `numpy.str_ / ABI bytes` |
+```
## C To Semantic IR Mapping
@@ -90,19 +243,16 @@ policy is documented in the datatype mapping section above.
- C parameter -> `SemanticArgument`.
- `void` return -> `None`.
- `_Bool` -> `Bool`.
-- `char` -> `Int8` with `c_char_policy` metadata; `signed char` -> `Int8`;
- `unsigned char` -> `UInt8`.
-- `int` maps to `Int`. Its concrete dtype is derived from a supplied
- `x2py.c_type_probe` report and stored with the fact source; without one it
- carries a marked `Int32` fallback.
-- `short`, `long`, and `long long` map to fixed signed integer names using the
- current Linux-oriented defaults: `Int16`, `Int64`, `Int64`.
-- Unsigned integer spellings map to `UInt16`, `UInt32`, `UInt64`, and
- `UInt64`; fixed-width typedef spellings such as `uint32_t` map to the
- matching `UInt*` fallback.
-- `float` -> `Float32`; `double` -> `Float64`; `long double` -> `Float128`.
-- `float _Complex` -> `Complex64`; `double _Complex` -> `Complex128`;
- `long double _Complex` -> `Complex256`.
+- All modeled primitive integer, real, and complex spellings consume supplied
+ `x2py.c_type_probe` facts. Plain `char` signedness, integer widths, real
+ storage widths and precision metadata, and complex storage widths come from
+ the selected compiler target.
+- `int` keeps semantic name `Int` while its concrete dtype follows the target.
+ Other primitive semantic names and dtypes become the measured width-specific
+ `Int*`, `UInt*`, `Float*`, or `Complex*` name.
+- Direct converter calls without a report retain the earlier Linux-oriented
+ primitive fallbacks; C semantic CLI stages supply a cached target report
+ automatically.
- Local typedef chains are resolved when their parser model definitions are
available.
- `size_t` maps to `SizeT` without a target probe; supplied
diff --git a/docs/tutorial.md b/docs/tutorial.md
index d0f275b2f..d93a9da6f 100644
--- a/docs/tutorial.md
+++ b/docs/tutorial.md
@@ -62,10 +62,17 @@ command is equivalent to `python3 -m x2py`.
## Fortran Walkthrough
-This walkthrough uses:
-
-```text
-tests/data/fortran/general/basic_subroutine.f90
+Input (`tests/data/fortran/general/basic_subroutine.f90`):
+
+
+```fortran
+module m1
+contains
+subroutine add1(n, x)
+ integer, intent(in) :: n
+ real(kind=8), intent(inout), dimension(n) :: x
+end subroutine add1
+end module m1
```
### 1. Parse The Source
@@ -170,10 +177,19 @@ Readiness treats the edited `.pyi` contract as the source of truth.
## C Walkthrough
-This walkthrough uses:
+Input (`tests/data/c/general/math_api.h`):
-```text
-tests/data/c/general/math_api.h
+
+```c
+#ifndef X2PY_GENERAL_MATH_API_H
+#define X2PY_GENERAL_MATH_API_H
+
+double norm2(int n, const double x[static 1]);
+void scale(int n, double alpha, double x[static 1]);
+double dot(int n, const double *restrict x, const double *restrict y);
+void fill_identity3(double a[static 3][3]);
+
+#endif
```
C inputs require explicit C mode:
@@ -328,10 +344,29 @@ python3 -m x2py include/api.h --language c --parse \
Use a C compilation database when one is available:
```bash
+python3 -m x2py.c_type_probe --compiler clang \
+ --compiler-arg=--target=aarch64-linux-gnu \
+ --runner=qemu-aarch64 \
+ > build/aarch64-c-types.json
+
python3 -m x2py src/api.c --language c --semantics \
- --compile-commands build/compile_commands.json
+ --compile-commands build/compile_commands.json \
+ --c-type-report build/aarch64-c-types.json
```
+For normal direct-compiler C semantic, `.pyi`, and readiness stages, x2py
+automatically probes primitive widths and plain `char` signedness using the
+selected compiler and target flags. It caches the result by compiler identity
+and target configuration, so repeated runs do not recompile the probe. Use
+`--refresh-c-type-probe` when a sysroot changes in place. For cross compilers,
+repeat `--c-type-probe-runner=...` for the runner command and arguments.
+
+NumPy types are used as the Python-side dtype mapping, not as the ABI probe:
+NumPy describes the interpreter host and can disagree with a cross compiler or
+selected sysroot. Compilation databases and custom preprocessing templates
+need an explicit reusable `--c-type-report` because they can contain multiple
+target recipes.
+
For Fortran:
```bash
@@ -343,11 +378,45 @@ python3 -m x2py src/api.f90 --language fortran --pyi \
--compiler-arg=-fdefault-real-8
```
+For direct-compiler Fortran semantic, `.pyi`, and readiness stages, x2py
+resolves compiler-dependent kind expressions and measures the storage of every
+intrinsic type used by the source. This matters for processor-dependent
+numeric kinds and flags such as `-fdefault-real-8` or
+`-fdefault-integer-8`. Expression and storage probes are cached by compiler
+identity and target configuration. Use `--refresh-fortran-type-probe` after a
+sysroot or compiler installation changes in place, and repeat
+`--fortran-type-probe-runner=...` for a cross-target runner.
+
+Compilation databases and custom preprocessing templates need an explicit
+reusable `--fortran-type-report`, for the same reason as C: one project recipe
+can describe multiple target profiles.
+
Compiler preprocessing preserves a recipe in machine-readable parser output,
including the selected compiler, arguments, includes, source mappings, and
diagnostics. See the [examples cookbook](examples.md#compiler-preprocessing)
for more supported preprocessing modes.
+## Inspect Target Datatype Mappings
+
+Generate the native-to-semantic-to-NumPy scalar mapping for the selected
+compiler target:
+
+```bash
+python3 -m x2py.type_mapping_report --language c
+python3 -m x2py.type_mapping_report --language fortran
+```
+
+Pass `--compiler` and repeated `--compiler-arg` options to inspect a different
+compiler target or target-changing flags. Both mapping commands use persistent
+probe caches; `--cache-dir`, `--refresh`, and repeated `--runner` options
+control reuse and cross-target execution. The generated
+[Linux x86_64 C and Fortran examples](semantics.md#generated-linux-x86_64-mapping-example)
+show the complete input facts and resulting NumPy dtype names used by the
+GitHub Actions profile. The Fortran table includes modern kinds and legacy
+spellings. It also shows the important distinction between fixed-width
+`complex*8` and compiler-kind `complex(kind=8)`, and identifies
+`character*N` as length syntax.
+
## Edit A Semantic `.pyi`
Generated `.pyi` files describe exact native contracts by default. They do not
diff --git a/fortran_parser/models.py b/fortran_parser/models.py
index 5fb738281..444e43494 100644
--- a/fortran_parser/models.py
+++ b/fortran_parser/models.py
@@ -248,6 +248,22 @@ def kind_expression(self) -> Any:
def value_expression(self) -> Any:
return _parse_fortran_expression(self.value)
+ @property
+ def target_kind_expression(self) -> str:
+ """Compiler kind expression preserved without changing parser JSON."""
+ return str(getattr(self, "_target_kind_expression", ""))
+
+ @property
+ def character_length_syntax(self) -> bool:
+ """Whether the stored character ``kind`` text is actually a length."""
+ return bool(getattr(self, "_character_length_syntax", False))
+
+ @property
+ def declared_storage_bits(self) -> int | None:
+ """Fixed storage width carried by a legacy numeric ``type*N`` form."""
+ bits = getattr(self, "_declared_storage_bits", None)
+ return int(bits) if bits is not None else None
+
@dataclass
class FortranArgument(FortranVariable):
diff --git a/fortran_parser/parser.py b/fortran_parser/parser.py
index c4ccf9c8d..86bad830d 100644
--- a/fortran_parser/parser.py
+++ b/fortran_parser/parser.py
@@ -96,7 +96,8 @@
_REGEX: dict[str, re.Pattern[str]] = {
"type": re.compile(
- r"^(integer|real|complex|logical|character|double\s+precision)\s*(\([^)]*\))?\s*(.*)$", re.IGNORECASE
+ r"^(integer|real|complex|logical|character|double\s+(?:precision|complex))\s*(\([^)]*\))?\s*(.*)$",
+ re.IGNORECASE,
),
"char_star": re.compile(r"^character\s*\*\s*(?P\([^)]*\)|\*|[A-Za-z_]\w*|\d+)\s*(?P.*)$", re.IGNORECASE),
"procedure": re.compile(
@@ -2250,6 +2251,7 @@ def _parse_procedure_header(
)
if parsed_prefix:
result.base_type, result.kind = parsed_prefix
+ self._apply_type_spelling_metadata(result, type_prefix)
sig = FortranProcedureSignature(
name=m.group("name"),
@@ -2442,10 +2444,14 @@ def _proc_scope_add_imports(self, proc_state: dict, names: list[str]) -> None:
def _proc_scope_set_declared_local_type(self, proc_state: dict, name: str, meta: dict) -> None:
"""Store type metadata for a declared local symbol."""
key = self._scope_key(name)
- proc_state["declared_local_types"][key] = {
+ declared_type = {
"base_type": meta["base_type"],
"kind": meta["kind"],
}
+ for metadata_key in ("target_kind_expression", "character_length_syntax", "declared_storage_bits"):
+ if metadata_key in meta:
+ declared_type[metadata_key] = meta[metadata_key]
+ proc_state["declared_local_types"][key] = declared_type
def _proc_scope_add_local_parameter(
self,
@@ -2998,23 +3004,27 @@ def _parse_declaration_left(
if kind.startswith("(") and kind.endswith(")"):
kind = kind[1:-1].strip()
trailing = (char_star.group("rest") or "").strip().lstrip(", ")
- return self._new_decl_meta("character", kind), split_csv(trailing)
+ meta = self._new_decl_meta("character", kind)
+ meta["character_length_syntax"] = True
+ return meta, split_csv(trailing)
if star_kind:
base, kind = star_kind
tail = self._strip_legacy_star_kind_prefix(left)
attrs = split_csv(tail.lstrip(", ")) if tail.startswith(",") else []
- return self._new_decl_meta(base.lower(), kind), attrs
+ meta = self._new_decl_meta(base.lower(), kind)
+ if base.lower() == "character":
+ meta["character_length_syntax"] = True
+ else:
+ meta["declared_storage_bits"] = int(kind) * 8
+ return meta, attrs
intrinsic = self._split_intrinsic_type_spec(left)
derived = _REGEX["type_field"].match(left)
class_derived = _REGEX["class_field"].match(left)
if intrinsic:
base, type_spec, tail = intrinsic
- if base == "double precision":
- base = "real"
- return self._new_decl_meta(base, extract_kind_from_type_spec(base, type_spec)), split_csv(
- tail.strip().lstrip(", ")
- )
+ meta = self._intrinsic_decl_meta(base, type_spec)
+ return meta, split_csv(tail.strip().lstrip(", "))
if derived or class_derived:
decl = derived or class_derived
return self._new_decl_meta("derived", decl.group("dtype")), split_csv(
@@ -3157,6 +3167,44 @@ def _new_decl_meta(base_type: str, kind: str | None) -> dict:
"parameter": False,
}
+ @staticmethod
+ def _intrinsic_decl_meta(base_type: str, type_spec: str) -> dict:
+ """Normalize one intrinsic spelling while retaining target-only facts."""
+ if base_type in {"double precision", "double complex"}:
+ normalized = "real" if base_type == "double precision" else "complex"
+ meta = FortranParser._new_decl_meta(normalized, None)
+ meta["target_kind_expression"] = "kind(1.0d0)"
+ return meta
+
+ meta = FortranParser._new_decl_meta(base_type, extract_kind_from_type_spec(base_type, type_spec))
+ if base_type == "character" and type_spec and re.search(r"\bkind\s*=", type_spec, re.IGNORECASE) is None:
+ meta["character_length_syntax"] = True
+ return meta
+
+ @staticmethod
+ def _apply_type_spelling_metadata(var: FortranVariable, spelling: str) -> None:
+ """Attach target-only facts from a standalone type prefix."""
+ star_kind = FortranParser._find_legacy_star_kind(spelling)
+ if star_kind is not None:
+ base_type, width = star_kind
+ if base_type == "character":
+ var._character_length_syntax = True
+ else:
+ var._declared_storage_bits = int(width) * 8
+ return
+ if _REGEX["char_star"].match(spelling):
+ var._character_length_syntax = True
+ return
+
+ intrinsic = FortranParser._split_intrinsic_type_spec(spelling)
+ if intrinsic is None:
+ return
+ base_type, type_spec, _tail = intrinsic
+ if base_type in {"double precision", "double complex"}:
+ var._target_kind_expression = "kind(1.0d0)"
+ elif base_type == "character" and type_spec and re.search(r"\bkind\s*=", type_spec, re.IGNORECASE) is None:
+ var._character_length_syntax = True
+
@staticmethod
def _apply_decl_attrs(meta: dict, attrs: list[str], *, include_intent: bool = False) -> None:
"""Merge declaration attributes into normalized metadata."""
@@ -3230,6 +3278,7 @@ def _apply(arg: FortranArgument, meta: dict, shape: list[str]):
arg.pointer = meta["pointer"]
arg.contiguous = meta["contiguous"]
arg.is_parameter = meta["parameter"]
+ FortranParser._apply_internal_type_metadata(arg, meta)
if shape:
arg.shape = shape
arg.rank = len(shape)
@@ -3238,6 +3287,16 @@ def _apply(arg: FortranArgument, meta: dict, shape: list[str]):
arg.rank = meta["rank"]
arg.lbound, arg.ubound = FortranParser._extract_bounds(arg.shape)
+ @staticmethod
+ def _apply_internal_type_metadata(arg: FortranVariable, meta: dict) -> None:
+ """Apply compiler-relevant facts that stay outside serialized models."""
+ if meta.get("target_kind_expression"):
+ arg._target_kind_expression = meta["target_kind_expression"]
+ if meta.get("character_length_syntax"):
+ arg._character_length_syntax = True
+ if meta.get("declared_storage_bits") is not None:
+ arg._declared_storage_bits = int(meta["declared_storage_bits"])
+
@staticmethod
def _split_dim_bounds(dim: str) -> tuple[str | None, str | None]:
"""Normalize one dimension into lower and upper bound text."""
@@ -3545,6 +3604,7 @@ def _finalize_proc(self, state: dict) -> FortranProcedureSignature:
continue
arg.base_type = inferred.get("base_type", arg.base_type)
arg.kind = inferred.get("kind", arg.kind)
+ self._apply_internal_type_metadata(arg, inferred)
if implicit_none and not sig.in_interface:
self._validate_all_args_declared(sig, filename, explicit_result=bool(state.get("explicit_result", False)))
@@ -3564,6 +3624,7 @@ def _finalize_proc(self, state: dict) -> FortranProcedureSignature:
value_type="expression",
is_parameter=True,
)
+ self._apply_internal_type_metadata(var, local_decl)
var.symbolic_value = value
sig.variables[name.lower()] = var
if sig.kind == "function" and sig.result and sig.result.base_type == "unknown":
@@ -4171,7 +4232,7 @@ def _topological_files(file_deps: dict[str, set[str]]) -> list[str]:
def _split_intrinsic_type_spec(text: str) -> tuple[str, str, str] | None:
"""Split an intrinsic declaration prefix into base, parenthesized spec, and tail."""
match = re.match(
- r"^(integer|real|complex|logical|character|double\s+precision)\b(?P.*)$",
+ r"^(integer|real|complex|logical|character|double\s+(?:precision|complex))\b(?P.*)$",
text.strip(),
re.IGNORECASE,
)
@@ -4273,6 +4334,8 @@ def _parse_type_prefix(prefix: str) -> tuple[str, str | None] | None:
return None
if base == "double precision":
base = "real"
+ elif base == "double complex":
+ base = "complex"
kind = extract_kind_from_type_spec(base, type_spec)
if kind is None and type_spec and base != "character":
kind = type_spec[1:-1].strip()
diff --git a/semantics/c2ir.py b/semantics/c2ir.py
index a752d94c1..142b9b819 100644
--- a/semantics/c2ir.py
+++ b/semantics/c2ir.py
@@ -98,6 +98,8 @@
)
_SIGNED_WIDTH_TYPES = {8: "Int8", 16: "Int16", 32: "Int32", 64: "Int64"}
_UNSIGNED_WIDTH_TYPES = {8: "UInt8", 16: "UInt16", 32: "UInt32", 64: "UInt64"}
+_REAL_WIDTH_TYPES = {32: "Float32", 64: "Float64", 80: "Float128", 96: "Float128", 128: "Float128"}
+_COMPLEX_WIDTH_TYPES = {64: "Complex64", 128: "Complex128", 160: "Complex256", 192: "Complex256", 256: "Complex256"}
_NUMERIC_SEMANTIC_TYPES = frozenset(
{
"Bool",
@@ -143,6 +145,27 @@
CLongDoubleComplex: "Complex256",
}
+_PRIMITIVE_TYPE_FACT_NAMES: dict[type[CType], str] = {
+ CBool: "_Bool",
+ CChar: "char",
+ CSignedChar: "signed char",
+ CUnsignedChar: "unsigned char",
+ CShort: "short",
+ CUnsignedShort: "unsigned short",
+ CInt: "int",
+ CUnsignedInt: "unsigned int",
+ CLong: "long",
+ CUnsignedLong: "unsigned long",
+ CLongLong: "long long",
+ CUnsignedLongLong: "unsigned long long",
+ CFloat: "float",
+ CDouble: "double",
+ CLongDouble: "long double",
+ CFloatComplex: "float _Complex",
+ CDoubleComplex: "double _Complex",
+ CLongDoubleComplex: "long double _Complex",
+}
+
_STANDARD_TYPE_FALLBACKS = {
"bool": "Bool",
"size_t": "SizeT",
@@ -516,6 +539,13 @@ def visit_enum(self, enum: CEnum) -> SemanticEnum:
)
def visit_type(self, type_: CType, *, owner: str | None = None) -> SemanticType:
+ structural_type = self._structural_type(type_, owner=owner)
+ if structural_type is not None:
+ return structural_type
+ return self._primitive_type(type_, owner=owner)
+
+ def _structural_type(self, type_: CType, *, owner: str | None) -> SemanticType | None:
+ """Convert non-primitive C types, leaving arithmetic types to the ABI mapper."""
if isinstance(type_, CComposedType):
return self._composed_type(type_, owner=owner)
if isinstance(type_, CTypedef):
@@ -537,7 +567,10 @@ def visit_type(self, type_: CType, *, owner: str | None = None) -> SemanticType:
metadata={"c_void_pointer_pointee": True},
origin=self._type_origin(type_),
)
+ return None
+ def _primitive_type(self, type_: CType, *, owner: str | None) -> SemanticType:
+ """Convert one modeled C arithmetic primitive using target ABI facts."""
semantic_name = self.primitive_type_map.get(type(type_))
if semantic_name is None:
return self._unsupported_type(
@@ -554,7 +587,34 @@ def visit_type(self, type_: CType, *, owner: str | None = None) -> SemanticType:
if isinstance(type_, CChar):
metadata["c_char_policy"] = "implementation-defined signed 8-bit code unit"
dtype = semantic_name
- if isinstance(type_, CInt) and semantic_name == "Int":
+ primitive_name = _PRIMITIVE_TYPE_FACT_NAMES.get(type(type_))
+ fact = self.standard_type_facts.get(primitive_name) if primitive_name is not None else None
+ if fact is not None and fact.get("available", True):
+ probed_name = self._semantic_type_from_standard_fact(fact)
+ if probed_name is None:
+ unsupported = self._unsupported_type(
+ "c_unsupported_primitive_abi",
+ "The selected C target uses a primitive ABI that has no semantic dtype mapping.",
+ owner=owner,
+ source_type=self._type_text(type_),
+ )
+ unsupported.metadata.update(
+ {
+ "c_primitive": primitive_name,
+ "c_type_fact": dict(fact),
+ "c_type_fact_source": "compiler_probe",
+ }
+ )
+ return unsupported
+ semantic_name = "Int" if isinstance(type_, CInt) and semantic_name == "Int" else probed_name
+ dtype = probed_name
+ metadata["c_primitive"] = primitive_name
+ metadata["c_type_fact"] = dict(fact)
+ metadata["c_type_fact_source"] = "compiler_probe"
+ if isinstance(type_, CChar):
+ signedness = "signed" if fact.get("signed") else "unsigned"
+ metadata["c_char_policy"] = f"compiler-probed {signedness} {fact.get('bits')}-bit code unit"
+ elif isinstance(type_, CInt) and semantic_name == "Int":
fact, fact_source = self._c_int_fact()
dtype = self._semantic_type_from_standard_fact(fact) or "Int"
metadata["c_primitive"] = "int"
@@ -1243,8 +1303,12 @@ def _semantic_type_from_standard_fact(fact: dict[str, Any]) -> str | None:
return _UNSIGNED_WIDTH_TYPES.get(bits)
if fact.get("signed") is True:
return _SIGNED_WIDTH_TYPES.get(bits)
+ if fact.get("kind") == "bool":
+ return "Bool"
if fact.get("kind") == "real":
- return {32: "Float32", 64: "Float64"}.get(bits)
+ return _REAL_WIDTH_TYPES.get(bits)
+ if fact.get("kind") == "complex":
+ return _COMPLEX_WIDTH_TYPES.get(bits)
return None
@staticmethod
diff --git a/semantics/fortran2ir.py b/semantics/fortran2ir.py
index f7da128a7..f445ad4cb 100644
--- a/semantics/fortran2ir.py
+++ b/semantics/fortran2ir.py
@@ -58,7 +58,7 @@
("integer", "c_int16_t"): "Int16",
("integer", "c_int32_t"): "Int32",
("integer", "c_int64_t"): "Int64",
- ("real", None): "Float64",
+ ("real", None): "Float32",
("real", "4"): "Float32",
("real", "8"): "Float64",
("real", "16"): "Float128",
@@ -67,7 +67,7 @@
("real", "real128"): "Float128",
("real", "c_float"): "Float32",
("real", "c_double"): "Float64",
- ("complex", None): "Complex128",
+ ("complex", None): "Complex64",
("complex", "4"): "Complex64",
("complex", "8"): "Complex128",
("complex", "16"): "Complex256",
@@ -87,6 +87,13 @@
("character", "c_char"): "String",
}
+_FORTRAN_INTRINSIC_TYPES = frozenset({"integer", "real", "complex", "logical", "character"})
+_FORTRAN_STORAGE_TYPE_MAP = {
+ "integer": {8: "Int8", 16: "Int16", 32: "Int32", 64: "Int64"},
+ "real": {32: "Float32", 64: "Float64", 80: "Float128", 96: "Float128", 128: "Float128"},
+ "complex": {64: "Complex64", 128: "Complex128", 160: "Complex256", 192: "Complex256", 256: "Complex256"},
+}
+
@dataclass(frozen=True)
class _DerivedTypeContext:
@@ -157,12 +164,17 @@ def __init__(
type_map: dict[tuple[str, str | None], str] | None = None,
compile_time_values: dict[str, int | str] | None = None,
wrapped_derived_types: Iterable[tuple[str, str]] | None = None,
+ type_facts: dict[tuple[str, str | None], dict[str, object]] | None = None,
):
self.type_map = FORTRAN_TYPE_MAP if type_map is None else type_map
self.compile_time_values = _normalize_compile_time_values(compile_time_values)
self.wrapped_derived_types = {
(str(module).lower(), str(name).lower()) for module, name in (wrapped_derived_types or [])
}
+ self.type_facts = {
+ (str(base_type).lower(), None if kind is None else str(kind).lower()): dict(fact)
+ for (base_type, kind), fact in (type_facts or {}).items()
+ }
def visit(self, node, **context):
"""Dispatch one parsed Fortran model to the matching conversion method."""
@@ -221,6 +233,10 @@ def visit_variable(
semantic_name = self._semantic_type_name(var)
derived_type_ref = self._derived_type_ref(var, derived_type_context)
metadata = {}
+ type_fact = self._target_type_fact(var)
+ if type_fact is not None:
+ metadata["fortran_type_fact"] = dict(type_fact)
+ metadata["fortran_type_fact_source"] = str(type_fact.get("source") or "compiler_probe")
if derived_type_ref is not None:
semantic_name, ref_metadata = derived_type_ref
metadata[EXTERNAL_TYPE_REF_METADATA] = ref_metadata
@@ -467,6 +483,7 @@ def _with_additional_wrapped_types(
type_map=self.type_map,
compile_time_values=self.compile_time_values,
wrapped_derived_types=merged,
+ type_facts=self.type_facts,
)
@staticmethod
@@ -576,6 +593,16 @@ def _semantic_type_name(self, var: FortranVariable) -> str:
if base_type == "procedure":
return "Procedure"
+ fact = self._target_type_fact(var)
+ if fact is not None:
+ semantic_type = self._semantic_type_from_target_fact(fact)
+ if semantic_type is None:
+ bits = int(fact.get("bits") or 0)
+ raise ValueError(
+ f"Unsupported Fortran target storage for variable '{var.name}': {base_type} uses {bits}-bit storage"
+ )
+ return semantic_type
+
kind = self._semantic_kind_key(var)
semantic_type = self.type_map.get((base_type, kind))
if semantic_type is None:
@@ -584,11 +611,12 @@ def _semantic_type_name(self, var: FortranVariable) -> str:
return semantic_type
def _semantic_kind_key(self, var: FortranVariable) -> str | None:
- if not var.kind:
+ raw_kind = var.target_kind_expression or var.kind
+ if not raw_kind:
return None
base_type = var.base_type.lower()
- kind = self._resolve_compile_time_text(str(var.kind)).strip().lower()
+ kind = self._resolve_compile_time_text(str(raw_kind)).strip().lower()
if base_type == "character":
return None
if base_type == "logical":
@@ -598,6 +626,43 @@ def _semantic_kind_key(self, var: FortranVariable) -> str | None:
return literal_kind
return kind
+ def _target_type_key(self, var: FortranVariable) -> tuple[str, str | None]:
+ base_type = var.base_type.lower()
+ raw_kind = var.target_kind_expression or var.kind
+ if not raw_kind:
+ return base_type, None
+
+ kind = self._resolve_compile_time_text(str(raw_kind)).strip().lower()
+ if base_type == "character":
+ if var.character_length_syntax:
+ return base_type, None
+ kind_match = re.search(r"(?:^|,)\s*kind\s*=\s*([^,]+)", kind)
+ if kind_match is not None:
+ kind = kind_match.group(1).strip()
+ elif kind.startswith("len="):
+ return base_type, None
+ return base_type, kind
+
+ def _target_type_fact(self, var: FortranVariable) -> dict[str, object] | None:
+ if var.declared_storage_bits is not None:
+ return {
+ "base_type": var.base_type.lower(),
+ "kind": var.kind or None,
+ "bits": var.declared_storage_bits,
+ "source": "legacy_star_storage",
+ }
+ return self.type_facts.get(self._target_type_key(var))
+
+ @staticmethod
+ def _semantic_type_from_target_fact(fact: dict[str, object]) -> str | None:
+ base_type = str(fact.get("base_type") or "").lower()
+ bits = int(fact.get("bits") or 0)
+ if base_type == "logical":
+ return "Bool"
+ if base_type == "character":
+ return "String"
+ return _FORTRAN_STORAGE_TYPE_MAP.get(base_type, {}).get(bits)
+
@staticmethod
def _literal_kind_key(kind: str) -> str | None:
match = re.fullmatch(r"kind\(\s*[-+]?\d+(?:\.\d*)?([edq])[-+]?\d*\s*\)", kind)
@@ -1085,6 +1150,55 @@ def _compile_time_requirement_message(code: str, symbol: str, expression: str) -
return f"Compile-time value required for '{symbol}'."
+def fortran_type_storage_expression(base_type: str, kind: str | None = None) -> str:
+ """Return the compiler expression that measures one intrinsic type."""
+ constructors = {
+ "integer": "int(0)",
+ "real": "real(0.0)",
+ "complex": "cmplx(0.0)",
+ "logical": "logical(.false.)",
+ "character": "char(65)",
+ }
+ base = str(base_type).lower()
+ constructor = constructors.get(base)
+ if constructor is None:
+ raise ValueError(f"Unsupported Fortran storage probe type: {base_type}")
+ if kind is not None:
+ constructor = constructor[:-1] + f",kind={kind})"
+ return f"storage_size({constructor})"
+
+
+def collect_fortran_type_storage_requirements(
+ parsed,
+ *,
+ compile_time_values: dict[str, int | str] | None = None,
+) -> list[dict[str, object]]:
+ """Collect unique compiler storage queries needed by semantic conversion."""
+ converter = FortranToIRConverter(compile_time_values=compile_time_values)
+ requirements: list[dict[str, object]] = []
+ seen: set[tuple[str, str | None]] = set()
+ for var, context in _iter_fortran_variable_contexts(parsed):
+ base_type = str(var.base_type or "").lower()
+ if base_type not in _FORTRAN_INTRINSIC_TYPES:
+ continue
+ if var.declared_storage_bits is not None:
+ continue
+ key = converter._target_type_key(var)
+ if key in seen:
+ continue
+ seen.add(key)
+ requirements.append(
+ {
+ "base_type": key[0],
+ "kind": key[1],
+ "expression": fortran_type_storage_expression(*key),
+ "unit": context.get("unit"),
+ "symbol": context.get("symbol"),
+ }
+ )
+ return requirements
+
+
def collect_semantic_compile_time_requirements(
parsed,
*,
@@ -1273,12 +1387,14 @@ def resolve_semantic_compile_time_values(
def _converter_for(
compile_time_values: dict[str, int | str] | None = None,
wrapped_derived_types: Iterable[tuple[str, str]] | None = None,
+ type_facts: dict[tuple[str, str | None], dict[str, object]] | None = None,
) -> FortranToIRConverter:
- if compile_time_values is None and wrapped_derived_types is None:
+ if compile_time_values is None and wrapped_derived_types is None and type_facts is None:
return _DEFAULT_CONVERTER
return FortranToIRConverter(
compile_time_values=compile_time_values,
wrapped_derived_types=wrapped_derived_types,
+ type_facts=type_facts,
)
@@ -1290,8 +1406,9 @@ def fortran_module_to_semantic_module(
*,
compile_time_values: dict[str, int | str] | None = None,
wrapped_derived_types: Iterable[tuple[str, str]] | None = None,
+ type_facts: dict[tuple[str, str | None], dict[str, object]] | None = None,
) -> SemanticModule:
- return _converter_for(compile_time_values, wrapped_derived_types).module_to_semantic_module(module)
+ return _converter_for(compile_time_values, wrapped_derived_types, type_facts).module_to_semantic_module(module)
def fortran_file_to_semantic_modules(
@@ -1300,8 +1417,9 @@ def fortran_file_to_semantic_modules(
standalone_module_name: str | None = None,
compile_time_values: dict[str, int | str] | None = None,
wrapped_derived_types: Iterable[tuple[str, str]] | None = None,
+ type_facts: dict[tuple[str, str | None], dict[str, object]] | None = None,
) -> list[SemanticModule]:
- return _converter_for(compile_time_values, wrapped_derived_types).file_to_semantic_modules(
+ return _converter_for(compile_time_values, wrapped_derived_types, type_facts).file_to_semantic_modules(
parsed_file,
standalone_module_name=standalone_module_name,
)
@@ -1311,8 +1429,9 @@ def fortran_project_to_semantic_modules(
project: FortranProject,
*,
compile_time_values: dict[str, int | str] | None = None,
+ type_facts: dict[tuple[str, str | None], dict[str, object]] | None = None,
) -> list[SemanticModule]:
- return _converter_for(compile_time_values).project_to_semantic_modules(project)
+ return _converter_for(compile_time_values, type_facts=type_facts).project_to_semantic_modules(project)
if __name__ == "__main__":
diff --git a/tests/parser/c/test_c_cli_skeleton.py b/tests/parser/c/test_c_cli_skeleton.py
index 4a2f142f8..95db369b6 100644
--- a/tests/parser/c/test_c_cli_skeleton.py
+++ b/tests/parser/c/test_c_cli_skeleton.py
@@ -244,7 +244,7 @@ def test_cli_c_semantics_json_stdout_for_header(tmp_path: Path):
argument_type = semantic_modules[0]["functions"][0]["arguments"][0]["semantic_type"]
assert argument_type["name"] == "Int"
assert argument_type["dtype"] == "Int32"
- assert argument_type["metadata"]["c_type_fact_source"] == "fallback"
+ assert argument_type["metadata"]["c_type_fact_source"] == "compiler_probe"
def test_cli_c_wrap_readiness_human_output_for_header(tmp_path: Path):
diff --git a/tests/parser/test_c_standard_type_probe.py b/tests/parser/test_c_standard_type_probe.py
index 062b78e22..7738bb2d2 100644
--- a/tests/parser/test_c_standard_type_probe.py
+++ b/tests/parser/test_c_standard_type_probe.py
@@ -1,6 +1,7 @@
"""Compiler-derived C standard-library type fact tests."""
import json
+import os
import shutil
import subprocess
import sys
@@ -10,9 +11,14 @@
import x2py.c_type_probe as c_type_probe
from x2py.c_type_probe import (
+ CStandardTypeProbeRecipe,
+ CStandardTypeProbeReport,
CStandardTypeProbeError,
_semantic_type_facts,
build_c_standard_type_probe_source,
+ c_standard_type_probe_cache_key,
+ load_c_standard_type_probe_report,
+ probe_c_standard_types_cached,
probe_c_standard_types,
)
from x2py.preprocessing import PreprocessingConfig
@@ -29,10 +35,17 @@ def _required_c_compiler() -> str:
def test_c_standard_type_probe_source_queries_standard_headers_without_layout_claims():
source = build_c_standard_type_probe_source()
+ assert "#include " in source
+ assert "#include " in source
assert "#include " in source
assert "#include " in source
assert "#include " in source
assert "#include " in source
+ assert 'X2PY_PRINT_ARITHMETIC("_Bool"' in source
+ assert "X2PY_PRINT_CHAR()" in source
+ assert 'X2PY_PRINT_ARITHMETIC("unsigned long"' in source
+ assert 'X2PY_PRINT_REAL("long double"' in source
+ assert 'X2PY_PRINT_ARITHMETIC("long double _Complex"' in source
assert 'X2PY_PRINT_ARITHMETIC("int"' in source
assert 'X2PY_PRINT_ARITHMETIC("size_t"' in source
assert 'X2PY_PRINT_ARITHMETIC("uint32_t"' in source
@@ -47,9 +60,14 @@ def test_c_standard_type_probe_requires_an_explicit_compiler():
def test_c_standard_type_probe_rejects_compile_database_and_classifies_all_arithmetic_categories():
+ compile_database = PreprocessingConfig(mode="compiler", compiler="cc", compile_commands="compile_commands.json")
with pytest.raises(CStandardTypeProbeError, match="does not consume compile_commands"):
+ probe_c_standard_types(compile_database)
+ with pytest.raises(CStandardTypeProbeError, match="does not consume compile_commands"):
+ probe_c_standard_types_cached(compile_database)
+ with pytest.raises(CStandardTypeProbeError, match="does not consume custom preprocessing templates"):
probe_c_standard_types(
- PreprocessingConfig(mode="compiler", compiler="cc", compile_commands="compile_commands.json")
+ PreprocessingConfig(mode="compiler", compiler="cc", command_template="{compiler} {source}")
)
types = {
@@ -118,6 +136,33 @@ def test_c_standard_type_probe_accepts_explicit_runner_and_cli_validates_macros(
c_type_probe.main(["--compiler", "cc", "-U", "=bad"])
+@pytest.mark.parametrize(
+ ("payload", "message"),
+ [
+ ([], "must contain a JSON object"),
+ ({}, "missing valid 'types'"),
+ ({"types": {}, "recipe": {}, "source_text": "probe"}, "missing a valid 'recipe'"),
+ ({"types": {}, "recipe": {"compiler": "cc"}}, "missing valid 'source_text'"),
+ ],
+)
+def test_c_standard_type_probe_report_loader_validates_reusable_reports(tmp_path, payload, message):
+ report_path = tmp_path / "report.json"
+ report_path.write_text(json.dumps(payload), encoding="utf-8")
+
+ with pytest.raises(CStandardTypeProbeError, match=message):
+ load_c_standard_type_probe_report(report_path)
+
+
+def test_c_standard_type_probe_report_loader_reports_read_and_json_errors(tmp_path):
+ with pytest.raises(CStandardTypeProbeError, match="failed to read"):
+ load_c_standard_type_probe_report(tmp_path / "missing.json")
+
+ report_path = tmp_path / "invalid.json"
+ report_path.write_text("not json", encoding="utf-8")
+ with pytest.raises(CStandardTypeProbeError, match="contains invalid JSON"):
+ load_c_standard_type_probe_report(report_path)
+
+
def test_c_standard_type_probe_reports_semantic_facts_from_native_compiler():
compiler = _required_c_compiler()
report = probe_c_standard_types(PreprocessingConfig(mode="compiler", compiler=compiler, std="c11"))
@@ -129,6 +174,23 @@ def test_c_standard_type_probe_reports_semantic_facts_from_native_compiler():
assert c_int["underlying_c_type"] == "int"
assert c_int["bits"] >= 16
+ plain_char = report.types["char"]
+ assert plain_char["kind"] == "integer"
+ assert isinstance(plain_char["signed"], bool)
+
+ c_long = report.types["long"]
+ assert c_long["kind"] == "integer"
+ assert c_long["signed"] is True
+ assert c_long["bits"] >= c_int["bits"]
+
+ long_double = report.types["long double"]
+ assert long_double["kind"] == "real"
+ assert long_double["precision_bits"] > 0
+
+ long_double_complex = report.types["long double _Complex"]
+ assert long_double_complex["kind"] == "complex"
+ assert long_double_complex["bits"] >= long_double["bits"]
+
size_t = report.types["size_t"]
assert size_t["available"] is True
assert size_t["kind"] == "integer"
@@ -188,6 +250,68 @@ def test_c_standard_type_probe_carries_target_relevant_user_flags(tmp_path):
assert report.recipe.defines == ["X2PY_FEATURE=1"]
assert report.recipe.undefs == ["X2PY_OLD_FEATURE"]
assert report.recipe.compiler_args == ["-funsigned-char"]
+ assert report.types["char"]["signed"] is False
+
+
+def test_c_standard_type_probe_cache_reuses_report_and_invalidates_for_flags(monkeypatch, tmp_path):
+ c_type_probe._MEMORY_CACHE.clear()
+ calls = []
+ compiler = tmp_path / "fake-cc"
+ compiler.write_text("first compiler identity", encoding="utf-8")
+ report = CStandardTypeProbeReport(
+ types={"int": {"available": True, "kind": "integer", "signed": True, "bits": 32}},
+ recipe=CStandardTypeProbeRecipe(compiler=str(compiler), compile_argv=[str(compiler)], run_argv=["probe"]),
+ source_text=build_c_standard_type_probe_source(),
+ )
+
+ def probe(config, *, runner=None):
+ calls.append((config, runner))
+ return report
+
+ monkeypatch.setattr(c_type_probe, "probe_c_standard_types", probe)
+ config = PreprocessingConfig(mode="compiler", compiler=str(compiler), compiler_args=["-m64"])
+
+ first = probe_c_standard_types_cached(config, cache_dir=tmp_path)
+ second = probe_c_standard_types_cached(config, cache_dir=tmp_path)
+ assert first is second
+ assert len(calls) == 1
+
+ c_type_probe._MEMORY_CACHE.clear()
+ loaded = probe_c_standard_types_cached(config, cache_dir=tmp_path)
+ assert loaded.types == report.types
+ assert len(calls) == 1
+
+ probe_c_standard_types_cached(config, cache_dir=tmp_path, refresh=True)
+ assert len(calls) == 2
+
+ changed = PreprocessingConfig(mode="compiler", compiler=str(compiler), compiler_args=["-m32"])
+ assert c_standard_type_probe_cache_key(changed) != c_standard_type_probe_cache_key(config)
+ assert c_standard_type_probe_cache_key(config, runner=["runner"]) != c_standard_type_probe_cache_key(config)
+ probe_c_standard_types_cached(changed, cache_dir=tmp_path)
+ assert len(calls) == 3
+
+ original_key = c_standard_type_probe_cache_key(config)
+ original_cpath = os.environ.get("CPATH")
+ monkeypatch.setenv("CPATH", "target/include")
+ assert c_standard_type_probe_cache_key(config) != original_key
+ if original_cpath is None:
+ monkeypatch.delenv("CPATH")
+ else:
+ monkeypatch.setenv("CPATH", original_cpath)
+ compiler.write_text("changed compiler identity and size", encoding="utf-8")
+ assert c_standard_type_probe_cache_key(config) != original_key
+
+
+def test_c_standard_type_probe_cache_directory_precedence(monkeypatch, tmp_path):
+ explicit = tmp_path / "explicit"
+ assert c_type_probe._probe_cache_dir(explicit) == explicit
+
+ monkeypatch.setenv("X2PY_CACHE_DIR", str(tmp_path / "x2py"))
+ monkeypatch.setenv("XDG_CACHE_HOME", str(tmp_path / "xdg"))
+ assert c_type_probe._probe_cache_dir(None) == tmp_path / "x2py" / "c_type_probe"
+
+ monkeypatch.delenv("X2PY_CACHE_DIR")
+ assert c_type_probe._probe_cache_dir(None) == tmp_path / "xdg" / "x2py" / "c_type_probe"
def test_c_standard_type_probe_module_cli_emits_json_for_semantic_input():
@@ -203,4 +327,4 @@ def test_c_standard_type_probe_module_cli_emits_json_for_semantic_input():
assert payload["types"]["size_t"]["semantic_category"] == "unsigned_integer"
assert payload["types"]["FILE"]["kind"] == "opaque_handle"
assert payload["recipe"]["compiler"] == compiler
- assert payload["source_text"].startswith("#include ")
+ assert payload["source_text"].startswith("#include ")
diff --git a/tests/parser/test_cli.py b/tests/parser/test_cli.py
index 841d50c35..538af1c7a 100644
--- a/tests/parser/test_cli.py
+++ b/tests/parser/test_cli.py
@@ -37,6 +37,14 @@ def _main_args(**overrides):
"undefs": [],
"std": None,
"compiler_args": [],
+ "c_type_report": None,
+ "c_type_probe_runner": [],
+ "c_type_probe_cache_dir": None,
+ "refresh_c_type_probe": False,
+ "fortran_type_report": None,
+ "fortran_type_probe_runner": [],
+ "fortran_type_probe_cache_dir": None,
+ "refresh_fortran_type_probe": False,
"include_exposure": "reachable-project",
"public_includes": [],
"private_includes": [],
@@ -888,6 +896,111 @@ class StopAfterDispatch(Exception):
x2py_cli.main()
+def test_x2py_main_reuses_one_c_type_report_across_semantic_and_readiness_stages(monkeypatch):
+ class StopAfterDispatch(Exception):
+ pass
+
+ args = _main_args(
+ language="c",
+ semantics=True,
+ wrap_readiness=True,
+ c_type_probe_runner=["qemu"],
+ c_type_probe_cache_dir="cache",
+ refresh_c_type_probe=True,
+ )
+ _install_main_parser(monkeypatch, args)
+ preprocessing = object()
+ report = {"types": {"long": {"kind": "integer", "signed": True, "bits": 32}}}
+ calls = []
+
+ monkeypatch.setattr(x2py_cli, "_resolve_language", lambda paths, language, parser: language)
+ monkeypatch.setattr(x2py_cli, "_build_preprocessing_config", lambda active_args, parser: preprocessing)
+ monkeypatch.setattr(
+ x2py_cli,
+ "_c_standard_type_report",
+ lambda active_preprocessing, **kwargs: calls.append(("probe", active_preprocessing, kwargs)) or report,
+ )
+ monkeypatch.setattr(
+ x2py_cli,
+ "_semantic_report",
+ lambda paths, active_preprocessing, **kwargs: calls.append(("semantic", kwargs)) or {},
+ )
+ monkeypatch.setattr(
+ x2py_cli,
+ "_wrap_readiness_report",
+ lambda paths, active_preprocessing, **kwargs: calls.append(("readiness", kwargs)) or {},
+ )
+ monkeypatch.setattr(
+ x2py_cli,
+ "_attach_wrap_readiness",
+ lambda semantic_payload, readiness_payload: (_ for _ in ()).throw(StopAfterDispatch),
+ )
+
+ with pytest.raises(StopAfterDispatch):
+ x2py_cli.main()
+
+ assert calls == [
+ (
+ "probe",
+ preprocessing,
+ {
+ "report_path": None,
+ "runner": ["qemu"],
+ "cache_dir": "cache",
+ "refresh": True,
+ },
+ ),
+ ("semantic", {"language": "c", "c_standard_type_report": report}),
+ ("readiness", {"language": "c", "c_standard_type_report": report}),
+ ]
+
+
+def test_x2py_main_forwards_fortran_type_probe_options_to_semantic_stages(monkeypatch):
+ class StopAfterDispatch(Exception):
+ pass
+
+ args = _main_args(
+ semantics=True,
+ wrap_readiness=True,
+ fortran_type_probe_runner=["qemu"],
+ fortran_type_probe_cache_dir="cache",
+ refresh_fortran_type_probe=True,
+ )
+ _install_main_parser(monkeypatch, args)
+ preprocessing = object()
+ calls = []
+
+ monkeypatch.setattr(x2py_cli, "_resolve_language", lambda paths, language, parser: language)
+ monkeypatch.setattr(x2py_cli, "_build_preprocessing_config", lambda active_args, parser: preprocessing)
+ monkeypatch.setattr(
+ x2py_cli,
+ "_semantic_report",
+ lambda paths, active_preprocessing, **kwargs: calls.append(("semantic", kwargs)) or {},
+ )
+ monkeypatch.setattr(
+ x2py_cli,
+ "_wrap_readiness_report",
+ lambda paths, active_preprocessing, **kwargs: calls.append(("readiness", kwargs)) or {},
+ )
+ monkeypatch.setattr(
+ x2py_cli,
+ "_attach_wrap_readiness",
+ lambda semantic_payload, readiness_payload: (_ for _ in ()).throw(StopAfterDispatch),
+ )
+
+ with pytest.raises(StopAfterDispatch):
+ x2py_cli.main()
+
+ expected = {
+ "language": "fortran",
+ "fortran_type_report": None,
+ "fortran_type_probe_runner": ["qemu"],
+ "fortran_type_probe_cache_dir": "cache",
+ "refresh_fortran_type_probe": True,
+ }
+ assert calls == [("semantic", expected), ("readiness", expected)]
+
+
@pytest.mark.parametrize(
("overrides", "expected"),
[
@@ -907,6 +1020,27 @@ class StopAfterDispatch(Exception):
({"print_limit": 1}, "--show-vars/--print-limit require --parse"),
({"vars_limit": 1}, "--show-vars/--print-limit require --parse"),
({"parse": True, "print_limit": -1}, "--print-limit must be >= 0"),
+ ({"parse": True, "c_type_report": "types.json"}, "C type probe options require --language c"),
+ (
+ {"language": "c", "parse": True, "refresh_c_type_probe": True},
+ "C type probe options require --semantics, --pyi, or --wrap-readiness",
+ ),
+ (
+ {"language": "c", "semantics": True, "c_type_report": "types.json", "refresh_c_type_probe": True},
+ "--c-type-report cannot be combined with automatic C type probe options",
+ ),
+ (
+ {"language": "c", "semantics": True, "fortran_type_report": "types.json"},
+ "Fortran type probe options require --language fortran",
+ ),
+ (
+ {"parse": True, "refresh_fortran_type_probe": True},
+ "Fortran type probe options require --semantics, --pyi, or --wrap-readiness",
+ ),
+ (
+ {"semantics": True, "fortran_type_report": "types.json", "refresh_fortran_type_probe": True},
+ "--fortran-type-report cannot be combined with automatic Fortran type probe options",
+ ),
({}, "Select at least one stage flag: --parse, --semantics, --pyi, or --wrap-readiness"),
],
)
@@ -1823,6 +1957,66 @@ def parse_args(self):
"help": "Raw compiler preprocessing argument. Use --compiler-arg=-target for values starting with '-'.",
},
),
+ (
+ ("--c-type-report",),
+ {
+ "metavar": "PATH",
+ "help": "Reuse a C ABI report generated by `python -m x2py.c_type_probe`.",
+ },
+ ),
+ (
+ ("--c-type-probe-runner",),
+ {
+ "dest": "c_type_probe_runner",
+ "action": "append",
+ "metavar": "ARG",
+ "help": "Runner command item for a cross-compiled C ABI probe; repeat for arguments.",
+ },
+ ),
+ (
+ ("--c-type-probe-cache-dir",),
+ {
+ "metavar": "PATH",
+ "help": "Directory for reusable automatic C ABI probe results.",
+ },
+ ),
+ (
+ ("--refresh-c-type-probe",),
+ {
+ "action": "store_true",
+ "help": "Ignore a reusable C ABI result and probe the selected compiler target again.",
+ },
+ ),
+ (
+ ("--fortran-type-report",),
+ {
+ "metavar": "PATH",
+ "help": "Reuse a Fortran type report generated by `python -m x2py.fortran_type_probe`.",
+ },
+ ),
+ (
+ ("--fortran-type-probe-runner",),
+ {
+ "dest": "fortran_type_probe_runner",
+ "action": "append",
+ "metavar": "ARG",
+ "help": "Runner command item for a cross-compiled Fortran type probe; repeat for arguments.",
+ },
+ ),
+ (
+ ("--fortran-type-probe-cache-dir",),
+ {
+ "metavar": "PATH",
+ "help": "Directory for reusable automatic Fortran type probe results.",
+ },
+ ),
+ (
+ ("--refresh-fortran-type-probe",),
+ {
+ "action": "store_true",
+ "help": "Ignore reusable Fortran type results and probe the selected compiler target again.",
+ },
+ ),
(
("--include-exposure",),
{
@@ -2445,6 +2639,8 @@ def test_x2py_fortran_readiness_helpers_attach_and_compile(monkeypatch):
calls = []
requirements = {"api_mod": {"dp": "kind(1.0d0)"}}
values = {"api_mod.dp": 8}
+ storage_requirements = [{"base_type": "real", "kind": "8", "expression": "storage_size(real(0.0,kind=8))"}]
+ facts = {("real", "8"): {"base_type": "real", "kind": "8", "bits": 64}}
def collect_requirements(received):
assert received is parsed
@@ -2457,8 +2653,22 @@ def evaluate_requirements(received_config, received_requirements):
calls.append(("evaluate", received_config, received_requirements))
return values
+ def collect_storage(received, *, compile_time_values):
+ assert received is parsed
+ assert compile_time_values is values
+ calls.append(("collect_storage", received))
+ return storage_requirements
+
+ def evaluate_facts(received_config, received_requirements):
+ assert received_config is compiler_config
+ assert received_requirements is storage_requirements
+ calls.append(("evaluate_facts", received_config, received_requirements))
+ return facts
+
monkeypatch.setattr("semantics.fortran2ir.collect_semantic_compile_time_requirements", collect_requirements)
+ monkeypatch.setattr("semantics.fortran2ir.collect_fortran_type_storage_requirements", collect_storage)
monkeypatch.setattr("x2py.fortran_type_probe.evaluate_fortran_type_requirements", evaluate_requirements)
+ monkeypatch.setattr("x2py.fortran_type_probe.evaluate_fortran_type_facts", evaluate_facts)
raw_config_with_compiler = x2py_cli.PreprocessingConfig(compiler="gfortran")
assert x2py_cli._fortran_compile_time_values(parsed, raw_config_with_compiler) is None
@@ -2467,6 +2677,8 @@ def evaluate_requirements(received_config, received_requirements):
compiler_config = x2py_cli.PreprocessingConfig(mode="compiler", compiler="gfortran")
assert x2py_cli._fortran_compile_time_values(parsed, compiler_config) == values
assert calls == [("collect", parsed), ("evaluate", compiler_config, requirements)]
+ assert x2py_cli._fortran_type_facts(parsed, compiler_config, compile_time_values=values) == facts
+ assert calls[-2:] == [("collect_storage", parsed), ("evaluate_facts", compiler_config, storage_requirements)]
def test_x2py_fortran_source_for_path_raw_uses_utf8_and_internal_recipe():
@@ -2571,6 +2783,7 @@ def test_x2py_semantic_report_preserves_c_module_and_dependency_contracts(monkey
path = Path("api.h")
config = object()
project = object()
+ standard_type_report = {"types": {"long": {"kind": "integer", "signed": True, "bits": 32}}}
module = types.SimpleNamespace(name="api", origin=types.SimpleNamespace(native_name=str(path)))
stubs = {
"api": "def api() -> None: ...",
@@ -2582,8 +2795,9 @@ def parse_project(paths, preprocessing):
assert preprocessing is config
return project
- def convert(received):
+ def convert(received, *, standard_type_report: object):
assert received is project
+ assert standard_type_report == {"types": {"long": {"kind": "integer", "signed": True, "bits": 32}}}
return [module]
def expand(paths):
@@ -2605,7 +2819,12 @@ def serialize(received):
monkeypatch.setattr("semantics.pyi_printer.emit_module_stubs", emit)
monkeypatch.setattr(x2py_cli, "asdict", serialize)
- assert x2py_cli._semantic_report(["api"], config, language="c") == {
+ assert x2py_cli._semantic_report(
+ ["api"],
+ config,
+ language="c",
+ c_standard_type_report=standard_type_report,
+ ) == {
str(path): {
"semantic_modules": [{"name": "api"}],
"pyi": "def api() -> None: ...",
@@ -2614,6 +2833,38 @@ def serialize(received):
}
+def test_x2py_c_standard_type_report_uses_cached_direct_probe_and_rejects_ambiguous_recipe(monkeypatch):
+ config = PreprocessingConfig(mode="compiler", compiler="cc", compiler_args=["-m32"])
+ expected = {"types": {"long": {"kind": "integer", "signed": True, "bits": 32}}}
+ calls = []
+
+ class Report:
+ def to_dict(self):
+ return expected
+
+ def probe(received, *, runner, cache_dir, refresh):
+ calls.append((received, runner, cache_dir, refresh))
+ return Report()
+
+ monkeypatch.setattr(x2py_cli, "probe_c_standard_types_cached", probe)
+
+ assert (
+ x2py_cli._c_standard_type_report(
+ config,
+ runner=["qemu"],
+ cache_dir="cache",
+ refresh=True,
+ )
+ == expected
+ )
+ assert calls == [(config, ["qemu"], "cache", True)]
+
+ with pytest.raises(ValueError, match="--c-type-report"):
+ x2py_cli._c_standard_type_report(
+ PreprocessingConfig(mode="compiler", compiler="cc", compile_commands="compile_commands.json")
+ )
+
+
def test_x2py_semantic_report_preserves_fortran_conversion_and_stub_contracts(monkeypatch):
path = Path("api.f90")
config = object()
diff --git a/tests/parser/test_declaration_and_interface_edges.py b/tests/parser/test_declaration_and_interface_edges.py
index 615c52695..77d0b016a 100644
--- a/tests/parser/test_declaration_and_interface_edges.py
+++ b/tests/parser/test_declaration_and_interface_edges.py
@@ -198,6 +198,7 @@ def test_declaration_and_execution_edge_branches_from_inline_fortran():
assert args["i"].kind == "4"
assert args["x"].base_type == "real"
assert args["y"].base_type == "real"
+ assert args["y"].target_kind_expression == "kind(1.0d0)"
def test_nested_interface_dummy_procedure_and_generic_module_procedure_interface():
diff --git a/tests/parser/test_fortran_type_probe.py b/tests/parser/test_fortran_type_probe.py
index 37acbed21..e9bf7c3a0 100644
--- a/tests/parser/test_fortran_type_probe.py
+++ b/tests/parser/test_fortran_type_probe.py
@@ -20,9 +20,13 @@
FortranTypeProbeError,
_value_for_expression,
build_fortran_type_probe_source,
+ evaluate_fortran_type_facts,
evaluate_fortran_type_requirements,
+ fortran_type_probe_cache_key,
fortran_type_probe_expressions,
+ load_fortran_type_probe_report,
probe_fortran_type_expressions,
+ probe_fortran_type_expressions_cached,
)
from x2py.preprocessing import PreprocessingConfig
@@ -50,6 +54,36 @@ def test_fortran_type_probe_source_evaluates_integer_initialization_expressions(
assert "x2py_value_1" not in normalized
+def test_fortran_type_probe_wraps_long_intrinsic_import_lists():
+ source = build_fortran_type_probe_source(
+ [
+ "c_bool",
+ "c_char",
+ "c_double",
+ "c_double_complex",
+ "c_float",
+ "c_float_complex",
+ "c_int",
+ "c_int16_t",
+ "c_int32_t",
+ "c_int64_t",
+ "c_int8_t",
+ "c_long",
+ "c_long_double",
+ "c_long_double_complex",
+ "c_long_long",
+ "c_short",
+ "c_signed_char",
+ "c_size_t",
+ ]
+ )
+
+ assert "use, intrinsic :: iso_c_binding, only: &" in source
+ assert " c_bool, &" in source
+ assert " c_size_t\n" in source
+ assert all(len(line) <= 120 for line in source.splitlines())
+
+
def test_x2py_public_api_lazily_exposes_type_probe_symbols_and_rejects_unknown_names():
import x2py
@@ -80,6 +114,113 @@ def test_fortran_type_probe_rejects_compile_database_and_validates_expression_fo
)
with pytest.raises(FortranTypeProbeError, match="unsupported characters"):
build_fortran_type_probe_source(["selected_real_kind(12)!"])
+ with pytest.raises(FortranTypeProbeError, match="custom preprocessing templates"):
+ probe_fortran_type_expressions(
+ PreprocessingConfig(mode="compiler", compiler="gfortran", command_template="{compiler} {source}"),
+ ["selected_real_kind(12)"],
+ )
+
+
+@pytest.mark.parametrize(
+ ("payload", "message"),
+ [
+ ([], "must contain a JSON object"),
+ ({}, "missing valid 'values'"),
+ ({"values": {}, "recipe": {}, "source_text": "probe"}, "missing a valid 'recipe'"),
+ ({"values": {}, "recipe": {"compiler": "gfortran"}}, "missing valid 'source_text'"),
+ ],
+)
+def test_fortran_type_probe_report_loader_validates_reusable_reports(tmp_path, payload, message):
+ report_path = tmp_path / "report.json"
+ report_path.write_text(json.dumps(payload), encoding="utf-8")
+
+ with pytest.raises(FortranTypeProbeError, match=message):
+ load_fortran_type_probe_report(report_path)
+
+
+def test_fortran_type_probe_report_loader_reports_read_json_and_missing_expression_errors(tmp_path):
+ with pytest.raises(FortranTypeProbeError, match="failed to read"):
+ load_fortran_type_probe_report(tmp_path / "missing.json")
+
+ report_path = tmp_path / "invalid.json"
+ report_path.write_text("not json", encoding="utf-8")
+ with pytest.raises(FortranTypeProbeError, match="contains invalid JSON"):
+ load_fortran_type_probe_report(report_path)
+
+ report = FortranTypeProbeReport(
+ values={"selected_real_kind(12)": 8},
+ recipe=FortranTypeProbeRecipe(
+ compiler="gfortran",
+ compile_argv=[],
+ run_argv=[],
+ expressions=["selected_real_kind(12)"],
+ ),
+ source_text="probe",
+ )
+ with pytest.raises(FortranTypeProbeError, match="missing required expressions"):
+ evaluate_fortran_type_facts(
+ PreprocessingConfig(),
+ [{"base_type": "real", "kind": None, "expression": "storage_size(real(0.0))"}],
+ report=report,
+ )
+
+
+def test_fortran_type_probe_cache_directory_precedence(monkeypatch, tmp_path):
+ explicit = tmp_path / "explicit"
+ assert fortran_type_probe._probe_cache_dir(explicit) == explicit
+
+ monkeypatch.setenv("X2PY_CACHE_DIR", str(tmp_path / "x2py"))
+ monkeypatch.setenv("XDG_CACHE_HOME", str(tmp_path / "xdg"))
+ assert fortran_type_probe._probe_cache_dir(None) == tmp_path / "x2py" / "fortran_type_probe"
+
+ monkeypatch.delenv("X2PY_CACHE_DIR")
+ assert fortran_type_probe._probe_cache_dir(None) == tmp_path / "xdg" / "x2py" / "fortran_type_probe"
+
+
+def test_fortran_type_probe_cache_reuses_report_and_invalidates_for_flags(monkeypatch, tmp_path):
+ fortran_type_probe._MEMORY_CACHE.clear()
+ calls = []
+ compiler = tmp_path / "fake-gfortran"
+ compiler.write_text("first compiler identity", encoding="utf-8")
+ expression = "storage_size(real(0.0))"
+ report = FortranTypeProbeReport(
+ values={expression: 32},
+ recipe=FortranTypeProbeRecipe(
+ compiler=str(compiler),
+ compile_argv=[str(compiler)],
+ run_argv=["probe"],
+ expressions=[expression],
+ ),
+ source_text=build_fortran_type_probe_source([expression]),
+ )
+
+ def probe(config, expressions, *, runner=None):
+ calls.append((config, expressions, runner))
+ return report
+
+ monkeypatch.setattr(fortran_type_probe, "probe_fortran_type_expressions", probe)
+ config = PreprocessingConfig(mode="compiler", compiler=str(compiler), compiler_args=["-fdefault-real-8"])
+
+ first = probe_fortran_type_expressions_cached(config, [expression], cache_dir=tmp_path)
+ second = probe_fortran_type_expressions_cached(config, [expression], cache_dir=tmp_path)
+ assert first is second
+ assert len(calls) == 1
+
+ fortran_type_probe._MEMORY_CACHE.clear()
+ loaded = probe_fortran_type_expressions_cached(config, [expression], cache_dir=tmp_path)
+ assert loaded.values == report.values
+ assert len(calls) == 1
+
+ changed = PreprocessingConfig(mode="compiler", compiler=str(compiler), compiler_args=["-fdefault-real-16"])
+ assert fortran_type_probe_cache_key(changed, [expression]) != fortran_type_probe_cache_key(config, [expression])
+ assert fortran_type_probe_cache_key(config, ["storage_size(int(0))"]) != fortran_type_probe_cache_key(
+ config, [expression]
+ )
+ probe_fortran_type_expressions_cached(changed, [expression], cache_dir=tmp_path)
+ assert len(calls) == 2
+
+ probe_fortran_type_expressions_cached(config, [expression], cache_dir=tmp_path, refresh=True)
+ assert len(calls) == 3
def test_fortran_type_probe_expressions_extracts_semantic_requirement_inputs():
@@ -241,6 +382,34 @@ def test_fortran_type_probe_carries_target_relevant_user_flags(tmp_path):
assert report.recipe.compiler_args == ["-fno-range-check"]
+def test_fortran_type_probe_maps_compiler_storage_facts():
+ compiler = _required_fortran_compiler()
+ requirements = [
+ {
+ "base_type": "integer",
+ "kind": None,
+ "expression": "storage_size(int(0))",
+ },
+ {
+ "base_type": "real",
+ "kind": None,
+ "expression": "storage_size(real(0.0))",
+ },
+ ]
+
+ facts = evaluate_fortran_type_facts(
+ PreprocessingConfig(
+ mode="compiler",
+ compiler=compiler,
+ compiler_args=["-fdefault-integer-8", "-fdefault-real-8"],
+ ),
+ requirements,
+ )
+
+ assert facts[("integer", None)]["bits"] == 64
+ assert facts[("real", None)]["bits"] == 64
+
+
def test_fortran_type_probe_evaluates_collected_semantic_requirements():
compiler = _required_fortran_compiler()
parsed = parse_fortran_source(
@@ -266,7 +435,7 @@ def test_fortran_type_probe_evaluates_collected_semantic_requirements():
assert module.functions[0].arguments[0].semantic_type.name == "Float64"
-def test_fortran_type_probe_module_cli_emits_json_for_semantic_input():
+def test_fortran_type_probe_module_cli_emits_json_for_semantic_input(tmp_path):
compiler = _required_fortran_compiler()
completed = subprocess.run(
[
@@ -279,6 +448,9 @@ def test_fortran_type_probe_module_cli_emits_json_for_semantic_input():
"selected_int_kind(9)",
"--expr",
"selected_real_kind(12)",
+ "--cache-dir",
+ str(tmp_path / "cache"),
+ "--refresh",
],
capture_output=True,
text=True,
@@ -327,3 +499,104 @@ def test_x2py_semantics_cli_evaluates_collected_fortran_type_requirements(tmp_pa
payload = json.loads(completed.stdout)
semantic_type = payload[str(source)]["semantic_modules"][0]["functions"][0]["arguments"][0]["semantic_type"]
assert semantic_type["name"] == "Float64"
+
+
+def test_x2py_semantics_cli_uses_compiler_dependent_default_fortran_kinds(tmp_path):
+ compiler = _required_fortran_compiler()
+ source = tmp_path / "defaults.f90"
+ source.write_text(
+ """
+module defaults
+ integer :: count
+ real :: scale
+ complex :: value
+ double precision :: double_scale
+ double complex :: double_value
+ complex*16 :: legacy_value
+end module defaults
+""",
+ encoding="utf-8",
+ )
+
+ completed = subprocess.run(
+ [
+ sys.executable,
+ "-m",
+ "x2py",
+ str(source),
+ "--semantics",
+ "--compiler",
+ compiler,
+ "--compiler-arg=-fdefault-integer-8",
+ "--compiler-arg=-fdefault-real-8",
+ "--json",
+ ],
+ capture_output=True,
+ text=True,
+ check=True,
+ )
+
+ payload = json.loads(completed.stdout)
+ variables = payload[str(source)]["semantic_modules"][0]["variables"]
+ semantic_types = {variable["name"]: variable["semantic_type"] for variable in variables}
+ assert semantic_types["count"]["name"] == "Int64"
+ assert semantic_types["scale"]["name"] == "Float64"
+ assert semantic_types["value"]["name"] == "Complex128"
+ assert semantic_types["double_scale"]["name"] == "Float128"
+ assert semantic_types["double_value"]["name"] == "Complex256"
+ assert semantic_types["legacy_value"]["name"] == "Complex128"
+ assert semantic_types["scale"]["metadata"]["fortran_type_fact_source"] == "compiler_probe"
+ assert semantic_types["legacy_value"]["metadata"]["fortran_type_fact_source"] == "legacy_star_storage"
+
+
+def test_x2py_semantics_cli_reuses_explicit_fortran_type_report(tmp_path):
+ compiler = _required_fortran_compiler()
+ source = tmp_path / "defaults.f90"
+ source.write_text(
+ """
+module defaults
+ real :: scale
+end module defaults
+""",
+ encoding="utf-8",
+ )
+ expression = "storage_size(real(0.0))"
+ report_path = tmp_path / "fortran-types.json"
+ report_path.write_text(
+ json.dumps(
+ {
+ "values": {expression: 64},
+ "recipe": {
+ "compiler": compiler,
+ "compile_argv": [],
+ "run_argv": [],
+ "expressions": [expression],
+ },
+ "source_text": "reusable test probe",
+ }
+ ),
+ encoding="utf-8",
+ )
+
+ completed = subprocess.run(
+ [
+ sys.executable,
+ "-m",
+ "x2py",
+ str(source),
+ "--semantics",
+ "--compiler",
+ compiler,
+ "--fortran-type-report",
+ str(report_path),
+ "--json",
+ ],
+ capture_output=True,
+ text=True,
+ check=True,
+ )
+
+ payload = json.loads(completed.stdout)
+ semantic_type = payload[str(source)]["semantic_modules"][0]["variables"][0]["semantic_type"]
+ assert semantic_type["name"] == "Float64"
+ assert semantic_type["metadata"]["fortran_type_fact"]["expression"] == expression
diff --git a/tests/parser/test_function_header_parsing.py b/tests/parser/test_function_header_parsing.py
index 125d6a0c4..7881c22a0 100644
--- a/tests/parser/test_function_header_parsing.py
+++ b/tests/parser/test_function_header_parsing.py
@@ -26,6 +26,9 @@ def test_typed_function_result_headers_are_parsed_from_inline_fortran():
double precision function norm2()
end function norm2
+
+ double complex function complex_norm2()
+ end function complex_norm2
end module typed_result_mod
"""
@@ -40,6 +43,9 @@ def test_typed_function_result_headers_are_parsed_from_inline_fortran():
assert procedures["weighted_value"].result.base_type == "real"
assert procedures["weighted_value"].result.kind == "8"
assert procedures["norm2"].result.base_type == "real"
+ assert procedures["norm2"].result.target_kind_expression == "kind(1.0d0)"
+ assert procedures["complex_norm2"].result.base_type == "complex"
+ assert procedures["complex_norm2"].result.target_kind_expression == "kind(1.0d0)"
def test_legacy_star_kind_function_headers_are_parsed_from_inline_fixed_form():
@@ -64,10 +70,13 @@ def test_legacy_star_kind_function_headers_are_parsed_from_inline_fixed_form():
assert procedures["zdotc"].result.base_type == "complex"
assert procedures["zdotc"].result.kind == "16"
+ assert procedures["zdotc"].result.declared_storage_bits == 128
assert procedures["trans_name"].result.base_type == "character"
assert procedures["trans_name"].result.kind == "1"
+ assert procedures["trans_name"].result.character_length_syntax is True
assert procedures["any_name"].result.base_type == "character"
assert procedures["any_name"].result.kind == "*"
+ assert procedures["any_name"].result.character_length_syntax is True
def test_no_argument_headers_without_parentheses_are_parsed():
diff --git a/tests/parser/test_preprocessing_cli.py b/tests/parser/test_preprocessing_cli.py
index 86ed9cd17..5c71feea8 100644
--- a/tests/parser/test_preprocessing_cli.py
+++ b/tests/parser/test_preprocessing_cli.py
@@ -2472,6 +2472,17 @@ def test_cli_c_compiler_mode_macro_metadata_flows_to_semantic_constants(tmp_path
tmp_path,
"#define API_VERSION 3\nint api(void);\n",
)
+ type_report = tmp_path / "c-types.json"
+ type_report.write_text(
+ json.dumps(
+ {
+ "types": {"int": {"available": True, "kind": "integer", "signed": True, "bits": 32}},
+ "recipe": {"compiler": str(compiler), "compile_argv": [], "run_argv": []},
+ "source_text": "reusable test probe",
+ }
+ ),
+ encoding="utf-8",
+ )
res = subprocess.run(
[
@@ -2485,6 +2496,8 @@ def test_cli_c_compiler_mode_macro_metadata_flows_to_semantic_constants(tmp_path
"--json",
"--compiler",
str(compiler),
+ "--c-type-report",
+ str(type_report),
],
capture_output=True,
text=True,
diff --git a/tests/parser/test_procedure_and_type_parsing.py b/tests/parser/test_procedure_and_type_parsing.py
index 2557d4399..ed0f69086 100644
--- a/tests/parser/test_procedure_and_type_parsing.py
+++ b/tests/parser/test_procedure_and_type_parsing.py
@@ -218,19 +218,30 @@ def test_builtin_star_kind_declarations_preserve_all_intrinsic_kinds():
assert args["i1"].base_type == "integer"
assert args["i1"].kind == "4"
+ assert args["i1"].declared_storage_bits == 32
assert args["i2"].kind == "8"
+ assert args["i2"].declared_storage_bits == 64
assert args["r1"].base_type == "real"
assert args["r1"].kind == "4"
+ assert args["r1"].declared_storage_bits == 32
assert args["r2"].kind == "8"
+ assert args["r2"].declared_storage_bits == 64
assert args["c1"].base_type == "complex"
assert args["c1"].kind == "8"
+ assert args["c1"].declared_storage_bits == 64
assert args["c2"].kind == "16"
+ assert args["c2"].declared_storage_bits == 128
assert args["l1"].base_type == "logical"
assert args["l1"].kind == "1"
+ assert args["l1"].declared_storage_bits == 8
assert args["l2"].kind == "4"
+ assert args["l2"].declared_storage_bits == 32
assert args["ch1"].base_type == "character"
assert args["ch1"].kind == "8"
+ assert args["ch1"].character_length_syntax is True
+ assert args["ch1"].declared_storage_bits is None
assert args["ch2"].kind == "*"
+ assert args["ch2"].character_length_syntax is True
def test_fixed_form_and_interface_detection():
diff --git a/tests/property/test_semantic_properties.py b/tests/property/test_semantic_properties.py
index 38618c12f..a6bc60ba5 100644
--- a/tests/property/test_semantic_properties.py
+++ b/tests/property/test_semantic_properties.py
@@ -41,15 +41,15 @@
[
("integer", "Int32"),
("logical", "Bool"),
- ("real", "Float64"),
+ ("real", "Float32"),
("real(4)", "Float32"),
]
)
_SHARED_VALUE_TYPES = st.sampled_from(
[
("_Bool", "logical", "Bool"),
- ("double", "real", "Float64"),
- ("float", "real(4)", "Float32"),
+ ("double", "real(8)", "Float64"),
+ ("float", "real", "Float32"),
]
)
_SEMANTIC_SCALAR_TYPES = st.sampled_from(["Bool", "Float32", "Float64", "Int32"])
diff --git a/tests/pyi/fixtures/general/compile_time_shape_exprs.pyi b/tests/pyi/fixtures/general/compile_time_shape_exprs.pyi
index ab2e8eecc..9ea1ff801 100644
--- a/tests/pyi/fixtures/general/compile_time_shape_exprs.pyi
+++ b/tests/pyi/fixtures/general/compile_time_shape_exprs.pyi
@@ -4,5 +4,5 @@ n1: Final[Int32]
def use_expr(
x: Int32[n1 - 1 - 0 + 1],
- y: Float64[n0 * 2]
+ y: Float32[n0 * 2]
) -> None: ...
diff --git a/tests/pyi/fixtures/general/scope_name_reuse_combinations.pyi b/tests/pyi/fixtures/general/scope_name_reuse_combinations.pyi
index 37c4da2a3..6e181755d 100644
--- a/tests/pyi/fixtures/general/scope_name_reuse_combinations.pyi
+++ b/tests/pyi/fixtures/general/scope_name_reuse_combinations.pyi
@@ -3,11 +3,11 @@ class same_name:
same_name_i: Int32
-same_name_r: Float64
+same_name_r: Float32
same_name_l: Bool
-same_name_c: Complex128
+same_name_c: Complex64
same_name_s: String
@@ -16,7 +16,7 @@ def do_work_i(
) -> None: ...
def do_work_r(
- same_name: Ptr(Const(Float64))
+ same_name: Ptr(Const(Float32))
) -> None: ...
def do_work_l(
@@ -28,15 +28,15 @@ def host_one(
) -> None: ...
def host_two(
- same_name: Ptr(Float64)
+ same_name: Ptr(Float32)
) -> None: ...
def convert_to_complex(
same_name: Ptr(Const(Int32))
-) -> Complex128: ...
+) -> Complex64: ...
def convert_to_char(
- same_name: Ptr(Const(Float64))
+ same_name: Ptr(Const(Float32))
) -> String: ...
def convert_to_logical(
diff --git a/tests/semantics/fixtures/general/compile_time_shape_exprs.json b/tests/semantics/fixtures/general/compile_time_shape_exprs.json
index cb5e6efde..d7fd6a612 100644
--- a/tests/semantics/fixtures/general/compile_time_shape_exprs.json
+++ b/tests/semantics/fixtures/general/compile_time_shape_exprs.json
@@ -119,9 +119,9 @@
{
"name": "y",
"semantic_type": {
- "name": "Float64",
+ "name": "Float32",
"rank": 1,
- "dtype": "Float64",
+ "dtype": "Float32",
"shape": [
"n0 * 2"
],
diff --git a/tests/semantics/fixtures/general/scope_name_reuse_combinations.json b/tests/semantics/fixtures/general/scope_name_reuse_combinations.json
index 17bc937b9..23da91f1b 100644
--- a/tests/semantics/fixtures/general/scope_name_reuse_combinations.json
+++ b/tests/semantics/fixtures/general/scope_name_reuse_combinations.json
@@ -113,9 +113,9 @@
{
"name": "same_name",
"semantic_type": {
- "name": "Float64",
+ "name": "Float32",
"rank": 0,
- "dtype": "Float64",
+ "dtype": "Float32",
"shape": [],
"constraints": [],
"coercions": [],
@@ -422,9 +422,9 @@
{
"name": "same_name",
"semantic_type": {
- "name": "Float64",
+ "name": "Float32",
"rank": 0,
- "dtype": "Float64",
+ "dtype": "Float32",
"shape": [],
"constraints": [],
"coercions": [],
@@ -596,9 +596,9 @@
}
],
"return_type": {
- "name": "Complex128",
+ "name": "Complex64",
"rank": 0,
- "dtype": "Complex128",
+ "dtype": "Complex64",
"shape": [],
"constraints": [],
"coercions": [],
@@ -662,9 +662,9 @@
{
"name": "same_name",
"semantic_type": {
- "name": "Float64",
+ "name": "Float32",
"rank": 0,
- "dtype": "Float64",
+ "dtype": "Float32",
"shape": [],
"constraints": [],
"coercions": [],
@@ -1082,9 +1082,9 @@
{
"name": "same_name_r",
"semantic_type": {
- "name": "Float64",
+ "name": "Float32",
"rank": 0,
- "dtype": "Float64",
+ "dtype": "Float32",
"shape": [],
"constraints": [],
"coercions": [],
@@ -1208,9 +1208,9 @@
{
"name": "same_name_c",
"semantic_type": {
- "name": "Complex128",
+ "name": "Complex64",
"rank": 0,
- "dtype": "Complex128",
+ "dtype": "Complex64",
"shape": [],
"constraints": [],
"coercions": [],
diff --git a/tests/semantics/fixtures/wrap_readiness_messages.json b/tests/semantics/fixtures/wrap_readiness_messages.json
index f26be8984..d4aa1e21e 100644
--- a/tests/semantics/fixtures/wrap_readiness_messages.json
+++ b/tests/semantics/fixtures/wrap_readiness_messages.json
@@ -387,22 +387,14 @@
"blockers": []
},
"blas/dcabs1.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"blas/dcopy.f": {
"wrappable": true,
@@ -735,22 +727,14 @@
"blockers": []
},
"blas/dzasum.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"blas/dznrm2.f90": {
"wrappable": true,
@@ -793,22 +777,14 @@
"blockers": []
},
"blas/izamax.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"blas/lsame.f": {
"wrappable": true,
@@ -1221,400 +1197,224 @@
"blockers": []
},
"blas/zaxpy.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"blas/zcopy.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"blas/zdotc.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"blas/zdotu.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"blas/zdrot.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"blas/zdscal.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"blas/zgbmv.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 5
- }
- ]
+ "messages": [],
+ "blockers": []
},
"blas/zgemm.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 5
- }
- ]
+ "messages": [],
+ "blockers": []
},
"blas/zgemmtr.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 5
- }
- ]
+ "messages": [],
+ "blockers": []
},
"blas/zgemv.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 5
- }
- ]
+ "messages": [],
+ "blockers": []
},
"blas/zgerc.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"blas/zgeru.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"blas/zhbmv.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 5
- }
- ]
+ "messages": [],
+ "blockers": []
},
"blas/zhemm.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 5
- }
- ]
+ "messages": [],
+ "blockers": []
},
"blas/zhemv.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 5
- }
- ]
+ "messages": [],
+ "blockers": []
},
"blas/zher.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"blas/zher2.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"blas/zher2k.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"blas/zherk.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"blas/zhpmv.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 5
- }
- ]
+ "messages": [],
+ "blockers": []
},
"blas/zhpr.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"blas/zhpr2.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"blas/zrotg.f90": {
"wrappable": true,
@@ -1627,238 +1427,134 @@
"blockers": []
},
"blas/zscal.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"blas/zswap.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"blas/zsymm.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 5
- }
- ]
+ "messages": [],
+ "blockers": []
},
"blas/zsyr2k.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 5
- }
- ]
+ "messages": [],
+ "blockers": []
},
"blas/zsyrk.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"blas/ztbmv.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"blas/ztbsv.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"blas/ztpmv.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"blas/ztpsv.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"blas/ztrmm.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"blas/ztrmv.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"blas/ztrsm.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"blas/ztrsv.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"general/assumed_shape_and_derived_args.f90": {
"wrappable": false,
@@ -3496,16 +3192,6 @@
"messages": [],
"blockers": []
},
- "lapack/chetrd_hb2st.F": {
- "wrappable": true,
- "status": "ok",
- "n_modules": 1,
- "n_functions": 1,
- "n_classes": 0,
- "n_variables": 0,
- "messages": [],
- "blockers": []
- },
"lapack/chetrd_he2hb.f": {
"wrappable": true,
"status": "ok",
@@ -4297,22 +3983,14 @@
"blockers": []
},
"lapack/clag2z.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/clags2.f": {
"wrappable": true,
@@ -11600,16 +11278,6 @@
"messages": [],
"blockers": []
},
- "lapack/dsytrd_sb2st.F": {
- "wrappable": true,
- "status": "ok",
- "n_modules": 1,
- "n_functions": 1,
- "n_classes": 0,
- "n_variables": 0,
- "messages": [],
- "blockers": []
- },
"lapack/dsytrd_sy2sb.f": {
"wrappable": true,
"status": "ok",
@@ -12221,22 +11889,14 @@
"blockers": []
},
"lapack/dzsum1.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/icmax1.f": {
"wrappable": true,
@@ -12379,42 +12039,16 @@
"blockers": []
},
"lapack/ilazlc.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/ilazlr.f": {
- "wrappable": false,
- "status": "ok",
- "n_modules": 1,
- "n_functions": 1,
- "n_classes": 0,
- "n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
- },
- "lapack/iparam2stage.F": {
"wrappable": true,
"status": "ok",
"n_modules": 1,
@@ -12435,22 +12069,14 @@
"blockers": []
},
"lapack/izmax1.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/la_constants.f90": {
"wrappable": true,
@@ -12462,20 +12088,6 @@
"messages": [],
"blockers": []
},
- "lapack/la_xisnan.F90": {
- "wrappable": false,
- "status": "semantic_error",
- "messages": [
- "Unsupported Fortran semantic type for variable 'x': real(kind=wp)"
- ],
- "blockers": [
- {
- "code": "semantic_conversion_error",
- "message": "Unsupported Fortran semantic type for variable 'x': real(kind=wp)",
- "n_items": 0
- }
- ]
- },
"lapack/lsamen.f": {
"wrappable": true,
"status": "ok",
@@ -16944,16 +16556,6 @@
"messages": [],
"blockers": []
},
- "lapack/ssytrd_sb2st.F": {
- "wrappable": true,
- "status": "ok",
- "n_modules": 1,
- "n_functions": 1,
- "n_classes": 0,
- "n_variables": 0,
- "messages": [],
- "blockers": []
- },
"lapack/ssytrd_sy2sb.f": {
"wrappable": true,
"status": "ok",
@@ -17585,400 +17187,224 @@
"blockers": []
},
"lapack/zbbcsd.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zbdsqr.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zcgesv.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zcposv.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zdrscl.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zgbbrd.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 5
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zgbcon.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zgbequ.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zgbequb.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zgbrfs.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 5
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zgbrfsx.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 5
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zgbsv.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zgbsvx.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 5
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zgbsvxx.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 5
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zgbtf2.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zgbtrf.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zgbtrs.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zgebak.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zgebal.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zgebd2.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zgebrd.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zgecon.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zgedmd.f90": {
"wrappable": true,
@@ -18001,5008 +17427,2774 @@
"blockers": []
},
"lapack/zgeequ.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zgeequb.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zgees.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zgeesx.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zgeev.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 5
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zgeevx.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 5
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zgehd2.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zgehrd.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zgejsv.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zgelq.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zgelq2.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zgelqf.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zgelqt.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zgelqt3.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zgels.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zgelsd.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zgelss.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zgelst.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zgelsy.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zgemlq.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zgemlqt.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zgemqr.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zgemqrt.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zgeql2.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zgeqlf.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zgeqp3.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zgeqp3rk.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zgeqr.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zgeqr2.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zgeqr2p.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zgeqrf.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zgeqrfp.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zgeqrt.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zgeqrt2.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zgeqrt3.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zgerfs.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 5
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zgerfsx.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 5
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zgerq2.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zgerqf.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zgesc2.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zgesdd.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zgesv.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zgesvd.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zgesvdq.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zgesvdx.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zgesvj.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zgesvx.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 5
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zgesvxx.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 5
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zgetc2.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zgetf2.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zgetrf.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zgetrf2.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zgetri.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zgetrs.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zgetsls.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zgetsqrhrt.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zggbak.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zggbal.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zgges.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 7
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zgges3.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 7
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zggesx.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 7
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zggev.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 7
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zggev3.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 7
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zggevx.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 7
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zggglm.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 6
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zgghd3.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 5
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zgghrd.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zgglse.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 6
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zggqrf.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 5
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zggrqf.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 5
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zggsvd3.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 6
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zggsvp3.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 7
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zgsvj0.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zgsvj1.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zgtcon.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 5
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zgtrfs.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 10
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zgtsv.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zgtsvx.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 10
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zgttrf.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zgttrs.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 5
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zgtts2.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 5
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zhb2st_kernels.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zhbev.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zhbev_2stage.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zhbevd.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zhbevd_2stage.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zhbevx.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zhbevx_2stage.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zhbgst.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zhbgv.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zhbgvd.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zhbgvx.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 5
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zhbtrd.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zhecon.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zhecon_3.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zhecon_rook.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zheequb.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zheev.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zheev_2stage.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zheevd.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zheevd_2stage.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zheevr.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zheevr_2stage.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zheevx.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zheevx_2stage.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zhegs2.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zhegst.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zhegv.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zhegv_2stage.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zhegvd.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zhegvx.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zherfs.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 5
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zherfsx.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 5
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zhesv.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zhesv_aa.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zhesv_aa_2stage.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zhesv_rk.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zhesv_rook.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zhesvx.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 5
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zhesvxx.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 5
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zheswapr.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zhetd2.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zhetf2.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zhetf2_rk.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zhetf2_rook.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zhetrd.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zhetrd_2stage.f": {
- "wrappable": false,
- "status": "ok",
- "n_modules": 1,
- "n_functions": 1,
- "n_classes": 0,
- "n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
- },
- "lapack/zhetrd_hb2st.F": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zhetrd_he2hb.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zhetrf.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zhetrf_aa.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zhetrf_aa_2stage.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zhetrf_rk.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zhetrf_rook.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zhetri.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zhetri2.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zhetri2x.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zhetri_3.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zhetri_3x.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zhetri_rook.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
- "n_modules": 1,
- "n_functions": 1,
- "n_classes": 0,
- "n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "n_modules": 1,
+ "n_functions": 1,
+ "n_classes": 0,
+ "n_variables": 0,
+ "messages": [],
+ "blockers": []
},
"lapack/zhetrs.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zhetrs2.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zhetrs_3.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zhetrs_aa.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zhetrs_aa_2stage.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zhetrs_rook.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zhfrk.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zhgeqz.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 7
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zhpcon.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zhpev.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zhpevd.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zhpevx.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zhpgst.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zhpgv.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zhpgvd.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zhpgvx.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zhprfs.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 5
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zhpsv.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
- "n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "n_variables": 0,
+ "messages": [],
+ "blockers": []
},
"lapack/zhpsvx.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 5
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zhptrd.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zhptrf.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zhptri.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zhptrs.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zhsein.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 5
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zhseqr.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zla_gbamv.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zla_gbrcond_c.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zla_gbrcond_x.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zla_gbrfsx_extended.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 7
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zla_gbrpvgrw.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zla_geamv.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zla_gercond_c.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zla_gercond_x.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zla_gerfsx_extended.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 7
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zla_gerpvgrw.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
- "lapack/zla_heamv.f": {
- "wrappable": false,
- "status": "ok",
- "n_modules": 1,
- "n_functions": 1,
- "n_classes": 0,
- "n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "lapack/zla_heamv.f": {
+ "wrappable": true,
+ "status": "ok",
+ "n_modules": 1,
+ "n_functions": 1,
+ "n_classes": 0,
+ "n_variables": 0,
+ "messages": [],
+ "blockers": []
},
"lapack/zla_hercond_c.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zla_hercond_x.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zla_herfsx_extended.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 7
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zla_herpvgrw.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zla_lin_berr.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zla_porcond_c.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zla_porcond_x.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zla_porfsx_extended.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 7
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zla_porpvgrw.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zla_syamv.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zla_syrcond_c.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zla_syrcond_x.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zla_syrfsx_extended.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 7
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zla_syrpvgrw.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zla_wwaddw.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlabrd.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 5
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlacgv.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlacn2.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlacon.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlacp2.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlacpy.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlacrm.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlacrt.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zladiv.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlaed0.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlaed7.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlaed8.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlaein.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlaesy.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 8
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlaev2.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlag2c.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlags2.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 5
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlagtm.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 5
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlahef.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlahef_aa.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlahef_rk.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
- "n_modules": 1,
- "n_functions": 1,
- "n_classes": 0,
- "n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "n_modules": 1,
+ "n_functions": 1,
+ "n_classes": 0,
+ "n_variables": 0,
+ "messages": [],
+ "blockers": []
},
"lapack/zlahef_rook.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlahqr.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlahr2.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlaic1.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 5
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlals0.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlalsa.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlalsd.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlamswlq.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlamtsqr.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlangb.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlange.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlangt.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlanhb.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlanhe.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlanhf.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlanhp.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlanhs.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlanht.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlansb.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlansp.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlansy.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlantb.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlantp.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlantr.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlapll.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlapmr.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlapmt.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlaqgb.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlaqge.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlaqhb.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlaqhe.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlaqhp.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlaqp2.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlaqp2rk.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlaqp3rk.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlaqps.f": {
- "wrappable": false,
- "status": "ok",
- "n_modules": 1,
- "n_functions": 1,
- "n_classes": 0,
- "n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "wrappable": true,
+ "status": "ok",
+ "n_modules": 1,
+ "n_functions": 1,
+ "n_classes": 0,
+ "n_variables": 0,
+ "messages": [],
+ "blockers": []
},
"lapack/zlaqr0.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlaqr1.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlaqr2.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 7
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlaqr3.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 7
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlaqr4.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlaqr5.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 7
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlaqsb.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlaqsp.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlaqsy.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlaqz0.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 7
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlaqz1.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlaqz2.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 9
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlaqz3.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 9
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlar1v.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlar2v.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlarcm.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlarf.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlarf1f.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
- "n_modules": 1,
- "n_functions": 1,
- "n_classes": 0,
- "n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "n_modules": 1,
+ "n_functions": 1,
+ "n_classes": 0,
+ "n_variables": 0,
+ "messages": [],
+ "blockers": []
},
"lapack/zlarf1l.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlarfb.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlarfb_gett.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlarfg.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlarfgp.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlarft.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlarfx.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlarfy.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlargv.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlarnv.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlarrv.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlarscl2.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlartg.f90": {
"wrappable": false,
@@ -23019,148 +20211,84 @@
]
},
"lapack/zlartv.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlarz.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlarzb.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlarzt.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlascl.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlascl2.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlaset.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlasr.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlassq.f90": {
"wrappable": false,
@@ -23177,3586 +20305,1994 @@
]
},
"lapack/zlaswlq.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlaswp.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlasyf.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlasyf_aa.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlasyf_rk.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlasyf_rook.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlat2c.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlatbs.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlatdf.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlatps.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlatrd.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlatrs.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlatrs3.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlatrz.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlatsqr.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlaunhr_col_getrfnp.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
- "n_modules": 1,
- "n_functions": 1,
- "n_classes": 0,
- "n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "n_modules": 1,
+ "n_functions": 1,
+ "n_classes": 0,
+ "n_variables": 0,
+ "messages": [],
+ "blockers": []
},
"lapack/zlaunhr_col_getrfnp2.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlauu2.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zlauum.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zpbcon.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zpbequ.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zpbrfs.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 5
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zpbstf.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zpbsv.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zpbsvx.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 5
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zpbtf2.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zpbtrf.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zpbtrs.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zpftrf.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zpftri.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zpftrs.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zpocon.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zpoequ.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zpoequb.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zporfs.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 5
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zporfsx.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 5
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zposv.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zposvx.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 5
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zposvxx.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 5
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zpotf2.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zpotrf.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zpotrf2.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zpotri.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zpotrs.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zppcon.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zppequ.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zpprfs.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 5
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zppsv.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zppsvx.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 5
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zpptrf.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zpptri.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zpptrs.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
- "n_modules": 1,
- "n_functions": 1,
- "n_classes": 0,
- "n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "n_modules": 1,
+ "n_functions": 1,
+ "n_classes": 0,
+ "n_variables": 0,
+ "messages": [],
+ "blockers": []
},
"lapack/zpstf2.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zpstrf.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zptcon.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zpteqr.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zptrfs.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 5
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zptsv.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zptsvx.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 5
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zpttrf.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zpttrs.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zptts2.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zrot.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zrscl.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zspcon.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zspmv.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 5
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zspr.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zsprfs.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 5
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zspsv.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zspsvx.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 5
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zsptrf.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zsptri.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zsptrs.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zstedc.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zstegr.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zstein.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zstemr.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zsteqr.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zsycon.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zsycon_3.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zsycon_rook.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zsyconv.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zsyconvf.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zsyconvf_rook.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zsyequb.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zsymv.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 5
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zsyr.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zsyrfs.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
- "n_modules": 1,
- "n_functions": 1,
- "n_classes": 0,
- "n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 5
- }
- ]
+ "n_modules": 1,
+ "n_functions": 1,
+ "n_classes": 0,
+ "n_variables": 0,
+ "messages": [],
+ "blockers": []
},
"lapack/zsyrfsx.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 5
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zsysv.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zsysv_aa.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zsysv_aa_2stage.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zsysv_rk.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zsysv_rook.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zsysvx.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 5
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zsysvxx.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 5
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zsyswapr.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zsytf2.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zsytf2_rk.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zsytf2_rook.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zsytrf.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zsytrf_aa.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zsytrf_aa_2stage.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zsytrf_rk.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zsytrf_rook.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zsytri.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zsytri2.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zsytri2x.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zsytri_3.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zsytri_3x.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zsytri_rook.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zsytrs.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zsytrs2.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zsytrs_3.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zsytrs_aa.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zsytrs_aa_2stage.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zsytrs_rook.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/ztbcon.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/ztbrfs.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/ztbtrs.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/ztfsm.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/ztftri.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/ztfttp.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/ztfttr.f": {
- "wrappable": false,
- "status": "ok",
- "n_modules": 1,
- "n_functions": 1,
- "n_classes": 0,
- "n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "wrappable": true,
+ "status": "ok",
+ "n_modules": 1,
+ "n_functions": 1,
+ "n_classes": 0,
+ "n_variables": 0,
+ "messages": [],
+ "blockers": []
},
"lapack/ztgevc.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 5
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/ztgex2.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/ztgexc.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/ztgsen.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 7
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/ztgsja.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 6
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/ztgsna.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 5
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/ztgsy2.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 6
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/ztgsyl.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 7
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/ztpcon.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/ztplqt.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/ztplqt2.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/ztpmlqt.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 5
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/ztpmqrt.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 5
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/ztpqrt.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/ztpqrt2.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/ztprfb.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 5
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/ztprfs.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/ztptri.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/ztptrs.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/ztpttf.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/ztpttr.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/ztrcon.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/ztrevc.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/ztrevc3.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/ztrexc.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/ztrrfs.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/ztrsen.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/ztrsna.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/ztrsyl.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/ztrsyl3.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/ztrti2.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/ztrtri.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 1
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/ztrtrs.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/ztrttf.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/ztrttp.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 2
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/ztzrzf.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
- "n_modules": 1,
- "n_functions": 1,
- "n_classes": 0,
- "n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "n_modules": 1,
+ "n_functions": 1,
+ "n_classes": 0,
+ "n_variables": 0,
+ "messages": [],
+ "blockers": []
},
"lapack/zunbdb.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 9
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zunbdb1.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 6
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zunbdb2.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 6
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zunbdb3.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 6
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zunbdb4.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 7
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zunbdb5.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 5
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zunbdb6.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 5
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zuncsd.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 9
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zuncsd2by1.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 6
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zung2l.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zung2r.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zungbr.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zunghr.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zungl2.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zunglq.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zungql.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zungqr.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zungr2.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
- "n_functions": 1,
- "n_classes": 0,
- "n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "n_functions": 1,
+ "n_classes": 0,
+ "n_variables": 0,
+ "messages": [],
+ "blockers": []
},
"lapack/zungrq.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zungtr.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zungtsqr.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zungtsqr_row.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zunhr_col.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zunm22.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 3
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zunm2l.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zunm2r.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zunmbr.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zunmhr.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zunml2.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zunmlq.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zunmql.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zunmqr.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zunmr2.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zunmr3.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zunmrq.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zunmrz.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
- "n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "n_variables": 0,
+ "messages": [],
+ "blockers": []
},
"lapack/zunmtr.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zupgtr.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"lapack/zupmtr.f": {
- "wrappable": false,
+ "wrappable": true,
"status": "ok",
"n_modules": 1,
"n_functions": 1,
"n_classes": 0,
"n_variables": 0,
- "messages": [
- "Some semantic type references are not declared by the .pyi interface or its imports."
- ],
- "blockers": [
- {
- "code": "unresolved_semantic_types",
- "message": "Some semantic type references are not declared by the .pyi interface or its imports.",
- "n_items": 4
- }
- ]
+ "messages": [],
+ "blockers": []
},
"scifortran/01_sf_fft_fftpack.f90": {
"wrappable": false,
@@ -27264,16 +22800,6 @@
}
]
},
- "scifortran/SF_BLACS.f90": {
- "wrappable": true,
- "status": "ok",
- "n_modules": 1,
- "n_functions": 10,
- "n_classes": 0,
- "n_variables": 6,
- "messages": [],
- "blockers": []
- },
"scifortran/SF_COLORS.f90": {
"wrappable": false,
"status": "ok",
@@ -27394,44 +22920,6 @@
}
]
},
- "scifortran/SF_LINALG.f90": {
- "wrappable": true,
- "status": "ok",
- "n_modules": 1,
- "n_functions": 2,
- "n_classes": 0,
- "n_variables": 0,
- "messages": [],
- "blockers": []
- },
- "scifortran/SF_MISC.f90": {
- "wrappable": false,
- "status": "ok",
- "n_modules": 1,
- "n_functions": 0,
- "n_classes": 0,
- "n_variables": 0,
- "messages": [
- "The semantic interface does not declare any public wrapper API."
- ],
- "blockers": [
- {
- "code": "no_public_api",
- "message": "The semantic interface does not declare any public wrapper API.",
- "n_items": 1
- }
- ]
- },
- "scifortran/SF_MPI.f90": {
- "wrappable": true,
- "status": "ok",
- "n_modules": 1,
- "n_functions": 19,
- "n_classes": 0,
- "n_variables": 0,
- "messages": [],
- "blockers": []
- },
"scifortran/SF_OPTIMIZE.f90": {
"wrappable": false,
"status": "ok",
@@ -27506,44 +22994,6 @@
}
]
},
- "scifortran/SF_SPARSE_ARRAY_COO.f90": {
- "wrappable": false,
- "status": "ok",
- "n_modules": 1,
- "n_functions": 8,
- "n_classes": 2,
- "n_variables": 0,
- "messages": [
- "Some shape expressions refer to symbols not supplied by the semantic interface."
- ],
- "blockers": [
- {
- "code": "unresolved_shape_symbols",
- "message": "Some shape expressions refer to symbols not supplied by the semantic interface.",
- "n_items": 8
- }
- ]
- },
- "scifortran/SF_SPARSE_ARRAY_CSC.f90": {
- "wrappable": true,
- "status": "ok",
- "n_modules": 1,
- "n_functions": 0,
- "n_classes": 2,
- "n_variables": 0,
- "messages": [],
- "blockers": []
- },
- "scifortran/SF_SPARSE_ARRAY_CSR.f90": {
- "wrappable": true,
- "status": "ok",
- "n_modules": 1,
- "n_functions": 0,
- "n_classes": 2,
- "n_variables": 0,
- "messages": [],
- "blockers": []
- },
"scifortran/SF_SPARSE_COMMON.f90": {
"wrappable": false,
"status": "ok",
@@ -27590,24 +23040,6 @@
}
]
},
- "scifortran/SF_SP_LINALG.f90": {
- "wrappable": false,
- "status": "ok",
- "n_modules": 1,
- "n_functions": 0,
- "n_classes": 0,
- "n_variables": 0,
- "messages": [
- "The semantic interface does not declare any public wrapper API."
- ],
- "blockers": [
- {
- "code": "no_public_api",
- "message": "The semantic interface does not declare any public wrapper API.",
- "n_items": 1
- }
- ]
- },
"scifortran/SF_STAT.f90": {
"wrappable": false,
"status": "ok",
@@ -27626,16 +23058,6 @@
}
]
},
- "scifortran/SF_TIMER.f90": {
- "wrappable": true,
- "status": "ok",
- "n_modules": 1,
- "n_functions": 6,
- "n_classes": 0,
- "n_variables": 0,
- "messages": [],
- "blockers": []
- },
"scifortran/adaptive_mix.f90": {
"wrappable": false,
"status": "ok",
@@ -28714,126 +24136,6 @@
}
]
},
- "scifortran/icbacn.F90": {
- "wrappable": true,
- "status": "ok",
- "n_modules": 1,
- "n_functions": 2,
- "n_classes": 0,
- "n_variables": 0,
- "messages": [],
- "blockers": []
- },
- "scifortran/icbadn.F90": {
- "wrappable": true,
- "status": "ok",
- "n_modules": 1,
- "n_functions": 2,
- "n_classes": 0,
- "n_variables": 0,
- "messages": [],
- "blockers": []
- },
- "scifortran/icbads.F90": {
- "wrappable": true,
- "status": "ok",
- "n_modules": 1,
- "n_functions": 2,
- "n_classes": 0,
- "n_variables": 0,
- "messages": [],
- "blockers": []
- },
- "scifortran/icbasn.F90": {
- "wrappable": true,
- "status": "ok",
- "n_modules": 1,
- "n_functions": 2,
- "n_classes": 0,
- "n_variables": 0,
- "messages": [],
- "blockers": []
- },
- "scifortran/icbass.F90": {
- "wrappable": true,
- "status": "ok",
- "n_modules": 1,
- "n_functions": 2,
- "n_classes": 0,
- "n_variables": 0,
- "messages": [],
- "blockers": []
- },
- "scifortran/icbazn.F90": {
- "wrappable": true,
- "status": "ok",
- "n_modules": 1,
- "n_functions": 2,
- "n_classes": 0,
- "n_variables": 0,
- "messages": [],
- "blockers": []
- },
- "scifortran/icbpcn.F90": {
- "wrappable": true,
- "status": "ok",
- "n_modules": 1,
- "n_functions": 2,
- "n_classes": 0,
- "n_variables": 0,
- "messages": [],
- "blockers": []
- },
- "scifortran/icbpdn.F90": {
- "wrappable": true,
- "status": "ok",
- "n_modules": 1,
- "n_functions": 2,
- "n_classes": 0,
- "n_variables": 0,
- "messages": [],
- "blockers": []
- },
- "scifortran/icbpds.F90": {
- "wrappable": true,
- "status": "ok",
- "n_modules": 1,
- "n_functions": 2,
- "n_classes": 0,
- "n_variables": 0,
- "messages": [],
- "blockers": []
- },
- "scifortran/icbpsn.F90": {
- "wrappable": true,
- "status": "ok",
- "n_modules": 1,
- "n_functions": 2,
- "n_classes": 0,
- "n_variables": 0,
- "messages": [],
- "blockers": []
- },
- "scifortran/icbpss.F90": {
- "wrappable": true,
- "status": "ok",
- "n_modules": 1,
- "n_functions": 2,
- "n_classes": 0,
- "n_variables": 0,
- "messages": [],
- "blockers": []
- },
- "scifortran/icbpzn.F90": {
- "wrappable": true,
- "status": "ok",
- "n_modules": 1,
- "n_functions": 2,
- "n_classes": 0,
- "n_variables": 0,
- "messages": [],
- "blockers": []
- },
"scifortran/integrate_func_1d.f90": {
"wrappable": false,
"status": "ok",
diff --git a/tests/semantics/test_c2ir.py b/tests/semantics/test_c2ir.py
index 24ad61ad9..50fbc859c 100644
--- a/tests/semantics/test_c2ir.py
+++ b/tests/semantics/test_c2ir.py
@@ -867,6 +867,39 @@ def test_c2ir_preserves_c_int_identity_and_stores_compiler_probed_precision():
}
+@pytest.mark.parametrize(
+ ("ctype", "primitive", "fact", "expected"),
+ [
+ (CChar(), "char", {"kind": "integer", "signed": False, "bits": 8}, "UInt8"),
+ (CLong(), "long", {"kind": "integer", "signed": True, "bits": 32}, "Int32"),
+ (CUnsignedLong(), "unsigned long", {"kind": "integer", "signed": False, "bits": 32}, "UInt32"),
+ (CLongDouble(), "long double", {"kind": "real", "bits": 64}, "Float64"),
+ (CLongDoubleComplex(), "long double _Complex", {"kind": "complex", "bits": 128}, "Complex128"),
+ (CBool(), "_Bool", {"kind": "bool", "bits": 8}, "Bool"),
+ ],
+)
+def test_c2ir_uses_compiler_probed_primitive_abi_facts(ctype, primitive, fact, expected):
+ semantic_type = CToIRConverter(standard_type_report={"types": {primitive: fact}}).visit_type(ctype)
+
+ assert semantic_type.name == expected
+ assert semantic_type.dtype == expected
+ assert semantic_type.metadata["c_primitive"] == primitive
+ assert semantic_type.metadata["c_type_fact"] == fact
+ assert semantic_type.metadata["c_type_fact_source"] == "compiler_probe"
+ if primitive == "char":
+ assert semantic_type.metadata["c_char_policy"] == "compiler-probed unsigned 8-bit code unit"
+
+
+def test_c2ir_blocks_compiler_probed_primitive_abi_without_semantic_dtype():
+ fact = {"kind": "integer", "signed": True, "bits": 48}
+ semantic_type = CToIRConverter(standard_type_report={"types": {"long": fact}}).visit_type(CLong())
+
+ assert semantic_type.name == "CUnsupported"
+ assert semantic_type.metadata["c_primitive"] == "long"
+ assert semantic_type.metadata["c_type_fact"] == fact
+ assert semantic_type.metadata["readiness_blockers"][0]["code"] == "c_unsupported_primitive_abi"
+
+
def test_c2ir_uses_enum_specific_underlying_type_facts_when_supplied():
parsed = parse_c_file(
"enum status { STATUS_OK = 0, STATUS_ERROR = 255 }; enum status get_status(void);",
diff --git a/tests/semantics/test_fortran2ir.py b/tests/semantics/test_fortran2ir.py
index acb176da2..3b215dc47 100644
--- a/tests/semantics/test_fortran2ir.py
+++ b/tests/semantics/test_fortran2ir.py
@@ -25,7 +25,9 @@
_iter_fortran_variable_contexts,
_requirement_unit_name,
_resolve_compile_time_text,
+ collect_fortran_type_storage_requirements,
collect_semantic_compile_time_requirements,
+ fortran_type_storage_expression,
fortran_file_to_semantic_modules,
fortran_module_to_semantic_module,
fortran_project_to_semantic_modules,
@@ -891,7 +893,7 @@ def test_intrinsic_builtin_kinds_map_to_semantic_types():
("integer", "c_int16_t", "Int16"),
("integer", "c_int32_t", "Int32"),
("integer", "c_int64_t", "Int64"),
- ("real", None, "Float64"),
+ ("real", None, "Float32"),
("real", "4", "Float32"),
("real", "8", "Float64"),
("real", "16", "Float128"),
@@ -903,7 +905,7 @@ def test_intrinsic_builtin_kinds_map_to_semantic_types():
("real", "kind(1.0e0)", "Float32"),
("real", "kind(1.0d0)", "Float64"),
("real", "kind(1.0q0)", "Float128"),
- ("complex", None, "Complex128"),
+ ("complex", None, "Complex64"),
("complex", "4", "Complex64"),
("complex", "8", "Complex128"),
("complex", "16", "Complex256"),
@@ -930,6 +932,87 @@ def test_intrinsic_builtin_kinds_map_to_semantic_types():
assert converter.visit_variable(variable).name == expected
+def test_fortran2ir_uses_compiler_probed_storage_facts_and_preserves_provenance():
+ fact = {
+ "base_type": "real",
+ "kind": None,
+ "bits": 64,
+ "expression": "storage_size(real(0.0))",
+ }
+ semantic_type = FortranToIRConverter(type_facts={("real", None): fact}).visit_variable(
+ FortranVariable(name="value", base_type="real")
+ )
+
+ assert semantic_type.name == "Float64"
+ assert semantic_type.dtype == "Float64"
+ assert semantic_type.metadata["fortran_type_fact"] == fact
+ assert semantic_type.metadata["fortran_type_fact_source"] == "compiler_probe"
+
+
+def test_fortran2ir_rejects_compiler_storage_without_semantic_dtype():
+ fact = {
+ "base_type": "integer",
+ "kind": None,
+ "bits": 48,
+ "expression": "storage_size(int(0))",
+ }
+
+ with pytest.raises(ValueError, match="integer uses 48-bit storage"):
+ FortranToIRConverter(type_facts={("integer", None): fact}).visit_variable(
+ FortranVariable(name="value", base_type="integer")
+ )
+
+
+def test_fortran_storage_requirements_follow_resolved_kinds_and_actual_source_types():
+ parsed = FortranFile(
+ variables=[
+ FortranVariable(name="default_real", base_type="real"),
+ FortranVariable(name="selected", base_type="real", kind="rk"),
+ FortranVariable(name="flag", base_type="logical", kind="8"),
+ FortranVariable(name="text", base_type="character", kind="len=12, kind=c_char"),
+ ]
+ )
+
+ assert fortran_type_storage_expression("complex", "8") == "storage_size(cmplx(0.0,kind=8))"
+ requirements = collect_fortran_type_storage_requirements(parsed, compile_time_values={"rk": 8})
+ assert {(item["base_type"], item["kind"], item["expression"]) for item in requirements} == {
+ ("real", None, "storage_size(real(0.0))"),
+ ("real", "8", "storage_size(real(0.0,kind=8))"),
+ ("logical", "8", "storage_size(logical(.false.,kind=8))"),
+ ("character", "c_char", "storage_size(char(65,kind=c_char))"),
+ }
+
+
+def test_legacy_fortran_storage_uses_fixed_star_widths_and_probes_double_types():
+ parsed = parse_fortran_source(
+ """
+subroutine legacy(c8, c16, dp, dc, label, explicit_kind)
+ complex*8 c8
+ complex*16 c16
+ double precision dp
+ double complex dc
+ character*8 label
+ character(kind=1) explicit_kind
+end subroutine legacy
+""",
+ filename="legacy_types.f90",
+ )
+ args = {arg.name: arg for arg in parsed.procedures[0].arguments}
+ converter = FortranToIRConverter()
+
+ assert converter.visit_variable(args["c8"]).name == "Complex64"
+ assert converter.visit_variable(args["c16"]).name == "Complex128"
+ assert converter.visit_variable(args["c16"]).metadata["fortran_type_fact_source"] == "legacy_star_storage"
+
+ requirements = collect_fortran_type_storage_requirements(parsed)
+ assert {(item["base_type"], item["kind"], item["expression"]) for item in requirements} == {
+ ("real", "kind(1.0d0)", "storage_size(real(0.0,kind=kind(1.0d0)))"),
+ ("complex", "kind(1.0d0)", "storage_size(cmplx(0.0,kind=kind(1.0d0)))"),
+ ("character", None, "storage_size(char(65))"),
+ ("character", "1", "storage_size(char(65,kind=1))"),
+ }
+
+
def test_semantic_model_helpers_cover_projection_and_canonical_edge_cases():
assert SemanticFunction("f") != SemanticMethod("f")
assert semantic_models._semantic_type_key(None, {}) is None
diff --git a/tests/tools/test_documentation_examples.py b/tests/tools/test_documentation_examples.py
index 836639cc4..151fa67ea 100644
--- a/tests/tools/test_documentation_examples.py
+++ b/tests/tools/test_documentation_examples.py
@@ -4,6 +4,7 @@
from dataclasses import dataclass
import os
+import platform
from pathlib import Path
import re
import shlex
@@ -15,8 +16,9 @@
ROOT = Path(__file__).parents[2]
DOC_PATHS = [ROOT / "README.md", *sorted((ROOT / "docs").rglob("*.md"))]
-TEST_MARKER = re.compile(r"^\s*\s*$")
+TEST_MARKER = re.compile(r"^\s*\s*$")
OUTPUT_MARKER = re.compile(r"^\s*\s*$")
+SOURCE_MARKER = re.compile(r"^\s*\s*$")
FENCE_MARKER = re.compile(r"^\s*(`{3,}|~{3,})")
SHELL_OPERATORS = {"&&", "||", ";", "|", ">", ">>", "<", "2>", "2>>"}
DISALLOWED_OPTIONS = {
@@ -36,12 +38,31 @@ class DocumentationExample:
language: str
command: str
expected_output: str | None = None
+ platform: str | None = None
@property
def test_id(self) -> str:
return f"{self.path.relative_to(ROOT)}:{self.line}"
+@dataclass(frozen=True)
+class DocumentedSource:
+ path: Path
+ line: int
+ source_path: Path
+ source_text: str
+
+ @property
+ def test_id(self) -> str:
+ return f"{self.path.relative_to(ROOT)}:{self.line}"
+
+
+def _platform_id() -> str:
+ machine = platform.machine().lower()
+ machine = {"amd64": "x86_64", "arm64": "aarch64"}.get(machine, machine)
+ return f"{platform.system().lower()}-{machine}"
+
+
def _next_nonempty_line(lines: list[str], start: int) -> int:
index = start
while index < len(lines) and not lines[index].strip():
@@ -72,12 +93,27 @@ def _logical_command(command_block: str, *, location: str) -> str:
return command
-def _examples_from_path(path: Path) -> list[DocumentationExample]:
+def _documented_content_from_path(path: Path) -> tuple[list[DocumentationExample], list[DocumentedSource]]:
lines = path.read_text(encoding="utf-8").splitlines()
examples: list[DocumentationExample] = []
+ sources: list[DocumentedSource] = []
index = 0
while index < len(lines):
+ source_marker = SOURCE_MARKER.match(lines[index])
+ if source_marker is not None:
+ marker_line = index + 1
+ source_text, index, _language = _fenced_block(lines, index + 1)
+ sources.append(
+ DocumentedSource(
+ path=path,
+ line=marker_line,
+ source_path=ROOT / source_marker.group(1),
+ source_text=source_text,
+ )
+ )
+ continue
+
marker = TEST_MARKER.match(lines[index])
if marker is None:
if OUTPUT_MARKER.match(lines[index]):
@@ -125,13 +161,16 @@ def _examples_from_path(path: Path) -> list[DocumentationExample]:
language=language,
command=command,
expected_output=expected_output,
+ platform=marker.group(2),
)
)
- return examples
+ return examples, sources
-DOCUMENTATION_EXAMPLES = [example for path in DOC_PATHS for example in _examples_from_path(path)]
+DOCUMENTATION_CONTENT = [_documented_content_from_path(path) for path in DOC_PATHS]
+DOCUMENTATION_EXAMPLES = [example for examples, _sources in DOCUMENTATION_CONTENT for example in examples]
+DOCUMENTED_SOURCES = [source for _examples, sources in DOCUMENTATION_CONTENT for source in sources]
def _command_argv(example: DocumentationExample) -> list[str]:
@@ -139,8 +178,10 @@ def _command_argv(example: DocumentationExample) -> list[str]:
return [sys.executable, "-c", example.command]
argv = shlex.split(example.command)
- if not argv or argv[0] not in {"python", "python3"} or argv[1:3] != ["-m", "x2py"]:
- raise AssertionError(f"{example.test_id}: only 'python[3] -m x2py' commands are supported")
+ allowed_modules = {("python", "-m", "x2py"), ("python", "-m", "x2py.type_mapping_report")}
+ normalized_command = ("python", *argv[1:3]) if argv and argv[0] in {"python", "python3"} else ()
+ if normalized_command not in allowed_modules:
+ raise AssertionError(f"{example.test_id}: unsupported documentation command")
if any(argument in SHELL_OPERATORS for argument in argv):
raise AssertionError(f"{example.test_id}: shell operators are not supported")
if any(
@@ -154,6 +195,13 @@ def _command_argv(example: DocumentationExample) -> list[str]:
def test_documentation_has_automatically_verified_examples():
assert DOCUMENTATION_EXAMPLES, "mark at least one Markdown example with x2py-doc-test"
assert any(example.mode == "exact" for example in DOCUMENTATION_EXAMPLES)
+ assert DOCUMENTED_SOURCES, "mark displayed fixture inputs with x2py-doc-source"
+
+
+@pytest.mark.parametrize("source", DOCUMENTED_SOURCES, ids=lambda source: source.test_id)
+def test_documented_source_input(source: DocumentedSource):
+ assert source.source_path.is_file(), f"{source.test_id}: documented source does not exist: {source.source_path}"
+ assert source.source_text.rstrip("\n") == source.source_path.read_text(encoding="utf-8").rstrip("\n")
@pytest.mark.parametrize("path", DOC_PATHS, ids=lambda path: str(path.relative_to(ROOT)))
@@ -170,6 +218,8 @@ def test_documented_expected_output_labels_are_automatically_verified(path: Path
@pytest.mark.parametrize("example", DOCUMENTATION_EXAMPLES, ids=lambda example: example.test_id)
def test_documentation_example(example: DocumentationExample):
+ if example.platform is not None and example.platform != _platform_id():
+ pytest.skip(f"example targets {example.platform}, running on {_platform_id()}")
env = os.environ.copy()
env["PYTHONPATH"] = os.pathsep.join(filter(None, [str(ROOT), env.get("PYTHONPATH")]))
result = subprocess.run(
diff --git a/tests/tools/test_type_mapping_report.py b/tests/tools/test_type_mapping_report.py
new file mode 100644
index 000000000..6d31ef2ab
--- /dev/null
+++ b/tests/tools/test_type_mapping_report.py
@@ -0,0 +1,95 @@
+"""Target-specific datatype mapping report tests."""
+
+import shutil
+
+import pytest
+
+import x2py.type_mapping_report as type_mapping_report
+
+
+@pytest.mark.parametrize(
+ ("language", "compiler", "native_header", "representative"),
+ [
+ ("c", "cc", "| C type |", "| `long double` |"),
+ (
+ "fortran",
+ "gfortran",
+ "| Fortran type |",
+ "| `real(kind(1.0d0))` | 64-bit storage | `Float64` |",
+ ),
+ ],
+)
+def test_type_mapping_markdown_covers_target_native_semantic_and_numpy_types(
+ language,
+ compiler,
+ native_header,
+ representative,
+):
+ if shutil.which(compiler) is None:
+ pytest.skip(f"{compiler} is required for the target-specific mapping report")
+
+ report = (
+ type_mapping_report.c_type_mapping_markdown(compiler=compiler)
+ if language == "c"
+ else type_mapping_report.fortran_type_mapping_markdown(compiler=compiler)
+ )
+
+ assert report.startswith(f"Target profile: `{type_mapping_report.target_profile()}`")
+ assert native_header in report
+ assert representative in report
+ assert "Semantic dtype | NumPy dtype" in report
+
+
+def test_type_mapping_report_main_selects_language(monkeypatch, capsys):
+ monkeypatch.setattr(
+ type_mapping_report,
+ "c_type_mapping_markdown",
+ lambda *, compiler, compiler_args, **options: f"C:{compiler}:{','.join(compiler_args)}:{options['refresh']}",
+ )
+ monkeypatch.setattr(
+ type_mapping_report,
+ "fortran_type_mapping_markdown",
+ lambda *, compiler, compiler_args, **options: f"F:{compiler}:{','.join(compiler_args)}:{options['refresh']}",
+ )
+
+ assert type_mapping_report.main(["--language", "c", "--compiler", "clang", "--compiler-arg=-m32", "--refresh"]) == 0
+ assert capsys.readouterr().out == "C:clang:-m32:True\n"
+
+ assert type_mapping_report.main(["--language", "fortran"]) == 0
+ assert capsys.readouterr().out == "F:gfortran::False\n"
+
+
+def test_fortran_type_mapping_uses_compiler_dependent_defaults():
+ if shutil.which("gfortran") is None:
+ pytest.skip("gfortran is required for the target-specific mapping report")
+
+ report = type_mapping_report.fortran_type_mapping_markdown(
+ compiler_args=["-fdefault-integer-8", "-fdefault-real-8"]
+ )
+
+ assert "| `integer` | 64-bit storage | `Int64` | `numpy.int64` |" in report
+ assert "| `real` | 64-bit storage | `Float64` | `numpy.float64` |" in report
+ assert "| `complex` | 128-bit storage | `Complex128` | `numpy.complex128` |" in report
+ assert "| `double precision` | 128-bit storage | `Float128` | `numpy.longdouble` |" in report
+ assert "| `double complex` | 256-bit storage | `Complex256` | `numpy.clongdouble` |" in report
+ assert "| `complex*16` | 128-bit storage | `Complex128` | `numpy.complex128` |" in report
+
+
+def test_fortran_type_mapping_includes_legacy_and_modern_spellings():
+ if shutil.which("gfortran") is None:
+ pytest.skip("gfortran is required for the target-specific mapping report")
+
+ report = type_mapping_report.fortran_type_mapping_markdown()
+
+ assert "| `complex(kind=8)` | 128-bit storage | `Complex128` | `numpy.complex128` |" in report
+ assert "| `complex*8` | 64-bit storage | `Complex64` | `numpy.complex64` |" in report
+ assert "| `double precision` | 64-bit storage | `Float64` | `numpy.float64` |" in report
+ assert "| `double complex` | 128-bit storage | `Complex128` | `numpy.complex128` |" in report
+ assert "| `character*8` | 8-bit storage | `String` | `numpy.str_ / ABI bytes` |" in report
+
+
+def test_target_profile_normalizes_common_machine_names(monkeypatch):
+ monkeypatch.setattr(type_mapping_report.platform, "system", lambda: "Linux")
+ monkeypatch.setattr(type_mapping_report.platform, "machine", lambda: "AMD64")
+
+ assert type_mapping_report.target_profile() == "linux-x86_64"
diff --git a/x2py/c_type_probe.py b/x2py/c_type_probe.py
index 1a78cb481..486741f11 100644
--- a/x2py/c_type_probe.py
+++ b/x2py/c_type_probe.py
@@ -1,21 +1,25 @@
-"""Compiler-derived ABI facts for common C standard-library types.
+"""Compiler-derived ABI facts for modeled C arithmetic primitives and standard types.
This module deliberately runs a generated C executable instead of hard-coding
-typedef spellings. Names such as ``size_t`` and ``time_t`` are target/compiler
-facts, while ``FILE`` is an opaque library handle for wrapper purposes.
+primitive widths or typedef spellings. Those are target/compiler facts, while
+``FILE`` is an opaque library handle for wrapper purposes.
"""
from __future__ import annotations
import argparse
from dataclasses import asdict, dataclass
+import hashlib
import json
import os
from pathlib import Path
import shlex
+import shutil
import subprocess
import tempfile
from collections.abc import Sequence
+from contextlib import suppress
+from typing import Any
from .preprocessing import PreprocessingConfig, PreprocessingError, validate_macro_name
@@ -67,17 +71,37 @@ def to_dict(self) -> dict[str, object]:
"unsigned long long",
}
_REAL_TYPES = {"float", "double", "long double"}
+_COMPLEX_TYPES = {"float _Complex", "double _Complex", "long double _Complex"}
+# Increment when report classification changes without changing the generated C source.
+_PROBE_CACHE_SCHEMA_VERSION = 1
+_PROBE_ENVIRONMENT_VARIABLES = (
+ "COMPILER_PATH",
+ "CPATH",
+ "C_INCLUDE_PATH",
+ "GCC_EXEC_PREFIX",
+ "INCLUDE",
+ "LIB",
+ "LIBRARY_PATH",
+ "MACOSX_DEPLOYMENT_TARGET",
+ "QEMU_LD_PREFIX",
+ "SDKROOT",
+ "SYSROOT",
+)
+_MEMORY_CACHE: dict[str, CStandardTypeProbeReport] = {}
def build_c_standard_type_probe_source() -> str:
"""Return the C11 source compiled by :func:`probe_c_standard_types`."""
- return r"""#include
+ return r"""#include
+#include
+#include
#include
#include
#include
#include
#define X2PY_BASE_TYPE(value) _Generic((value), \
+ _Bool: "_Bool", \
char: "char", \
signed char: "signed char", \
unsigned char: "unsigned char", \
@@ -92,6 +116,9 @@ def build_c_standard_type_probe_source() -> str:
float: "float", \
double: "double", \
long double: "long double", \
+ float _Complex: "float _Complex", \
+ double _Complex: "double _Complex", \
+ long double _Complex: "long double _Complex", \
default: "other")
#define X2PY_PRINT_ARITHMETIC(name, header, type) \
@@ -102,10 +129,62 @@ def build_c_standard_type_probe_source() -> str:
sizeof(type) * (size_t)CHAR_BIT, \
_Alignof(type) * (size_t)CHAR_BIT)
+#define X2PY_PRINT_CHAR() \
+ printf("\"char\":{\"header\":\"\",\"available\":true," \
+ "\"kind\":\"arithmetic\",\"underlying_c_type\":\"char\"," \
+ "\"signed\":%s,\"bits\":%zu,\"alignment_bits\":%zu}", \
+ CHAR_MIN < 0 ? "true" : "false", \
+ sizeof(char) * (size_t)CHAR_BIT, \
+ _Alignof(char) * (size_t)CHAR_BIT)
+
+#define X2PY_PRINT_REAL(name, type, precision, max_exp) \
+ printf("\"" name "\":{\"header\":\"\",\"available\":true," \
+ "\"kind\":\"arithmetic\",\"underlying_c_type\":\"%s\"," \
+ "\"bits\":%zu,\"alignment_bits\":%zu,\"precision_bits\":%d," \
+ "\"max_binary_exponent\":%d}", \
+ X2PY_BASE_TYPE((type)0), \
+ sizeof(type) * (size_t)CHAR_BIT, \
+ _Alignof(type) * (size_t)CHAR_BIT, \
+ precision, max_exp)
+
int main(void) {
printf("{\"types\":{");
+ X2PY_PRINT_ARITHMETIC("_Bool", "", _Bool);
+ printf(",");
+ X2PY_PRINT_CHAR();
+ printf(",");
+ X2PY_PRINT_ARITHMETIC("signed char", "", signed char);
+ printf(",");
+ X2PY_PRINT_ARITHMETIC("unsigned char", "", unsigned char);
+ printf(",");
+ X2PY_PRINT_ARITHMETIC("short", "", short);
+ printf(",");
+ X2PY_PRINT_ARITHMETIC("unsigned short", "", unsigned short);
+ printf(",");
X2PY_PRINT_ARITHMETIC("int", "", int);
printf(",");
+ X2PY_PRINT_ARITHMETIC("unsigned int", "", unsigned int);
+ printf(",");
+ X2PY_PRINT_ARITHMETIC("long", "", long);
+ printf(",");
+ X2PY_PRINT_ARITHMETIC("unsigned long", "", unsigned long);
+ printf(",");
+ X2PY_PRINT_ARITHMETIC("long long", "", long long);
+ printf(",");
+ X2PY_PRINT_ARITHMETIC("unsigned long long", "", unsigned long long);
+ printf(",");
+ X2PY_PRINT_REAL("float", float, FLT_MANT_DIG, FLT_MAX_EXP);
+ printf(",");
+ X2PY_PRINT_REAL("double", double, DBL_MANT_DIG, DBL_MAX_EXP);
+ printf(",");
+ X2PY_PRINT_REAL("long double", long double, LDBL_MANT_DIG, LDBL_MAX_EXP);
+ printf(",");
+ X2PY_PRINT_ARITHMETIC("float _Complex", "", float _Complex);
+ printf(",");
+ X2PY_PRINT_ARITHMETIC("double _Complex", "", double _Complex);
+ printf(",");
+ X2PY_PRINT_ARITHMETIC("long double _Complex", "", long double _Complex);
+ printf(",");
X2PY_PRINT_ARITHMETIC("size_t", "stddef.h", size_t);
printf(",");
#ifdef UINT32_MAX
@@ -153,9 +232,18 @@ def _semantic_type_facts(types: dict[str, dict[str, object]]) -> None:
elif underlying in _REAL_TYPES:
fact["kind"] = "real"
fact["semantic_category"] = "real"
+ elif underlying in _COMPLEX_TYPES:
+ fact["kind"] = "complex"
+ fact["semantic_category"] = "complex"
+ elif underlying == "_Bool":
+ fact["kind"] = "bool"
+ fact["semantic_category"] = "bool"
elif underlying == "char":
fact["kind"] = "integer"
- fact["semantic_category"] = "integer_implementation_signedness"
+ if isinstance(fact.get("signed"), bool):
+ fact["semantic_category"] = "signed_integer" if fact["signed"] else "unsigned_integer"
+ else:
+ fact["semantic_category"] = "integer_implementation_signedness"
else:
fact["semantic_category"] = "implementation_defined"
@@ -171,13 +259,7 @@ def probe_c_standard_types(
appropriate for native builds. Cross-compiled targets must provide a
runner such as an emulator; the command is recorded in the result.
"""
- if not config.compiler:
- raise CStandardTypeProbeError("C standard type probing requires an exact compiler executable")
- if config.compile_commands:
- raise CStandardTypeProbeError(
- "C standard type probing does not consume compile_commands directly; "
- "pass the selected target/include/compiler flags explicitly"
- )
+ _validate_probe_config(config)
with tempfile.TemporaryDirectory(prefix="x2py-c-type-probe-") as temp_dir:
source_path = Path(temp_dir) / "c_standard_type_probe.c"
@@ -250,10 +332,161 @@ def probe_c_standard_types(
)
+def _validate_probe_config(config: PreprocessingConfig) -> None:
+ if not config.compiler:
+ raise CStandardTypeProbeError("C standard type probing requires an exact compiler executable")
+ if config.compile_commands:
+ raise CStandardTypeProbeError(
+ "C standard type probing does not consume compile_commands directly; "
+ "pass the selected target/include/compiler flags explicitly"
+ )
+ if config.command_template:
+ raise CStandardTypeProbeError(
+ "C standard type probing does not consume custom preprocessing templates; "
+ "pass the selected compiler and target flags explicitly"
+ )
+
+
+def load_c_standard_type_probe_report(path: str | Path) -> CStandardTypeProbeReport:
+ """Load and validate a previously generated C ABI probe report."""
+ report_path = Path(path)
+ try:
+ payload = json.loads(report_path.read_text(encoding="utf-8"))
+ except OSError as exc:
+ raise CStandardTypeProbeError(f"failed to read C type probe report {report_path}: {exc}") from exc
+ except json.JSONDecodeError as exc:
+ raise CStandardTypeProbeError(f"C type probe report {report_path} contains invalid JSON: {exc}") from exc
+ return _report_from_payload(payload, source=str(report_path))
+
+
+def c_standard_type_probe_cache_key(
+ config: PreprocessingConfig,
+ *,
+ runner: Sequence[str] | None = None,
+) -> str:
+ """Return the cache key for one exact compiler target and probe schema."""
+ source_digest = hashlib.sha256(build_c_standard_type_probe_source().encode()).hexdigest()
+ payload = {
+ "schema_version": _PROBE_CACHE_SCHEMA_VERSION,
+ "source_digest": source_digest,
+ "compiler": _compiler_identity(config.compiler),
+ "cwd": str(Path.cwd().resolve()),
+ "requested_standard": config.std,
+ "include_dirs": list(config.include_dirs),
+ "defines": list(config.defines),
+ "undefs": list(config.undefs),
+ "compiler_args": list(config.compiler_args),
+ "runner": {
+ "argv": list(runner or ()),
+ "executable": _compiler_identity(runner[0]) if runner else None,
+ },
+ "environment": {name: os.environ.get(name) for name in _PROBE_ENVIRONMENT_VARIABLES},
+ }
+ return hashlib.sha256(json.dumps(payload, sort_keys=True, separators=(",", ":")).encode()).hexdigest()
+
+
+def probe_c_standard_types_cached(
+ config: PreprocessingConfig,
+ *,
+ runner: Sequence[str] | None = None,
+ cache_dir: str | Path | None = None,
+ refresh: bool = False,
+) -> CStandardTypeProbeReport:
+ """Return compiler ABI facts, reusing memory and persistent cache entries."""
+ _validate_probe_config(config)
+ cache_key = c_standard_type_probe_cache_key(config, runner=runner)
+ if not refresh and cache_key in _MEMORY_CACHE:
+ return _MEMORY_CACHE[cache_key]
+
+ cache_path = _probe_cache_dir(cache_dir) / f"{cache_key}.json"
+ if not refresh:
+ try:
+ report = load_c_standard_type_probe_report(cache_path)
+ except CStandardTypeProbeError:
+ pass
+ else:
+ _MEMORY_CACHE[cache_key] = report
+ return report
+
+ report = probe_c_standard_types(config, runner=runner)
+ _MEMORY_CACHE[cache_key] = report
+ _write_cached_report(cache_path, report)
+ return report
+
+
+def _report_from_payload(payload: Any, *, source: str) -> CStandardTypeProbeReport:
+ if not isinstance(payload, dict):
+ raise CStandardTypeProbeError(f"C type probe report {source} must contain a JSON object")
+ types = payload.get("types")
+ recipe = payload.get("recipe")
+ source_text = payload.get("source_text")
+ if not isinstance(types, dict) or not all(
+ isinstance(name, str) and isinstance(fact, dict) for name, fact in types.items()
+ ):
+ raise CStandardTypeProbeError(f"C type probe report {source} is missing valid 'types'")
+ if not isinstance(recipe, dict) or not isinstance(recipe.get("compiler"), str):
+ raise CStandardTypeProbeError(f"C type probe report {source} is missing a valid 'recipe'")
+ if not isinstance(source_text, str):
+ raise CStandardTypeProbeError(f"C type probe report {source} is missing valid 'source_text'")
+ return CStandardTypeProbeReport(
+ types=types,
+ recipe=CStandardTypeProbeRecipe(
+ compiler=recipe["compiler"],
+ compile_argv=list(recipe.get("compile_argv") or []),
+ run_argv=list(recipe.get("run_argv") or []),
+ probe_standard=str(recipe.get("probe_standard") or "c11"),
+ requested_standard=recipe.get("requested_standard"),
+ include_dirs=list(recipe.get("include_dirs") or []),
+ defines=list(recipe.get("defines") or []),
+ undefs=list(recipe.get("undefs") or []),
+ compiler_args=list(recipe.get("compiler_args") or []),
+ ),
+ source_text=source_text,
+ )
+
+
+def _compiler_identity(compiler: str | None) -> dict[str, object]:
+ if compiler is None:
+ return {"command": None}
+ resolved = shutil.which(compiler) or compiler
+ path = Path(resolved).expanduser().resolve()
+ identity: dict[str, object] = {"command": compiler, "path": str(path)}
+ try:
+ stat = path.stat()
+ except OSError:
+ return identity
+ identity.update({"size": stat.st_size, "mtime_ns": stat.st_mtime_ns})
+ return identity
+
+
+def _probe_cache_dir(cache_dir: str | Path | None) -> Path:
+ if cache_dir is not None:
+ return Path(cache_dir)
+ if root := os.getenv("X2PY_CACHE_DIR"):
+ return Path(root) / "c_type_probe"
+ if root := os.getenv("XDG_CACHE_HOME"):
+ return Path(root) / "x2py" / "c_type_probe"
+ return Path.home() / ".cache" / "x2py" / "c_type_probe"
+
+
+def _write_cached_report(path: Path, report: CStandardTypeProbeReport) -> None:
+ temporary_path = path.with_name(f".{path.name}.{os.getpid()}.tmp")
+ try:
+ path.parent.mkdir(parents=True, exist_ok=True)
+ temporary_path.write_text(json.dumps(report.to_dict(), indent=2), encoding="utf-8")
+ os.replace(temporary_path, path)
+ except OSError:
+ # A read-only home/cache directory must not make semantic conversion fail.
+ pass
+ finally:
+ with suppress(OSError):
+ temporary_path.unlink(missing_ok=True)
+
+
def main(argv: list[str] | None = None) -> int:
"""Run a compiler-derived C standard type probe and write JSON."""
parser = argparse.ArgumentParser(
- description="Probe C standard-library typedef ABI facts through an exact compiler."
+ description="Probe modeled C arithmetic-primitive and standard-type ABI facts through an exact compiler."
)
parser.add_argument("--compiler", required=True, help="Exact native or cross C compiler executable.")
parser.add_argument("-I", "--include-dir", dest="include_dirs", action="append", default=[])
@@ -268,13 +501,15 @@ def main(argv: list[str] | None = None) -> int:
default=[],
help="Runner command item for cross targets; repeat for arguments.",
)
+ parser.add_argument("--cache-dir", help="Directory for reusable compiler ABI probe results.")
+ parser.add_argument("--refresh", action="store_true", help="Ignore a reusable ABI probe result and probe again.")
args = parser.parse_args(argv)
try:
for define in args.defines:
validate_macro_name(define, "--define/-D")
for undef in args.undefs:
validate_macro_name(undef, "--undef/-U")
- report = probe_c_standard_types(
+ report = probe_c_standard_types_cached(
PreprocessingConfig(
mode="compiler",
compiler=args.compiler,
@@ -285,6 +520,8 @@ def main(argv: list[str] | None = None) -> int:
compiler_args=args.compiler_args,
),
runner=args.runner or None,
+ cache_dir=args.cache_dir,
+ refresh=args.refresh,
)
except (PreprocessingError, ValueError) as exc:
parser.error(str(exc))
@@ -301,5 +538,8 @@ def main(argv: list[str] | None = None) -> int:
"CStandardTypeProbeRecipe",
"CStandardTypeProbeReport",
"build_c_standard_type_probe_source",
+ "c_standard_type_probe_cache_key",
+ "load_c_standard_type_probe_report",
"probe_c_standard_types",
+ "probe_c_standard_types_cached",
)
diff --git a/x2py/cli.py b/x2py/cli.py
index af36dcfc2..99a328aa4 100644
--- a/x2py/cli.py
+++ b/x2py/cli.py
@@ -17,6 +17,15 @@
from semantics.fortran2ir import fortran_file_to_semantic_modules
from semantics.pyi_parser import load_pyi_modules
from semantics.readiness import assess_semantic_wrap_readiness
+from x2py.c_type_probe import (
+ CStandardTypeProbeError,
+ load_c_standard_type_probe_report,
+ probe_c_standard_types_cached,
+)
+from x2py.fortran_type_probe import (
+ FortranTypeProbeReport,
+ load_fortran_type_probe_report,
+)
from x2py.preprocessing import (
PreprocessingConfig,
PreprocessingError,
@@ -239,35 +248,108 @@ def _parse_report(paths: list[str], preprocessing: PreprocessingConfig | None =
return out
+def _convert_c_project(project, *, c_standard_type_report: dict[str, object] | None):
+ if c_standard_type_report is None:
+ return c_project_to_semantic_modules(project)
+ return c_project_to_semantic_modules(project, standard_type_report=c_standard_type_report)
+
+
+def _c_standard_type_report(
+ preprocessing: PreprocessingConfig,
+ *,
+ report_path: str | None = None,
+ runner: list[str] | None = None,
+ cache_dir: str | None = None,
+ refresh: bool = False,
+) -> dict[str, object] | None:
+ """Load or probe target C ABI facts used by semantic conversion."""
+ if report_path is not None:
+ return load_c_standard_type_probe_report(report_path).to_dict()
+ if not isinstance(preprocessing, PreprocessingConfig) or not preprocessing.compiler:
+ return None
+ if preprocessing.compile_commands or preprocessing.command_template:
+ raise CStandardTypeProbeError(
+ "automatic C ABI probing requires a direct compiler configuration; "
+ "generate a reusable report with `python -m x2py.c_type_probe` and pass it with --c-type-report"
+ )
+ return probe_c_standard_types_cached(
+ preprocessing,
+ runner=runner,
+ cache_dir=cache_dir,
+ refresh=refresh,
+ ).to_dict()
+
+
+def _fortran_probe_options(
+ *,
+ report: FortranTypeProbeReport | None,
+ runner: list[str] | None,
+ cache_dir: str | None,
+ refresh: bool,
+) -> dict[str, object]:
+ options: dict[str, object] = {}
+ if report is not None:
+ options["report"] = report
+ if runner is not None:
+ options["runner"] = runner
+ if cache_dir is not None:
+ options["cache_dir"] = cache_dir
+ if refresh:
+ options["refresh"] = True
+ return options
+
+
def _semantic_report(
paths: list[str],
preprocessing: PreprocessingConfig | None = None,
*,
language: str = "fortran",
+ c_standard_type_report: dict[str, object] | None = None,
+ fortran_type_report: FortranTypeProbeReport | None = None,
+ fortran_type_probe_runner: list[str] | None = None,
+ fortran_type_probe_cache_dir: str | None = None,
+ refresh_fortran_type_probe: bool = False,
) -> dict[str, dict]:
- from semantics.fortran2ir import fortran_module_to_semantic_module
- from semantics.pyi_printer import emit_module_stubs
-
preprocessing = preprocessing or PreprocessingConfig()
- out: dict[str, dict] = {}
if language == "c":
- project = _parse_c_project(paths, preprocessing)
- converted_files = {module.origin.native_name: [module] for module in c_project_to_semantic_modules(project)}
- available_modules = [module for modules in converted_files.values() for module in modules]
- for p in expand_c_paths(paths):
- modules = converted_files[str(p)]
- stubs = emit_module_stubs(modules, available_modules=available_modules)
- primary_names = {module.name for module in modules}
- out[str(p)] = {
- "semantic_modules": [asdict(module) for module in modules],
- "pyi": "\n\n".join(stubs[module.name] for module in modules).strip(),
- }
- dependencies = {
- module_name: text for module_name, text in stubs.items() if module_name not in primary_names
- }
- if dependencies:
- out[str(p)]["pyi_dependencies"] = dependencies
- return out
+ return _c_semantic_report(paths, preprocessing, c_standard_type_report=c_standard_type_report)
+ return _fortran_semantic_report(
+ paths,
+ preprocessing,
+ fortran_type_report=fortran_type_report,
+ fortran_type_probe_runner=fortran_type_probe_runner,
+ fortran_type_probe_cache_dir=fortran_type_probe_cache_dir,
+ refresh_fortran_type_probe=refresh_fortran_type_probe,
+ )
+
+
+def _c_semantic_report(
+ paths: list[str],
+ preprocessing: PreprocessingConfig,
+ *,
+ c_standard_type_report: dict[str, object] | None,
+) -> dict[str, dict]:
+ if c_standard_type_report is None:
+ c_standard_type_report = _c_standard_type_report(preprocessing)
+ project = _parse_c_project(paths, preprocessing)
+ modules_by_source = {
+ module.origin.native_name: [module]
+ for module in _convert_c_project(project, c_standard_type_report=c_standard_type_report)
+ }
+ converted_files = [(path, modules_by_source[str(path)]) for path in expand_c_paths(paths)]
+ return _semantic_payload_for_converted_files(converted_files)
+
+
+def _fortran_semantic_report(
+ paths: list[str],
+ preprocessing: PreprocessingConfig,
+ *,
+ fortran_type_report: FortranTypeProbeReport | None,
+ fortran_type_probe_runner: list[str] | None,
+ fortran_type_probe_cache_dir: str | None,
+ refresh_fortran_type_probe: bool,
+) -> dict[str, dict]:
+ from semantics.fortran2ir import fortran_module_to_semantic_module
parser = FortranParser()
parsed_files = []
@@ -277,17 +359,37 @@ def _semantic_report(
parsed_files.append((p, fobj))
wrapped_derived_types = _fortran_wrapped_derived_types(fobj for _p, fobj in parsed_files)
converted_files = []
+ probe_options = _fortran_probe_options(
+ report=fortran_type_report,
+ runner=fortran_type_probe_runner,
+ cache_dir=fortran_type_probe_cache_dir,
+ refresh=refresh_fortran_type_probe,
+ )
for p, fobj in parsed_files:
- compile_time_values = _fortran_compile_time_values(fobj, preprocessing)
+ compile_time_values = _fortran_compile_time_values(fobj, preprocessing, **probe_options)
+ type_facts = _fortran_type_facts(
+ fobj,
+ preprocessing,
+ compile_time_values=compile_time_values,
+ **probe_options,
+ )
modules = [
fortran_module_to_semantic_module(
m,
compile_time_values=compile_time_values,
wrapped_derived_types=wrapped_derived_types,
+ **({"type_facts": type_facts} if type_facts is not None else {}),
)
for m in fobj.modules
]
converted_files.append((p, modules))
+ return _semantic_payload_for_converted_files(converted_files)
+
+
+def _semantic_payload_for_converted_files(converted_files) -> dict[str, dict]:
+ from semantics.pyi_printer import emit_module_stubs
+
+ out: dict[str, dict] = {}
available_modules = [module for _p, modules in converted_files for module in modules]
for p, modules in converted_files:
stubs = emit_module_stubs(modules, available_modules=available_modules)
@@ -343,14 +445,24 @@ def _wrap_readiness_report(
preprocessing: PreprocessingConfig | None = None,
*,
language: str = "fortran",
+ c_standard_type_report: dict[str, object] | None = None,
+ fortran_type_report: FortranTypeProbeReport | None = None,
+ fortran_type_probe_runner: list[str] | None = None,
+ fortran_type_probe_cache_dir: str | None = None,
+ refresh_fortran_type_probe: bool = False,
) -> dict[str, dict]:
preprocessing = preprocessing or PreprocessingConfig()
out: dict[str, dict] = {}
if language == "c":
c_paths = [path for path in expand_c_paths(paths) if path.suffix.lower() != ".pyi"]
if c_paths:
+ if c_standard_type_report is None:
+ c_standard_type_report = _c_standard_type_report(preprocessing)
project = _parse_c_project([str(path) for path in c_paths], preprocessing)
- converted_files = {module.origin.native_name: [module] for module in c_project_to_semantic_modules(project)}
+ converted_files = {
+ module.origin.native_name: [module]
+ for module in _convert_c_project(project, c_standard_type_report=c_standard_type_report)
+ }
for p in c_paths:
modules = converted_files[str(p)]
out[str(p)] = {
@@ -369,14 +481,27 @@ def _wrap_readiness_report(
parsed_files[p] = parser.visit_file(code, filename=str(p))
wrapped_derived_types = _fortran_wrapped_derived_types(parsed_files.values())
+ probe_options = _fortran_probe_options(
+ report=fortran_type_report,
+ runner=fortran_type_probe_runner,
+ cache_dir=fortran_type_probe_cache_dir,
+ refresh=refresh_fortran_type_probe,
+ )
for p in expanded_paths:
parsed = parsed_files[p]
- compile_time_values = _fortran_compile_time_values(parsed, preprocessing)
+ compile_time_values = _fortran_compile_time_values(parsed, preprocessing, **probe_options)
+ type_facts = _fortran_type_facts(
+ parsed,
+ preprocessing,
+ compile_time_values=compile_time_values,
+ **probe_options,
+ )
modules = fortran_file_to_semantic_modules(
parsed,
standalone_module_name=p.stem,
compile_time_values=compile_time_values,
wrapped_derived_types=wrapped_derived_types,
+ **({"type_facts": type_facts} if type_facts is not None else {}),
)
out[str(p)] = {
@@ -418,9 +543,18 @@ def _fortran_wrapped_derived_types(parsed_files) -> set[tuple[str, str]]:
def _fortran_compile_time_values(
parsed,
preprocessing: PreprocessingConfig,
+ *,
+ report: FortranTypeProbeReport | None = None,
+ runner: list[str] | None = None,
+ cache_dir: str | None = None,
+ refresh: bool = False,
) -> dict[str, int] | None:
"""Evaluate compiler-dependent Fortran values when a compiler is configured."""
- if not preprocessing.uses_compiler or not preprocessing.compiler:
+ if report is None and (
+ not isinstance(preprocessing, PreprocessingConfig)
+ or not preprocessing.uses_compiler
+ or not preprocessing.compiler
+ ):
return None
from semantics.fortran2ir import collect_semantic_compile_time_requirements
@@ -429,7 +563,36 @@ def _fortran_compile_time_values(
requirements = collect_semantic_compile_time_requirements(parsed)
if not requirements:
return None
- return evaluate_fortran_type_requirements(preprocessing, requirements)
+ probe_options = _fortran_probe_options(report=report, runner=runner, cache_dir=cache_dir, refresh=refresh)
+ return evaluate_fortran_type_requirements(preprocessing, requirements, **probe_options)
+
+
+def _fortran_type_facts(
+ parsed,
+ preprocessing: PreprocessingConfig,
+ *,
+ compile_time_values: dict[str, int] | None = None,
+ report: FortranTypeProbeReport | None = None,
+ runner: list[str] | None = None,
+ cache_dir: str | None = None,
+ refresh: bool = False,
+) -> dict[tuple[str, str | None], dict[str, object]] | None:
+ """Measure compiler-dependent storage for intrinsic types used by one source."""
+ if report is None and (
+ not isinstance(preprocessing, PreprocessingConfig)
+ or not preprocessing.uses_compiler
+ or not preprocessing.compiler
+ ):
+ return None
+
+ from semantics.fortran2ir import collect_fortran_type_storage_requirements
+ from x2py.fortran_type_probe import evaluate_fortran_type_facts
+
+ requirements = collect_fortran_type_storage_requirements(parsed, compile_time_values=compile_time_values)
+ if not requirements:
+ return None
+ probe_options = _fortran_probe_options(report=report, runner=runner, cache_dir=cache_dir, refresh=refresh)
+ return evaluate_fortran_type_facts(preprocessing, requirements, **probe_options)
def _attach_wrap_readiness(payload: dict[str, dict] | None, readiness_report: dict[str, dict] | None) -> None:
@@ -526,6 +689,317 @@ def _build_preprocessing_config(args: argparse.Namespace, parser: argparse.Argum
return config
+def _validate_fortran_type_probe_options(
+ *,
+ language: str,
+ has_semantic_stage: bool,
+ report_path: str | None,
+ automatic_options: tuple[object, ...],
+ parser: argparse.ArgumentParser,
+) -> None:
+ options_used = bool(report_path or any(automatic_options))
+ if language != "fortran":
+ if options_used:
+ parser.error("Fortran type probe options require --language fortran")
+ return
+ if options_used and not has_semantic_stage:
+ parser.error("Fortran type probe options require --semantics, --pyi, or --wrap-readiness")
+ if report_path and any(automatic_options):
+ parser.error("--fortran-type-report cannot be combined with automatic Fortran type probe options")
+
+
+def _has_stage(args: argparse.Namespace) -> bool:
+ return bool(args.parse or args.semantics or args.pyi or args.wrap_readiness)
+
+
+def _has_semantic_stage(args: argparse.Namespace) -> bool:
+ return bool(args.semantics or args.pyi or args.wrap_readiness)
+
+
+def _automatic_c_type_probe_options(args: argparse.Namespace) -> tuple[object, ...]:
+ return (
+ getattr(args, "c_type_probe_runner", None),
+ getattr(args, "c_type_probe_cache_dir", None),
+ getattr(args, "refresh_c_type_probe", False),
+ )
+
+
+def _automatic_fortran_type_probe_options(args: argparse.Namespace) -> tuple[object, ...]:
+ return (
+ getattr(args, "fortran_type_probe_runner", None),
+ getattr(args, "fortran_type_probe_cache_dir", None),
+ getattr(args, "refresh_fortran_type_probe", False),
+ )
+
+
+def _c_type_probe_options_used(args: argparse.Namespace) -> bool:
+ return bool(getattr(args, "c_type_report", None) or any(_automatic_c_type_probe_options(args)))
+
+
+def _fortran_type_probe_options_used(args: argparse.Namespace) -> bool:
+ return bool(getattr(args, "fortran_type_report", None) or any(_automatic_fortran_type_probe_options(args)))
+
+
+def _validate_c_type_probe_options(args: argparse.Namespace, parser: argparse.ArgumentParser) -> None:
+ report_path = getattr(args, "c_type_report", None)
+ automatic_options = _automatic_c_type_probe_options(args)
+ options_used = bool(report_path or any(automatic_options))
+ if args.language != "c":
+ if options_used:
+ parser.error("C type probe options require --language c")
+ return
+ if options_used and not _has_semantic_stage(args):
+ parser.error("C type probe options require --semantics, --pyi, or --wrap-readiness")
+ if report_path and any(automatic_options):
+ parser.error("--c-type-report cannot be combined with automatic C type probe options")
+
+
+def _validate_main_options(args: argparse.Namespace, parser: argparse.ArgumentParser) -> int | None:
+ if args.language == "c":
+ if not _has_stage(args):
+ parser.error(
+ "--language c requires a stage flag: choose one of --parse, --semantics, --pyi, or --wrap-readiness"
+ )
+ if args.show_vars:
+ parser.error("--show-vars is Fortran-only and is not supported for --language c")
+
+ _validate_c_type_probe_options(args, parser)
+ _validate_fortran_type_probe_options(
+ language=args.language,
+ has_semantic_stage=_has_semantic_stage(args),
+ report_path=getattr(args, "fortran_type_report", None),
+ automatic_options=_automatic_fortran_type_probe_options(args),
+ parser=parser,
+ )
+ if args.out is not None and not _has_stage(args):
+ parser.error("--out requires a stage flag: choose one of --parse, --semantics, --pyi, or --wrap-readiness")
+ if (args.show_vars or args.print_limit is not None or args.vars_limit is not None) and not args.parse:
+ parser.error("--show-vars/--print-limit require --parse")
+
+ print_limit = args.print_limit if args.print_limit is not None else args.vars_limit
+ if print_limit is not None and print_limit < 0:
+ parser.error("--print-limit must be >= 0")
+ if not _has_stage(args):
+ parser.error("Select at least one stage flag: --parse, --semantics, --pyi, or --wrap-readiness")
+ return print_limit
+
+
+def _load_c_type_report_for_stages(args: argparse.Namespace, preprocessing: PreprocessingConfig):
+ if args.language != "c" or not _has_semantic_stage(args):
+ return None
+ return _c_standard_type_report(
+ preprocessing,
+ report_path=getattr(args, "c_type_report", None),
+ runner=getattr(args, "c_type_probe_runner", None),
+ cache_dir=getattr(args, "c_type_probe_cache_dir", None),
+ refresh=getattr(args, "refresh_c_type_probe", False),
+ )
+
+
+def _load_fortran_type_report_for_stages(args: argparse.Namespace) -> FortranTypeProbeReport | None:
+ report_path = getattr(args, "fortran_type_report", None)
+ return load_fortran_type_probe_report(report_path) if report_path is not None else None
+
+
+def _semantic_stage_options(
+ args: argparse.Namespace,
+ *,
+ c_standard_type_report: dict[str, object] | None,
+ fortran_type_report: FortranTypeProbeReport | None,
+) -> dict[str, object]:
+ options: dict[str, object] = {"language": args.language}
+ if c_standard_type_report is not None:
+ options["c_standard_type_report"] = c_standard_type_report
+ if _fortran_type_probe_options_used(args):
+ options.update(
+ {
+ "fortran_type_report": fortran_type_report,
+ "fortran_type_probe_runner": getattr(args, "fortran_type_probe_runner", None),
+ "fortran_type_probe_cache_dir": getattr(args, "fortran_type_probe_cache_dir", None),
+ "refresh_fortran_type_probe": getattr(args, "refresh_fortran_type_probe", False),
+ }
+ )
+ return options
+
+
+def _parse_stage_report(args: argparse.Namespace, preprocessing: PreprocessingConfig):
+ if not args.parse:
+ return None
+ if args.language == "c":
+ return parse_c_report(
+ args.paths,
+ include_dirs=preprocessing.include_dirs,
+ preprocessing=_c_parser_preprocessing_mode(preprocessing),
+ source_loader=_c_source_loader(preprocessing),
+ )
+ return _parse_report(args.paths, preprocessing)
+
+
+def _run_stage_reports(args: argparse.Namespace, preprocessing: PreprocessingConfig):
+ c_standard_type_report = _load_c_type_report_for_stages(args, preprocessing)
+ fortran_type_report = _load_fortran_type_report_for_stages(args)
+ semantic_options = _semantic_stage_options(
+ args,
+ c_standard_type_report=c_standard_type_report,
+ fortran_type_report=fortran_type_report,
+ )
+ parse_payload = _parse_stage_report(args, preprocessing)
+ semantic_payload = (
+ _semantic_report(args.paths, preprocessing, **semantic_options) if (args.semantics or args.pyi) else None
+ )
+ readiness_payload = (
+ _wrap_readiness_report(args.paths, preprocessing, **semantic_options) if args.wrap_readiness else None
+ )
+ _attach_wrap_readiness(semantic_payload, readiness_payload)
+ return parse_payload, semantic_payload, readiness_payload
+
+
+def _run_stage_reports_with_diagnostics(args: argparse.Namespace, preprocessing: PreprocessingConfig):
+ try:
+ return _run_stage_reports(args, preprocessing)
+ except CParseError as exc:
+ if args.debug or _env_flag("C_PARSER_DEBUG"):
+ raise
+ print(
+ exc.format_diagnostic(color=_diagnostic_color_enabled(disabled=args.no_color), debug=False), file=sys.stderr
+ )
+ except FortranParseError as exc:
+ if args.debug or _env_flag("FORTRAN_PARSER_DEBUG"):
+ raise
+ print(
+ exc.format_diagnostic(color=_diagnostic_color_enabled(disabled=args.no_color), debug=False), file=sys.stderr
+ )
+ except PreprocessingError as exc:
+ if args.debug or _env_flag("X2PY_DEBUG"):
+ raise
+ if exc.diagnostics:
+ for diagnostic in exc.diagnostics:
+ location = diagnostic.path or ""
+ if diagnostic.line is not None:
+ location = f"{location}:{diagnostic.line}"
+ print(f"{location}: error[{diagnostic.category}]: {diagnostic.message}", file=sys.stderr)
+ else:
+ print(f"x2py: error[{exc.category}]: {exc}", file=sys.stderr)
+ except (SyntaxError, ValueError) as exc:
+ if args.debug or _env_flag("X2PY_DEBUG"):
+ raise
+ print(f"x2py: error: {exc}", file=sys.stderr)
+ return None
+
+
+def _select_main_payload(args: argparse.Namespace, parse_payload, semantic_payload, readiness_payload):
+ if args.parse and args.wrap_readiness and (args.json or args.out is not None):
+ return {
+ "parse": parse_payload or {},
+ "wrap_readiness": readiness_payload or {},
+ }
+ if args.parse:
+ return parse_payload or {}
+ if args.semantics or args.pyi:
+ return semantic_payload or {}
+ return readiness_payload or {}
+
+
+def _write_pyi_output(args: argparse.Namespace, semantic_payload: dict[str, dict]) -> None:
+ if args.out:
+ pyi_text = "\n\n".join((report.get("pyi") or "") for report in semantic_payload.values()).strip()
+ Path(args.out).write_text(pyi_text + "\n", encoding="utf-8")
+ _write_pyi_dependencies(semantic_payload, output_dir=Path(args.out).parent)
+ return
+ for fname, report in semantic_payload.items():
+ Path(fname).with_suffix(".pyi").write_text((report.get("pyi") or "") + "\n", encoding="utf-8")
+ _write_pyi_dependencies(semantic_payload)
+
+
+def _write_json_output(args: argparse.Namespace, payload: dict) -> None:
+ if args.out:
+ Path(args.out).write_text(json.dumps(payload, indent=2), encoding="utf-8")
+ return
+ for fname, report in payload.items():
+ Path(fname).with_suffix(".json").write_text(json.dumps({fname: report}, indent=2), encoding="utf-8")
+
+
+def _write_main_output(
+ args: argparse.Namespace,
+ parser: argparse.ArgumentParser,
+ payload: dict,
+ semantic_payload: dict[str, dict] | None,
+) -> bool:
+ if args.out is None:
+ return False
+ if args.json and args.pyi:
+ parser.error("--out cannot be used with both --json and --pyi")
+ if args.pyi:
+ _write_pyi_output(args, semantic_payload or {})
+ else:
+ _write_json_output(args, payload)
+ return True
+
+
+def _print_parse_output(args: argparse.Namespace, parse_payload: dict, print_limit: int | None) -> None:
+ if args.language == "c":
+ print(format_c_report(parse_payload, print_limit=print_limit))
+ return
+ print(
+ _format_report(
+ parse_payload,
+ show_vars=args.show_vars or args.vars_limit is not None,
+ print_limit=print_limit,
+ )
+ )
+
+
+def _print_main_output(
+ args: argparse.Namespace,
+ payload: dict,
+ parse_payload: dict[str, dict] | None,
+ semantic_payload: dict[str, dict] | None,
+ readiness_payload: dict[str, dict] | None,
+ print_limit: int | None,
+) -> None:
+ if args.wrap_readiness:
+ _print_wrap_readiness_output(
+ args,
+ payload,
+ parse_payload=parse_payload,
+ semantic_payload=semantic_payload,
+ readiness_payload=readiness_payload,
+ print_limit=print_limit,
+ )
+ return
+ if args.pyi and not args.json:
+ print_pyi_output(_format_pyi_report(semantic_payload or {}))
+ elif args.parse and not (args.semantics or args.json or args.pyi):
+ _print_parse_output(args, parse_payload or {}, print_limit)
+ else:
+ print(json.dumps(payload, indent=2))
+
+
+def _print_wrap_readiness_output(
+ args: argparse.Namespace,
+ payload: dict,
+ *,
+ parse_payload: dict[str, dict] | None,
+ semantic_payload: dict[str, dict] | None,
+ readiness_payload: dict[str, dict] | None,
+ print_limit: int | None,
+) -> None:
+ if args.parse and not args.json:
+ _print_parse_output(args, parse_payload or {}, print_limit)
+ print()
+ print(_format_semantic_readiness(readiness_payload or {}))
+ elif args.pyi and not args.json:
+ print_pyi_output(_format_pyi_report(semantic_payload or {}))
+ print()
+ print(_format_semantic_readiness(readiness_payload or {}))
+ elif args.parse or args.semantics or args.pyi:
+ print(json.dumps(payload, indent=2))
+ elif args.json:
+ print(json.dumps(readiness_payload or {}, indent=2))
+ else:
+ print(_format_semantic_readiness(readiness_payload or {}))
+
+
def print_pyi_output(code: str) -> None:
# Safe fallback for files, pipes, CI, unsupported terminals, etc.
if not sys.stdout.isatty():
@@ -680,6 +1154,50 @@ def main() -> int:
metavar="ARG",
help="Raw compiler preprocessing argument. Use --compiler-arg=-target for values starting with '-'.",
)
+ parser.add_argument(
+ "--c-type-report",
+ metavar="PATH",
+ help="Reuse a C ABI report generated by `python -m x2py.c_type_probe`.",
+ )
+ parser.add_argument(
+ "--c-type-probe-runner",
+ dest="c_type_probe_runner",
+ action="append",
+ metavar="ARG",
+ help="Runner command item for a cross-compiled C ABI probe; repeat for arguments.",
+ )
+ parser.add_argument(
+ "--c-type-probe-cache-dir",
+ metavar="PATH",
+ help="Directory for reusable automatic C ABI probe results.",
+ )
+ parser.add_argument(
+ "--refresh-c-type-probe",
+ action="store_true",
+ help="Ignore a reusable C ABI result and probe the selected compiler target again.",
+ )
+ parser.add_argument(
+ "--fortran-type-report",
+ metavar="PATH",
+ help="Reuse a Fortran type report generated by `python -m x2py.fortran_type_probe`.",
+ )
+ parser.add_argument(
+ "--fortran-type-probe-runner",
+ dest="fortran_type_probe_runner",
+ action="append",
+ metavar="ARG",
+ help="Runner command item for a cross-compiled Fortran type probe; repeat for arguments.",
+ )
+ parser.add_argument(
+ "--fortran-type-probe-cache-dir",
+ metavar="PATH",
+ help="Directory for reusable automatic Fortran type probe results.",
+ )
+ parser.add_argument(
+ "--refresh-fortran-type-probe",
+ action="store_true",
+ help="Ignore reusable Fortran type results and probe the selected compiler target again.",
+ )
parser.add_argument(
"--include-exposure",
choices=("reachable-project", "roots-only"),
@@ -741,160 +1259,13 @@ def main() -> int:
args = parser.parse_args()
args.language = _resolve_language(args.paths, args.language, parser)
preprocessing = _build_preprocessing_config(args, parser)
-
- if args.language == "c":
- if not (args.parse or args.semantics or args.pyi or args.wrap_readiness):
- parser.error(
- "--language c requires a stage flag: choose one of --parse, --semantics, --pyi, or --wrap-readiness"
- )
- if args.show_vars:
- parser.error("--show-vars is Fortran-only and is not supported for --language c")
-
- if args.out is not None and not (args.parse or args.semantics or args.pyi or args.wrap_readiness):
- parser.error("--out requires a stage flag: choose one of --parse, --semantics, --pyi, or --wrap-readiness")
-
- if (args.show_vars or args.print_limit is not None or args.vars_limit is not None) and not args.parse:
- parser.error("--show-vars/--print-limit require --parse")
-
- print_limit = args.print_limit if args.print_limit is not None else args.vars_limit
- if print_limit is not None and print_limit < 0:
- parser.error("--print-limit must be >= 0")
-
- if not (args.parse or args.semantics or args.pyi or args.wrap_readiness):
- parser.error("Select at least one stage flag: --parse, --semantics, --pyi, or --wrap-readiness")
-
- try:
- parse_payload = (
- parse_c_report(
- args.paths,
- include_dirs=preprocessing.include_dirs,
- preprocessing=_c_parser_preprocessing_mode(preprocessing),
- source_loader=_c_source_loader(preprocessing),
- )
- if args.parse and args.language == "c"
- else _parse_report(args.paths, preprocessing)
- if args.parse
- else None
- )
- semantic_payload = (
- _semantic_report(args.paths, preprocessing, language=args.language)
- if (args.semantics or args.pyi)
- else None
- )
- readiness_payload = (
- _wrap_readiness_report(args.paths, preprocessing, language=args.language) if args.wrap_readiness else None
- )
- _attach_wrap_readiness(semantic_payload, readiness_payload)
- except CParseError as exc:
- if args.debug or _env_flag("C_PARSER_DEBUG"):
- raise
- print(
- exc.format_diagnostic(color=_diagnostic_color_enabled(disabled=args.no_color), debug=False), file=sys.stderr
- )
- return 1
- except FortranParseError as exc:
- if args.debug or _env_flag("FORTRAN_PARSER_DEBUG"):
- raise
- print(
- exc.format_diagnostic(color=_diagnostic_color_enabled(disabled=args.no_color), debug=False), file=sys.stderr
- )
- return 1
- except PreprocessingError as exc:
- if args.debug or _env_flag("X2PY_DEBUG"):
- raise
- if exc.diagnostics:
- for diagnostic in exc.diagnostics:
- location = diagnostic.path or ""
- if diagnostic.line is not None:
- location = f"{location}:{diagnostic.line}"
- print(
- f"{location}: error[{diagnostic.category}]: {diagnostic.message}",
- file=sys.stderr,
- )
- else:
- print(f"x2py: error[{exc.category}]: {exc}", file=sys.stderr)
+ print_limit = _validate_main_options(args, parser)
+ reports = _run_stage_reports_with_diagnostics(args, preprocessing)
+ if reports is None:
return 1
- except (SyntaxError, ValueError) as exc:
- if args.debug or _env_flag("X2PY_DEBUG"):
- raise
- print(f"x2py: error: {exc}", file=sys.stderr)
- return 1
-
- if args.parse and args.wrap_readiness and (args.json or args.out is not None):
- payload = {
- "parse": parse_payload or {},
- "wrap_readiness": readiness_payload or {},
- }
- elif args.parse:
- payload = parse_payload or {}
- elif args.semantics or args.pyi:
- payload = semantic_payload or {}
- else:
- payload = readiness_payload or {}
-
- if args.out is not None:
- if args.json and args.pyi:
- parser.error("--out cannot be used with both --json and --pyi")
-
- if args.pyi:
- if args.out:
- pyi_text = "\n\n".join(
- (report.get("pyi") or "") for report in (semantic_payload or {}).values()
- ).strip()
- Path(args.out).write_text(pyi_text + "\n", encoding="utf-8")
- _write_pyi_dependencies(semantic_payload or {}, output_dir=Path(args.out).parent)
- else:
- for fname, report in (semantic_payload or {}).items():
- Path(fname).with_suffix(".pyi").write_text((report.get("pyi") or "") + "\n", encoding="utf-8")
- _write_pyi_dependencies(semantic_payload or {})
- else:
- if args.out:
- Path(args.out).write_text(json.dumps(payload, indent=2), encoding="utf-8")
- else:
- for fname, report in payload.items():
- Path(fname).with_suffix(".json").write_text(json.dumps({fname: report}, indent=2), encoding="utf-8")
-
- if args.out is not None:
+ parse_payload, semantic_payload, readiness_payload = reports
+ payload = _select_main_payload(args, parse_payload, semantic_payload, readiness_payload)
+ if _write_main_output(args, parser, payload, semantic_payload):
return 0
-
- if args.wrap_readiness:
- if args.parse and not args.json:
- if args.language == "c":
- print(format_c_report(parse_payload or {}, print_limit=print_limit))
- else:
- print(
- _format_report(
- parse_payload or {},
- show_vars=args.show_vars or args.vars_limit is not None,
- print_limit=print_limit,
- )
- )
- print()
- print(_format_semantic_readiness(readiness_payload or {}))
- elif args.pyi and not args.json:
- print_pyi_output(_format_pyi_report(semantic_payload or {}))
- print()
- print(_format_semantic_readiness(readiness_payload or {}))
- elif args.parse or args.semantics or args.pyi:
- print(json.dumps(payload, indent=2))
- elif args.json:
- print(json.dumps(readiness_payload or {}, indent=2))
- else:
- print(_format_semantic_readiness(readiness_payload or {}))
- elif args.pyi and not args.json:
- print_pyi_output(_format_pyi_report(semantic_payload or {}))
- elif args.parse and not (args.semantics or args.json or args.pyi):
- if args.language == "c":
- print(format_c_report(parse_payload or {}, print_limit=print_limit))
- else:
- print(
- _format_report(
- parse_payload or {},
- show_vars=args.show_vars or args.vars_limit is not None,
- print_limit=print_limit,
- )
- )
- else:
- print(json.dumps(payload, indent=2))
-
+ _print_main_output(args, payload, parse_payload, semantic_payload, readiness_payload, print_limit)
return 0
diff --git a/x2py/fortran_type_probe.py b/x2py/fortran_type_probe.py
index c01d26c96..15ba42fb1 100644
--- a/x2py/fortran_type_probe.py
+++ b/x2py/fortran_type_probe.py
@@ -11,14 +11,18 @@
import argparse
from collections.abc import Iterable, Mapping, Sequence
+from contextlib import suppress
from dataclasses import asdict, dataclass
+import hashlib
import json
import os
from pathlib import Path
import re
import shlex
+import shutil
import subprocess
import tempfile
+from typing import Any
from .preprocessing import PreprocessingConfig, PreprocessingError, validate_macro_name
@@ -79,6 +83,23 @@ def to_compile_time_values(
return values
+_PROBE_CACHE_SCHEMA_VERSION = 1
+_PROBE_ENVIRONMENT_VARIABLES = (
+ "COMPILER_PATH",
+ "CPATH",
+ "GFORTRAN_UNBUFFERED_ALL",
+ "GFORTRAN_UNBUFFERED_PRECONNECTED",
+ "GFORTRAN_CONVERT_UNIT",
+ "GCC_EXEC_PREFIX",
+ "LIB",
+ "LIBRARY_PATH",
+ "QEMU_LD_PREFIX",
+ "SDKROOT",
+ "SYSROOT",
+)
+_MEMORY_CACHE: dict[str, FortranTypeProbeReport] = {}
+
+
_SAFE_EXPRESSION_RE = re.compile(r"^[A-Za-z0-9_+\-*/().,= :]+$")
_TOKEN_RE = re.compile(r"\b[A-Za-z_][A-Za-z0-9_]*\b")
@@ -173,13 +194,7 @@ def probe_fortran_type_expressions(
current native-target assumption. Cross targets can pass an emulator/runner
command; the command is recorded in the result.
"""
- if not config.compiler:
- raise FortranTypeProbeError("Fortran type probing requires an exact compiler executable")
- if config.compile_commands:
- raise FortranTypeProbeError(
- "Fortran type probing does not consume compile_commands directly; "
- "pass the selected target/include/compiler flags explicitly"
- )
+ _validate_probe_config(config)
unique_expressions = _normalize_expressions(expressions)
source_text = build_fortran_type_probe_source(unique_expressions)
@@ -262,23 +277,253 @@ def probe_fortran_type_expressions(
)
+def _validate_probe_config(config: PreprocessingConfig) -> None:
+ if not config.compiler:
+ raise FortranTypeProbeError("Fortran type probing requires an exact compiler executable")
+ if config.compile_commands:
+ raise FortranTypeProbeError(
+ "Fortran type probing does not consume compile_commands directly; "
+ "pass the selected target/include/compiler flags explicitly"
+ )
+ if config.command_template:
+ raise FortranTypeProbeError(
+ "Fortran type probing does not consume custom preprocessing templates; "
+ "pass the selected compiler and target flags explicitly"
+ )
+
+
+def load_fortran_type_probe_report(path: str | Path) -> FortranTypeProbeReport:
+ """Load and validate a reusable compiler-derived Fortran type report."""
+ report_path = Path(path)
+ try:
+ payload = json.loads(report_path.read_text(encoding="utf-8"))
+ except OSError as exc:
+ raise FortranTypeProbeError(f"failed to read Fortran type probe report {report_path}: {exc}") from exc
+ except json.JSONDecodeError as exc:
+ raise FortranTypeProbeError(f"Fortran type probe report {report_path} contains invalid JSON: {exc}") from exc
+ return _report_from_payload(payload, source=str(report_path))
+
+
+def fortran_type_probe_cache_key(
+ config: PreprocessingConfig,
+ expressions: Sequence[str],
+ *,
+ runner: Sequence[str] | None = None,
+) -> str:
+ """Return the cache key for one exact compiler target and expression set."""
+ normalized = _normalize_expressions(expressions)
+ source_digest = hashlib.sha256(build_fortran_type_probe_source(normalized).encode()).hexdigest()
+ payload = {
+ "schema_version": _PROBE_CACHE_SCHEMA_VERSION,
+ "source_digest": source_digest,
+ "compiler": _compiler_identity(config.compiler),
+ "cwd": str(Path.cwd().resolve()),
+ "requested_standard": config.std,
+ "include_dirs": list(config.include_dirs),
+ "defines": list(config.defines),
+ "undefs": list(config.undefs),
+ "compiler_args": list(config.compiler_args),
+ "runner": {
+ "argv": list(runner or ()),
+ "executable": _compiler_identity(runner[0]) if runner else None,
+ },
+ "environment": {name: os.environ.get(name) for name in _PROBE_ENVIRONMENT_VARIABLES},
+ }
+ return hashlib.sha256(json.dumps(payload, sort_keys=True, separators=(",", ":")).encode()).hexdigest()
+
+
+def probe_fortran_type_expressions_cached(
+ config: PreprocessingConfig,
+ expressions: Sequence[str],
+ *,
+ runner: Sequence[str] | None = None,
+ cache_dir: str | Path | None = None,
+ refresh: bool = False,
+) -> FortranTypeProbeReport:
+ """Return compiler facts, reusing memory and persistent cache entries."""
+ _validate_probe_config(config)
+ cache_key = fortran_type_probe_cache_key(config, expressions, runner=runner)
+ if not refresh and cache_key in _MEMORY_CACHE:
+ return _MEMORY_CACHE[cache_key]
+
+ cache_path = _probe_cache_dir(cache_dir) / f"{cache_key}.json"
+ if not refresh:
+ try:
+ report = load_fortran_type_probe_report(cache_path)
+ except FortranTypeProbeError:
+ pass
+ else:
+ _MEMORY_CACHE[cache_key] = report
+ return report
+
+ report = probe_fortran_type_expressions(config, expressions, runner=runner)
+ _MEMORY_CACHE[cache_key] = report
+ _write_cached_report(cache_path, report)
+ return report
+
+
+def _report_for_expressions(
+ config: PreprocessingConfig,
+ expressions: Sequence[str],
+ *,
+ report: FortranTypeProbeReport | None = None,
+ runner: Sequence[str] | None = None,
+ cache_dir: str | Path | None = None,
+ refresh: bool = False,
+) -> FortranTypeProbeReport:
+ normalized = _normalize_expressions(expressions)
+ if report is not None:
+ missing = [expression for expression in normalized if _value_for_expression(report.values, expression) is None]
+ if missing:
+ raise FortranTypeProbeError(
+ "Fortran type probe report is missing required expressions: "
+ + ", ".join(repr(item) for item in missing)
+ )
+ return report
+ return probe_fortran_type_expressions_cached(
+ config,
+ normalized,
+ runner=runner,
+ cache_dir=cache_dir,
+ refresh=refresh,
+ )
+
+
def evaluate_fortran_type_requirements(
config: PreprocessingConfig,
requirements: Iterable[Mapping[str, object]],
*,
+ report: FortranTypeProbeReport | None = None,
runner: Sequence[str] | None = None,
+ cache_dir: str | Path | None = None,
+ refresh: bool = False,
) -> dict[str, int]:
"""Evaluate collected semantic requirements into compile-time values."""
requirement_list = list(requirements)
expressions = fortran_type_probe_expressions(requirement_list)
if not expressions:
return {}
- report = probe_fortran_type_expressions(
+ active_report = _report_for_expressions(
config,
expressions,
+ report=report,
runner=runner,
+ cache_dir=cache_dir,
+ refresh=refresh,
)
- return report.to_compile_time_values(requirement_list)
+ return active_report.to_compile_time_values(requirement_list)
+
+
+def evaluate_fortran_type_facts(
+ config: PreprocessingConfig,
+ requirements: Iterable[Mapping[str, object]],
+ *,
+ report: FortranTypeProbeReport | None = None,
+ runner: Sequence[str] | None = None,
+ cache_dir: str | Path | None = None,
+ refresh: bool = False,
+) -> dict[tuple[str, str | None], dict[str, object]]:
+ """Measure storage facts for collected intrinsic Fortran type requirements."""
+ requirement_list = list(requirements)
+ expressions = [str(item.get("expression") or "").strip() for item in requirement_list]
+ expressions = [expression for expression in expressions if expression]
+ if not expressions:
+ return {}
+ active_report = _report_for_expressions(
+ config,
+ expressions,
+ report=report,
+ runner=runner,
+ cache_dir=cache_dir,
+ refresh=refresh,
+ )
+ facts: dict[tuple[str, str | None], dict[str, object]] = {}
+ for item in requirement_list:
+ expression = str(item.get("expression") or "").strip()
+ if not expression:
+ continue
+ value = _value_for_expression(active_report.values, expression)
+ if value is None: # pragma: no cover - guarded by _report_for_expressions.
+ raise FortranTypeProbeError(f"Fortran type probe report is missing required expression {expression!r}")
+ base_type = str(item.get("base_type") or "").lower()
+ raw_kind = item.get("kind")
+ kind = None if raw_kind is None else str(raw_kind).lower()
+ facts[(base_type, kind)] = {
+ "base_type": base_type,
+ "kind": kind,
+ "bits": value,
+ "expression": expression,
+ }
+ return facts
+
+
+def _report_from_payload(payload: Any, *, source: str) -> FortranTypeProbeReport:
+ if not isinstance(payload, dict):
+ raise FortranTypeProbeError(f"Fortran type probe report {source} must contain a JSON object")
+ values = payload.get("values")
+ recipe = payload.get("recipe")
+ source_text = payload.get("source_text")
+ if not isinstance(values, dict) or not all(
+ isinstance(key, str) and isinstance(value, int) for key, value in values.items()
+ ):
+ raise FortranTypeProbeError(f"Fortran type probe report {source} is missing valid 'values'")
+ if not isinstance(recipe, dict) or not isinstance(recipe.get("compiler"), str):
+ raise FortranTypeProbeError(f"Fortran type probe report {source} is missing a valid 'recipe'")
+ if not isinstance(source_text, str):
+ raise FortranTypeProbeError(f"Fortran type probe report {source} is missing valid 'source_text'")
+ return FortranTypeProbeReport(
+ values=values,
+ recipe=FortranTypeProbeRecipe(
+ compiler=recipe["compiler"],
+ compile_argv=list(recipe.get("compile_argv") or []),
+ run_argv=list(recipe.get("run_argv") or []),
+ expressions=list(recipe.get("expressions") or []),
+ requested_standard=recipe.get("requested_standard"),
+ include_dirs=list(recipe.get("include_dirs") or []),
+ defines=list(recipe.get("defines") or []),
+ undefs=list(recipe.get("undefs") or []),
+ compiler_args=list(recipe.get("compiler_args") or []),
+ ),
+ source_text=source_text,
+ )
+
+
+def _compiler_identity(compiler: str | None) -> dict[str, object]:
+ if compiler is None:
+ return {"command": None}
+ resolved = shutil.which(compiler) or compiler
+ path = Path(resolved).expanduser().resolve()
+ identity: dict[str, object] = {"command": compiler, "path": str(path)}
+ try:
+ stat = path.stat()
+ except OSError:
+ return identity
+ identity.update({"size": stat.st_size, "mtime_ns": stat.st_mtime_ns})
+ return identity
+
+
+def _probe_cache_dir(cache_dir: str | Path | None) -> Path:
+ if cache_dir is not None:
+ return Path(cache_dir)
+ if root := os.getenv("X2PY_CACHE_DIR"):
+ return Path(root) / "fortran_type_probe"
+ if root := os.getenv("XDG_CACHE_HOME"):
+ return Path(root) / "x2py" / "fortran_type_probe"
+ return Path.home() / ".cache" / "x2py" / "fortran_type_probe"
+
+
+def _write_cached_report(path: Path, report: FortranTypeProbeReport) -> None:
+ temporary_path = path.with_name(f".{path.name}.{os.getpid()}.tmp")
+ try:
+ path.parent.mkdir(parents=True, exist_ok=True)
+ temporary_path.write_text(json.dumps(report.to_dict(), indent=2), encoding="utf-8")
+ os.replace(temporary_path, path)
+ except OSError:
+ # A read-only home/cache directory must not make semantic conversion fail.
+ pass
+ finally:
+ with suppress(OSError):
+ temporary_path.unlink(missing_ok=True)
def _normalize_expressions(expressions: Sequence[str]) -> list[str]:
@@ -312,9 +557,18 @@ def _probe_import_lines(expressions: Sequence[str]) -> list[str]:
env_names = sorted(tokens & _ISO_FORTRAN_ENV_NAMES)
c_names = sorted(tokens & _ISO_C_BINDING_NAMES)
if env_names:
- lines.append(f" use, intrinsic :: iso_fortran_env, only: {', '.join(env_names)}")
+ lines.extend(_probe_import_statement("iso_fortran_env", env_names))
if c_names:
- lines.append(f" use, intrinsic :: iso_c_binding, only: {', '.join(c_names)}")
+ lines.extend(_probe_import_statement("iso_c_binding", c_names))
+ return lines
+
+
+def _probe_import_statement(module: str, names: Sequence[str]) -> list[str]:
+ single_line = f" use, intrinsic :: {module}, only: {', '.join(names)}"
+ if len(single_line) <= 120:
+ return [single_line]
+ lines = [f" use, intrinsic :: {module}, only: &"]
+ lines.extend(f" {name}{', &' if index < len(names) - 1 else ''}" for index, name in enumerate(names))
return lines
@@ -367,13 +621,15 @@ def main(argv: list[str] | None = None) -> int:
default=[],
help="Runner command item for cross targets; repeat for arguments.",
)
+ parser.add_argument("--cache-dir", help="Directory for reusable compiler-derived Fortran type results.")
+ parser.add_argument("--refresh", action="store_true", help="Ignore a reusable Fortran type result and probe again.")
args = parser.parse_args(argv)
try:
for define in args.defines:
validate_macro_name(define, "--define/-D")
for undef in args.undefs:
validate_macro_name(undef, "--undef/-U")
- report = probe_fortran_type_expressions(
+ report = probe_fortran_type_expressions_cached(
PreprocessingConfig(
mode="compiler",
compiler=args.compiler,
@@ -385,6 +641,8 @@ def main(argv: list[str] | None = None) -> int:
),
args.expressions,
runner=args.runner or None,
+ cache_dir=args.cache_dir,
+ refresh=args.refresh,
)
except (PreprocessingError, ValueError) as exc:
parser.error(str(exc))
@@ -401,7 +659,11 @@ def main(argv: list[str] | None = None) -> int:
"FortranTypeProbeRecipe",
"FortranTypeProbeReport",
"build_fortran_type_probe_source",
+ "evaluate_fortran_type_facts",
"evaluate_fortran_type_requirements",
+ "fortran_type_probe_cache_key",
"fortran_type_probe_expressions",
+ "load_fortran_type_probe_report",
"probe_fortran_type_expressions",
+ "probe_fortran_type_expressions_cached",
)
diff --git a/x2py/type_mapping_report.py b/x2py/type_mapping_report.py
new file mode 100644
index 000000000..7a2ab2f00
--- /dev/null
+++ b/x2py/type_mapping_report.py
@@ -0,0 +1,322 @@
+"""Generate target-specific native-to-semantic-to-NumPy mapping examples."""
+
+from __future__ import annotations
+
+import argparse
+from collections.abc import Sequence
+import platform
+
+from c_parser.models import (
+ CBool,
+ CChar,
+ CDouble,
+ CDoubleComplex,
+ CFloat,
+ CFloatComplex,
+ CInt,
+ CLong,
+ CLongDouble,
+ CLongDoubleComplex,
+ CLongLong,
+ CShort,
+ CSignedChar,
+ CTypedef,
+ CUnsignedChar,
+ CUnsignedInt,
+ CUnsignedLong,
+ CUnsignedLongLong,
+ CUnsignedShort,
+)
+from fortran_parser.models import FortranVariable
+from semantics.c2ir import CToIRConverter
+from semantics.fortran2ir import FortranToIRConverter, fortran_type_storage_expression
+
+from .c_type_probe import probe_c_standard_types_cached
+from .fortran_type_probe import evaluate_fortran_type_facts, probe_fortran_type_expressions_cached
+from .preprocessing import PreprocessingConfig
+
+
+_NUMPY_DTYPE_BY_SEMANTIC_DTYPE = {
+ "Bool": "numpy.bool_",
+ "Int8": "numpy.int8",
+ "Int16": "numpy.int16",
+ "Int32": "numpy.int32",
+ "Int64": "numpy.int64",
+ "UInt8": "numpy.uint8",
+ "UInt16": "numpy.uint16",
+ "UInt32": "numpy.uint32",
+ "UInt64": "numpy.uint64",
+ "Float32": "numpy.float32",
+ "Float64": "numpy.float64",
+ "Float128": "numpy.longdouble",
+ "Complex64": "numpy.complex64",
+ "Complex128": "numpy.complex128",
+ "Complex256": "numpy.clongdouble",
+ "String": "numpy.str_ / ABI bytes",
+}
+
+_C_TYPES = (
+ ("_Bool", CBool()),
+ ("char", CChar()),
+ ("signed char", CSignedChar()),
+ ("unsigned char", CUnsignedChar()),
+ ("short", CShort()),
+ ("unsigned short", CUnsignedShort()),
+ ("int", CInt()),
+ ("unsigned int", CUnsignedInt()),
+ ("long", CLong()),
+ ("unsigned long", CUnsignedLong()),
+ ("long long", CLongLong()),
+ ("unsigned long long", CUnsignedLongLong()),
+ ("float", CFloat()),
+ ("double", CDouble()),
+ ("long double", CLongDouble()),
+ ("float _Complex", CFloatComplex()),
+ ("double _Complex", CDoubleComplex()),
+ ("long double _Complex", CLongDoubleComplex()),
+ ("size_t", CTypedef(name="size_t")),
+)
+
+
+def _fortran_type(
+ spelling: str,
+ base_type: str,
+ kind: str | None = None,
+ *,
+ target_kind_expression: str | None = None,
+ character_length_syntax: bool = False,
+ declared_storage_bits: int | None = None,
+) -> tuple[str, FortranVariable]:
+ variable = FortranVariable(name="value", base_type=base_type, kind=kind or "")
+ if target_kind_expression:
+ variable._target_kind_expression = target_kind_expression
+ if character_length_syntax:
+ variable._character_length_syntax = True
+ if declared_storage_bits is not None:
+ variable._declared_storage_bits = declared_storage_bits
+ return spelling, variable
+
+
+_FORTRAN_MODERN_TYPES = (
+ _fortran_type("integer", "integer"),
+ *(_fortran_type(f"integer(kind={kind})", "integer", kind) for kind in ("1", "2", "4", "8")),
+ *(_fortran_type(f"integer({kind})", "integer", kind) for kind in ("int8", "int16", "int32", "int64")),
+ *(
+ _fortran_type(f"integer({kind})", "integer", kind)
+ for kind in (
+ "c_signed_char",
+ "c_short",
+ "c_int",
+ "c_long",
+ "c_long_long",
+ "c_size_t",
+ "c_int8_t",
+ "c_int16_t",
+ "c_int32_t",
+ "c_int64_t",
+ )
+ ),
+ _fortran_type("real", "real"),
+ *(_fortran_type(f"real(kind={kind})", "real", kind) for kind in ("4", "8", "16")),
+ *(_fortran_type(f"real({kind})", "real", kind) for kind in ("real32", "real64", "real128")),
+ *(_fortran_type(f"real({kind})", "real", kind) for kind in ("c_float", "c_double", "c_long_double")),
+ *(_fortran_type(f"real({kind})", "real", kind) for kind in ("kind(1.0e0)", "kind(1.0d0)", "kind(1.0q0)")),
+ _fortran_type("complex", "complex"),
+ *(_fortran_type(f"complex(kind={kind})", "complex", kind) for kind in ("4", "8", "16")),
+ *(_fortran_type(f"complex({kind})", "complex", kind) for kind in ("real32", "real64", "real128")),
+ *(
+ _fortran_type(f"complex({kind})", "complex", kind)
+ for kind in ("c_float_complex", "c_double_complex", "c_long_double_complex")
+ ),
+ *(
+ _fortran_type(f"complex(kind={kind})", "complex", kind)
+ for kind in ("kind(1.0e0)", "kind(1.0d0)", "kind(1.0q0)")
+ ),
+ _fortran_type("logical", "logical"),
+ *(_fortran_type(f"logical(kind={kind})", "logical", kind) for kind in ("1", "2", "4", "8")),
+ _fortran_type("logical(c_bool)", "logical", "c_bool"),
+ _fortran_type("character", "character"),
+ _fortran_type("character(len=n)", "character", "n", character_length_syntax=True),
+ _fortran_type("character(kind=1)", "character", "kind=1"),
+ _fortran_type("character(kind=c_char)", "character", "kind=c_char"),
+)
+
+_FORTRAN_LEGACY_TYPES = (
+ *(
+ _fortran_type(f"integer*{width}", "integer", width, declared_storage_bits=int(width) * 8)
+ for width in ("1", "2", "4", "8")
+ ),
+ *(
+ _fortran_type(f"real*{width}", "real", width, declared_storage_bits=int(width) * 8)
+ for width in ("4", "8", "16")
+ ),
+ _fortran_type("double precision", "real", target_kind_expression="kind(1.0d0)"),
+ *(
+ _fortran_type(f"complex*{width}", "complex", width, declared_storage_bits=int(width) * 8)
+ for width in ("8", "16", "32")
+ ),
+ _fortran_type("double complex", "complex", target_kind_expression="kind(1.0d0)"),
+ *(
+ _fortran_type(f"logical*{width}", "logical", width, declared_storage_bits=int(width) * 8)
+ for width in ("1", "2", "4", "8")
+ ),
+ _fortran_type("character*1", "character", "1", character_length_syntax=True),
+ _fortran_type("character*8", "character", "8", character_length_syntax=True),
+ _fortran_type("character*(*)", "character", "*", character_length_syntax=True),
+)
+
+_FORTRAN_TYPES = (*_FORTRAN_MODERN_TYPES, *_FORTRAN_LEGACY_TYPES)
+
+
+def target_profile() -> str:
+ """Return a stable platform label used by architecture-specific docs."""
+ machine = platform.machine().lower()
+ machine = {"amd64": "x86_64", "arm64": "aarch64"}.get(machine, machine)
+ return f"{platform.system().lower()}-{machine}"
+
+
+def c_type_mapping_markdown(
+ *,
+ compiler: str = "cc",
+ compiler_args: Sequence[str] = (),
+ runner: Sequence[str] | None = None,
+ cache_dir: str | None = None,
+ refresh: bool = False,
+) -> str:
+ """Generate the modeled C arithmetic mapping table for one compiler target."""
+ report = probe_c_standard_types_cached(
+ PreprocessingConfig(mode="compiler", compiler=compiler, compiler_args=list(compiler_args)),
+ runner=runner,
+ cache_dir=cache_dir,
+ refresh=refresh,
+ )
+ converter = CToIRConverter(standard_type_report=report)
+ rows = []
+ for spelling, ctype in _C_TYPES:
+ semantic_type = converter.visit_type(ctype)
+ fact = report.types[spelling]
+ rows.append((spelling, _c_fact_text(fact), _semantic_text(semantic_type), _numpy_dtype(semantic_type.dtype)))
+ return _markdown_table("C type", rows)
+
+
+def fortran_type_mapping_markdown(
+ *,
+ compiler: str = "gfortran",
+ compiler_args: Sequence[str] = (),
+ runner: Sequence[str] | None = None,
+ cache_dir: str | None = None,
+ refresh: bool = False,
+) -> str:
+ """Generate the supported Fortran intrinsic mapping table for one target."""
+ key_converter = FortranToIRConverter()
+ entries = [
+ (
+ spelling,
+ variable,
+ key,
+ None if variable.declared_storage_bits is not None else fortran_type_storage_expression(*key),
+ )
+ for spelling, variable in _FORTRAN_TYPES
+ for key in [key_converter._target_type_key(variable)]
+ ]
+ expressions = [expression for _spelling, _variable, _key, expression in entries if expression is not None]
+ config = PreprocessingConfig(mode="compiler", compiler=compiler, compiler_args=list(compiler_args))
+ report = probe_fortran_type_expressions_cached(
+ config,
+ expressions,
+ runner=runner,
+ cache_dir=cache_dir,
+ refresh=refresh,
+ )
+ requirements = [
+ {
+ "base_type": key[0],
+ "kind": key[1],
+ "expression": expression,
+ }
+ for _spelling, _variable, key, expression in entries
+ if expression is not None
+ ]
+ converter = FortranToIRConverter(type_facts=evaluate_fortran_type_facts(config, requirements, report=report))
+ rows = []
+ for spelling, variable, _key, _expression in entries:
+ semantic_type = converter.visit_variable(variable)
+ fact = semantic_type.metadata["fortran_type_fact"]
+ rows.append(
+ (
+ spelling,
+ f"{fact['bits']}-bit storage",
+ _semantic_text(semantic_type),
+ _numpy_dtype(semantic_type.dtype),
+ )
+ )
+ return _markdown_table("Fortran type", rows)
+
+
+def _c_fact_text(fact: dict[str, object]) -> str:
+ bits = int(fact.get("bits") or 0)
+ if fact.get("kind") == "integer":
+ signedness = "signed" if fact.get("signed") else "unsigned"
+ return f"{signedness} {bits}-bit"
+ if fact.get("kind") == "bool":
+ return f"{bits}-bit bool"
+ if fact.get("kind") == "real":
+ return f"{bits}-bit storage, {fact.get('precision_bits')}-bit precision"
+ if fact.get("kind") == "complex":
+ return f"{bits}-bit storage"
+ return str(fact.get("kind") or "unknown")
+
+
+def _semantic_text(semantic_type) -> str:
+ if semantic_type.name != semantic_type.dtype:
+ return f"{semantic_type.name} ({semantic_type.dtype} storage)"
+ return str(semantic_type.dtype)
+
+
+def _numpy_dtype(semantic_dtype: str | None) -> str:
+ return _NUMPY_DTYPE_BY_SEMANTIC_DTYPE.get(str(semantic_dtype), "unsupported")
+
+
+def _markdown_table(native_header: str, rows: list[tuple[str, str, str, str]]) -> str:
+ lines = [
+ f"Target profile: `{target_profile()}`",
+ "",
+ f"| {native_header} | Native target fact | Semantic dtype | NumPy dtype |",
+ "| --- | --- | --- | --- |",
+ ]
+ lines.extend(f"| `{native}` | {fact} | `{semantic}` | `{numpy}` |" for native, fact, semantic, numpy in rows)
+ return "\n".join(lines)
+
+
+def main(argv: list[str] | None = None) -> int:
+ """Print one compiler-generated datatype mapping table."""
+ parser = argparse.ArgumentParser(description="Generate a target-specific x2py datatype mapping table.")
+ parser.add_argument("--language", choices=("c", "fortran"), required=True)
+ parser.add_argument("--compiler", help="Exact compiler executable; defaults to cc or gfortran.")
+ parser.add_argument("--compiler-arg", dest="compiler_args", action="append", default=[])
+ parser.add_argument("--runner", action="append", default=[], help="Runner command item for a cross target.")
+ parser.add_argument("--cache-dir", help="Directory for reusable compiler type probe results.")
+ parser.add_argument("--refresh", action="store_true", help="Ignore reusable type probe results and probe again.")
+ args = parser.parse_args(argv)
+ options = {
+ "compiler_args": args.compiler_args,
+ "runner": args.runner or None,
+ "cache_dir": args.cache_dir,
+ "refresh": args.refresh,
+ }
+ if args.language == "c":
+ print(c_type_mapping_markdown(compiler=args.compiler or "cc", **options))
+ else:
+ print(fortran_type_mapping_markdown(compiler=args.compiler or "gfortran", **options))
+ return 0
+
+
+if __name__ == "__main__": # pragma: no cover - exercised through executable documentation.
+ raise SystemExit(main())
+
+
+__all__ = (
+ "c_type_mapping_markdown",
+ "fortran_type_mapping_markdown",
+ "target_profile",
+)