Mirror-bot/AnyPS5
1
0 Fork 0
mirror of https://github.com/boykopovar/AnyPS5.git synced 2026-11-04 13:07:32 +00:00
Code Issues Projects Releases Activity
Files
c3cfc125236258ef640cd2bfb7d9c4b9a63ef4e2
AnyPS5/docs/dev/debt/libSceJson2.md
T

29 KiB
Raw Blame History

libSceJson2 technical debt

Unknown function info

  • JSON real-number conversion (libSceJson2) uses locale-independent to_chars with 17 significant digits and from_chars, following JSON's decimal-point grammar in RFC 8259 section 6. Out-of-range input falls back to a classic-locale stream so underflow retains the prior signed-zero behavior and overflow throws. Console rounding and formatting are unverified.

  • sce::Json::Array::pop_front - the console result for an empty array remains unverified; the existing host behavior throws std::out_of_range. Missing storage throws unsupported. Nonempty removal releases the allocator-owned node without allocating and preserves surviving element/iterator identity.

  • sce::Json::Parser::parse - null text with nonzero size and double overflow throw rather than inventing a result. Numeric-token validation, more complex parser allocation failures and cross-thread operation behavior remain incomplete. Parsing mutates the supplied destination, following 0x6940, 0x6840 and 0x5d30: failed arrays/objects retain admitted entries, strings append their decoded prefix, and incomplete scalar literals preserve the previous value. Existing collections retain their entries across later parses. Local tests cover nested parent links, duplicate-member failure, type transitions and actual allocator cleanup; the same contract passes the reference module. These checks do not establish allocator-failure equivalence or Linux/Windows guest execution.

  • sce::Json::InitParameter2, InitParameterRtti and InitParameterRtti2 (libSceJson2) - initialization owns its allocator-backed context, default resources, module fallback and kernel synchronization handles. Allocation admission, rollback and retry follow the observed default-resource protocol; file-buffer size is snapshotted and used by file parsing. Kernel API failure paths, reentrant initialization/termination and full guest execution remain incomplete. The active-byte and enum validation rules follow the inspected initializer at 0x920 and 0x12b0–0x13f7, with local allocation-failure coverage. The module firmware version is unverified; these are library observations, not console measurements.

  • sce::Json::Value auxiliary ownership - values use the inspected 32-byte inline payload and parent layout, and allocator-backed auxiliary ownership. Outer value handles, string headers and characters, array and object storage and their iterator states use the supplied allocator; module defaults are allocated during initialization, including admitted partial default resources. Request sizes, failure admission and SDK-dependent ownership below SDK 6 remain incomplete. The callback regressions exercise SDK 6 behavior; console execution and older-SDK callback compatibility are unverified.

  • InitParameter2 special-float configuration follows assignment helpers at 0x40a0 and 0x41a0 and formatting at 0x26a0: mode 0 converts non-finite numbers to strings, mode 1 to null, and mode 2 retains real values and emits lowercase non-JSON tokens. Parser acceptance of those tokens, floating-point exception flags, signaling-NaN behavior and concurrent reconfiguration remain unverified. Legacy initialization does not enable the conversion; its internal formatter differs from the host formatter and remains unsupported for non-finite serialization. Value::set(double) and toString(String&) expose no consistent return value and are declared void.

  • sce::Json::Object::Pair, sce::Json::Array::iterator and sce::Json::Object::iterator members (libSceJson2) - Pair(const String&, const Value&) and default Pair() zero the 8 bytes between the key and value; what the console keeps there is unknown. Array and object postfix increment use this and the dummy integer argument and advance in place, following 0xb270 and 0xc4a0; they do not take a hidden result pointer. This ABI is verified against the inspected module, not every firmware version.

  • sce::Json::Value handler registration - legacy special-float/element registration and libc-heap failure handling remain incomplete. Modern auxiliary records, fallback values and callback records use the supplied allocator. The inspected setters at 0x39c0, 0x3b00, 0x3e90 and 0x3fa0 reject owned children with 0x80848104. The value null-access setter is a three-argument member returning status, rather than a static callback setter. Legacy mismatch-map storage is covered separately below; other SDK-dependent legacy combinations remain unverified.

  • sce::Json::Value type-mismatch dispatch - libc-heap failures and untested legacy callback combinations remain incomplete. Global registration follows 0x1480; root-local mismatch precedes global null recovery, followed by global mismatch. Current root lookup and borrowed-result dispatch follow 0x22b0 and 0x2930, including requested type, source, immediate parent, callback precedence and a shared reentry guard. Additional legacy compatibility remains unverified.

  • sce::Json::Value element-access failure dispatch - SDK-dependent dispatch remains incomplete. Global registration and fallback selection follow 0x1670 and 0x2c70. Root-owned fallback identity, reentry suppression and errors 0x80848115 through 0x80848118 follow 0x2c70, 0x4e80 and 0x5070. Nested fallback-value failure behavior and compatibility below SDK 6 remain incomplete.

  • sce::Json::Value special-float recovery - allocator-backed value failures remain incomplete. Global registration follows 0x14f0, including legacy-initializer rejection and duplicate registration; root handlers precede global handlers. Root recovery follows 0x2b90, 0x2d90 and 0x41a0, including the hidden result object, temporary cloning and teardown, function types 0/1, optional error flag and reentry suppression. SDK-dependent registration below SDK 6, signaling NaNs and floating-point exception flags remain unverified.

  • sce::Json::MemAllocator::notifyError (libSceJson2) - the base class's virtual does nothing; whether the console's base implementation logs is unknown. String, array, object, callback metadata and file-buffer allocation failures dispatch the supplied allocator's notifier.

  • sce::Json::String size, capacity, resize, append(const char*, size_t), operator+= (libSceJson2) - headers and characters use the supplied allocator, with the inspected 24-byte header and 32-bit capacity. Constructors, clear, reserve, resize, copy, assignment and append failure contracts follow 0xa100–0xb0a0, 0xde50 and the instructions at 0xdf20. Overlapping assignment, exact substring temporary allocations, allocator failure propagation through every value/parser operation and native assertion behavior for sizes above 32 bits remain incomplete. SDK-dependent growth reads process parameters; missing metadata uses the reference query-failure rule. Appending null text with a nonzero length throws instead of dereferencing it.

  • sce::Json::Array::iterator::advance and Object::iterator members (libSceJson2) - the source-level return type of advance remains unverified; array advancement is declared void and tested for its side effects. Object iterator advancement past the end throws instead of asserting. Array iterators expose the inspected node payload address, including the sentinel; a missing iterator state uses the module default value, whose allocator-backed identity remains incomplete.

  • sce::Json::Value::operator bool - untested legacy callback combinations remain incomplete. Modern root-local mismatch precedes global mismatch; ordinary boolean values bypass both. Root-local mismatch dispatch precedes ordinary conversion, following 0x2100; the returned value is read through its boolean getter under the shared callback guard.

  • sce::Json::Parser file input - allocator failures outside the file buffer and callback-read failure combinations remain incomplete. Buffer ownership and the read adapter follow 0x69c0 and 0x6b20; local contract tests substitute the kernel file boundary and do not prove guest filesystem integration on Linux or Windows.

  • sce::Json::Array storage and iterators - nested value-copy allocator failures, shared concurrent allocation-operation accounting and legacy parent binding remain incomplete. Header, sentinel, node and iterator allocation follow 0xb2d0, 0xb410, 0xb540, 0xb6f0 and 0xb130; local contract tests cover scalar copies and partial ownership. Failed node allocation in push_back removes the existing last entry, following 0xb880; this behavior is verified against the inspected module only. Circular traversal follows 0xb250 and 0xb290; large advances reduce complete cycles without changing the resulting node. front on a partial header with no sentinel throws instead of dereferencing null. Full Linux/Windows execution is unverified.

  • sce::Json::Object storage and assignment - legacy ownership, callback-bearing copies and concurrent operation accounting remain incomplete. Allocator-backed tree nodes can retain incomplete entries or a source count exceeding their live nodes after copy failure (0xca40, 0xe000). Modern assignment (0xd400) preserves the original on initial allocation failure but can replace it with partial entries after later failures; self-assignment rebuilds the tree. Legacy insertion copies the pair directly. SDK 5 boundary tests do not establish cross-firmware compatibility. Erasure allocates nothing (0xd350). Missing-state iterator dereference throws if its temporary default iterator cannot be allocated; the reference can recurse. Full Linux/Windows execution remains unverified.

  • sce::Json::Parser embedded zero characters - decoded Unicode zero is discarded through the inspected character-append behavior. Binary string values serialize using their stored length, while object keys serialize their C-string prefix. Broader malformed Unicode handling remains incomplete.

  • sce::Json::Value handle admission and type changes - collection copy/assignment failure ordering, nested recovery failures and older SDK compatibility remain incomplete. The supplied allocator owns each eight-byte complex-value handle. Typed construction and type changes follow 0x580, 0x10d0, 0x1170 and 0x1210: the old payload is destroyed before replacement admission; string/header failure leaves null, an array can retain a header without its sentinel, and object construction reclaims a failed sentinel. Scalar changes preserve inactive payload bytes. Special-float string conversion follows the temporary string at 0x40a0; failure of its header preserves the prior value, while later failures can leave null or an empty string. Local tests cover SDK 6 process metadata, not every firmware version.

  • sce::Json::Value auxiliary admission and retry - legacy special-float and element registration remain unsupported and throw. Modern admission follows 0x3280: a failed fallback allocation retains the 72-byte auxiliary record; later registration reuses it without recreating the missing fallback. Local tests cover all four callback setters, their allocation failures, replacement and null callbacks, child rejection, parent preservation and teardown through the original allocator. Legacy auxiliary records use 24 bytes; mismatch callbacks use a separate map whose header uses the supplied allocator and whose 56-byte nodes use libc new/delete.

  • sce::Json::Value scalar and string copying - nested collection assignment failures remain incomplete. Scalar and string dispatch follow 0x1e40: null and boolean copies preserve inactive destination bytes, numeric values retain their exact payloads, and string assignment changes type before copying characters into the existing header. A character-allocation failure can empty an existing string; it does not restore its old contents. Copy construction initializes ownership metadata directly, following 0x1e20. Local allocator tests cover null, boolean, signed, unsigned, finite real and string sources across all destination types and failure budgets.

  • sce::Json::Array and Value collection assignment - nested allocator failures, legacy callback propagation and concurrent operation accounting remain incomplete. Modern array assignment follows 0xbc80: initial header/sentinel failure preserves the original, node failures retain a partial replacement and iteration continues, self-assignment replaces the header, and entries bind to the destination owner. Legacy assignment uses replacement list storage inside the existing header, following 0xb540. Value collection dispatch follows 0x1e40, changing type before invoking Array/Object assignment rather than cloning through their copy constructors. Local tests cover scalar array assignment, self-assignment and empty collection Value admission across destination types.

  • sce::Json::Value constructors and setters taking Array/Object - nested allocation failures and older SDK compatibility remain incomplete. These paths follow 0x1d00, 0x1d50, 0x1d90 and 0x1de0: a missing source header is ignored, while admitted inputs change the destination type before collection assignment. Missing-header construction initializes null ownership metadata without changing inactive payload bytes. Self-setting retains the Value handle and callback metadata while replacing collection storage. The setters expose no consistent status result and are declared void; local tests verify side effects rather than a fabricated success return.

  • sce::Json::Value nested array allocation regressions - local same-source tests cover every allocation point in copying and assigning an array containing a string, integer and inner array containing another string. Persistent and single-allocation failures preserve the observed null entries, empty strings, missing sentinels, parent links, error counts and actual owned cleanup. These checks do not complete nested object failure coverage, callback-return cloning failures, legacy SDK behavior or full guest execution.

  • sce::Json::Initializer resource admission - initialization follows 0x1340, 0xda0 and 0x940: a 24-byte allocation context owns the original allocator, user context and file-buffer setting; default handles/storage, a 32-byte fallback and kernel mutex handles are allocated before admission. Inner default failures can retain usable outer handles; required-resource failure reclaims ownership and leaves retry legal. SDK 6 uses two recursive kernel mutex handles, while the legacy path shares one. Local tests substitute the kernel boundary and cover all twelve SDK 6 allocation positions, partial admission and retry. Failed kernel mutex setup or locking throws rather than fabricating success; terminating from an active callback remains unsupported. These checks do not prove Linux/Windows integration or every reentrant/concurrent lifecycle.

  • sce::Json::Value legacy mismatch map - legacy special-float/element registration and libc allocation exceptions remain incomplete. Map registration, lookup, copying and destruction follow 0x3b00, 0x7230, 0x22b0, 0x1e40 and 0x1810: a parsed root must already own auxiliary metadata; a shared 24-byte map header uses the supplied allocator, while its sentinel and entries use libc new/delete. Copies propagate callback records independently of auxiliary ownership. Empty map storage survives until termination. Local SDK 5 tests cover replacement, null handlers, parent dispatch, null-recovery ordering, swap temporary cleanup, tree balance, erasure and both allocator domains. Failure to allocate the libc sentinel throws unsupported after reclaiming the unpublished header; reference exception unwinding is unverified.

  • sce::Json::Object nested allocation regressions - local tests cover 322 copy-construction and assignment cases for an object containing a string, inner object/string and array. Persistent and single-allocation failure budgets exercise every allocation position through successful completion (50 allocations for construction, 109 for assignment). Reference comparisons cover retained partial contents, collection counts, parent/owner links, request counts, notifications, unchanged source state and allocator cleanup. Construction may retain a source count larger than its admitted nodes and leave copied root entries unbound; tests preserve those observed semantics. Callback-bearing copies, alternate SDK behavior and concurrent failure accounting remain unverified.

  • sce::Json::Parser value admission - recognized values change type before root metadata admission, following 0x5d30 and 0x3280; incomplete scalar tokens allocate no auxiliary record. Twelve reference-backed string cases cover persistent and one-shot failure at every allocation position, retained type, error status, request/notification counts, character retries and cleanup. A failed character allocation can discard the first character while later characters are admitted. More complex parser low-memory paths, callback-driven allocation failures and child-metadata rebinding remain incomplete; reference execution terminated during one missing-sentinel array case, so that case does not establish a verified recovery contract.

  • sce::Json::Parser array allocation failures - numeric token storage uses the supplied allocator; array parsing uses the public append implementation. Parser and append operations share the depth/error flag observed at 0x6840, 0x310, 0x340 and 0xb880, retaining inherited errors until the outer operation finishes. Twenty-four reference-backed cases cover persistent and one-shot failures through successful parsing, partial counts, numeric-zero fallback after token-allocation failure, string suffixes, parent links, notifications and cleanup. Missing-sentinel parsing throws unsupported because reference execution crashes; callback-bearing collections and concurrent behavior remain incomplete.

  • sce::Json::Parser object allocation failures - object keys use one allocator-backed string reused between members, following 0x6250; lookup closes its shared operation scope before assigning the exposed key and owner, following 0xda40. Sixty-six reference-backed cases cover persistent and one-shot failure at each returning allocation position through a 33-allocation successful parse of an object containing a string and array. Checks include partial keys/members, numeric and string fallback values, parent links, error status, request/notification counts and complete allocator cleanup. The nested array sentinel failure is excluded because reference execution crashes; more complex nested objects, callback-driven allocation failures and concurrency remain unverified.

  • sce::Json::Collection inherited allocation errors - array assignment, object assignment/insertion and legacy mismatch-map updates now use the shared depth/error protocol instead of counter snapshots, following 0xbc80, 0xd400, 0xcd30 and 0x3b00. Six reference-backed public parser/read-callback cases invoke array assignment, object assignment or insertion after a one-shot character allocation failure, plus healthy controls. Checks cover placeholder retention, skipped payload binding, unchanged source, outer error persistence, recovery on the next independent parse and complete cleanup. Baseline and targeted assignment/insertion mutations fail these checks. Nested legacy map updates, callback-return cloning and cross-thread failure propagation remain unverified.

Unknown 3.20 import declarations

Reference in new issue View Git Blame Copy Permalink