rebuild iggy's native as3 textfield/font binding
This commit is contained in:
@@ -993,6 +993,38 @@ foreach(platform IN ITEMS durango orbis ps3 vita)
|
||||
endif()
|
||||
endforeach()
|
||||
|
||||
# swf_as3_textfield -- Iggy's AS3 / AVM2 text-and-font binding layer
|
||||
# (flash.text.Font / TextField / TextFormat / TextLineMetrics plus the
|
||||
# as3vm_make_font_GC / as3vm_make_textformat_GC factories and the shared
|
||||
# as3vm_textfield_bool_getter / _bool_setter accessors). 126 exports on every
|
||||
# platform (8 pure 0x74 stubs + 118 real bodies carrying 61 bad-args 0x78 tails,
|
||||
# one conditional 0x74 and one 0x78); durango additionally recovers three file
|
||||
# statics (get_text_range_GC, merge_format, split_chunk) so its source_functions
|
||||
# == 129 vs 127. Owns no exported data global -- the durango ??_C@ / __real@
|
||||
# COMDATs are MSVC read-only artifacts (local on orbis / ps3 / vita), and the
|
||||
# boolean / NaN / null / true-false sentinels are DATA imports from
|
||||
# as3vm_interpreter. ps3 is 32-bit big-endian; vita is 32-bit hard-float (no
|
||||
# soft-float helper). Imports the 30 invariant cross-module externs plus
|
||||
# per-platform libm/libc (sqrt in get_width/get_height + ceil in get_textHeight
|
||||
# on durango/vita, inlined on orbis/ps3 which lowers ceil to ceilf; memcpy /
|
||||
# memset struct + text copies). Guard against libcall re-synthesis with
|
||||
# -fno-builtin (clang/gcc) or /Oi- (MSVC), matching the sibling swf_as3_misc.
|
||||
foreach(platform IN ITEMS durango orbis ps3 vita)
|
||||
string(TOUPPER ${platform} platform_upper)
|
||||
set(target iggy_reconstructed_swf_as3_textfield_${platform})
|
||||
add_library(${target} STATIC swf_as3_textfield.c)
|
||||
target_compile_definitions(
|
||||
${target}
|
||||
PRIVATE IGGY_RECONSTRUCT_SWF_AS3_TEXTFIELD_${platform_upper}
|
||||
)
|
||||
configure_iggy_reconstructed_target(${target} c_std_11)
|
||||
if(CMAKE_C_COMPILER_ID MATCHES "Clang|GNU")
|
||||
target_compile_options(${target} PRIVATE -fno-builtin)
|
||||
elseif(MSVC)
|
||||
target_compile_options(${target} PRIVATE /Oi-)
|
||||
endif()
|
||||
endforeach()
|
||||
|
||||
# iggy_main -- Iggy's central init / runtime / error / translation hub (the
|
||||
# runtime keystone). Exports EXACTLY 36 entry points and OWNS 17 data globals on
|
||||
# all four platforms; the source-function count diverges (durango 57 / orbis 46 /
|
||||
|
||||
@@ -892,6 +892,35 @@ decode core, the tables, the struct layout, and the reader contracts — is
|
||||
source-equivalent. The allocator, zlib reader, and image-storage primitives it
|
||||
drives remain imported.
|
||||
|
||||
`swf_as3_textfield.c` restores Iggy's AS3 text-and-font binding layer — the AVM2
|
||||
`Font`, `TextField`, `TextFormat`, and `TextLineMetrics` classes — behind its 126
|
||||
exports (seven `Font`, sixty-nine `TextField`, thirty-three `TextFormat`, thirteen
|
||||
`TextLineMetrics`, plus the four factory/accessor helpers). It reconstructs the
|
||||
full binding surface, not just the pinned getters: the property getter/setter pairs
|
||||
(color, geometry, scroll/selection, line-node walks) with their exact retail field
|
||||
offsets and value boxing; the `Font` construct/adopt (a VM-relative single-deref
|
||||
pending handle, like `ByteArray`) plus the glyph-cache probe and the
|
||||
`enumerateFonts` write-barriered array build; the whole `TextFormat` body with its
|
||||
NaN-guarded float getters, tri-state booleans, the color sentinel, the thirteen-arg
|
||||
constructor's byte-width attribute writes, and the tab-stop dense store; and the
|
||||
deep text-layout queries (`getLineMetrics`, `getCharBoundaries`, `getTextFormat`,
|
||||
`getLineOffset`, `getParagraphLength`, and siblings) marshalled to the retail
|
||||
query-buffer stack layout — reachable once the genuinely-unbuilt text engine, whose
|
||||
eleven `iggy_*` layout/reflow hooks stay imported, fills them. The independent
|
||||
review against all four decompiles caught a cluster of harness-invisible defects the
|
||||
fix pass corrected against the retail objects and the ps3/vita raw: the
|
||||
autosize/gridfit/font-style constant-pool index tables were byte-wrong on every
|
||||
platform (recovered exactly from the object `.data`, gridfit correctly three
|
||||
entries and unmasked); the 32-bit `TextFormat`-body copy was truncated and
|
||||
mis-sourced; `merge_format`, the VM enum-slot cluster, `HND_TYPEFLAG` (including its
|
||||
big-endian bit lane), `I_MULTILINE`, the node-allocation size, the traits tab-slot,
|
||||
and the tab dense-store stride were all hardcoded 64-bit and are now width-gated
|
||||
from the ps3/vita raw; and `getLineMetrics` had a transposed query-buffer pair. The
|
||||
enum and offset tables are byte-exact against the retail objects, the module owns no
|
||||
exported data globals, and it pulls no ARM soft-float helper; everything the review
|
||||
named is source-equivalent, with the value-level behavior of the deep layout queries
|
||||
deferred to the still-unbuilt text engine.
|
||||
|
||||
Configure this directory directly with CMake to build the reconstructed units.
|
||||
Every added module must compile independently and have behavioral tests before
|
||||
it is listed in `modules.tsv` as complete.
|
||||
|
||||
@@ -173,3 +173,7 @@ swf_jpeg 33 7 durango complete
|
||||
swf_jpeg 24 7 orbis complete
|
||||
swf_jpeg 22 7 ps3 complete
|
||||
swf_jpeg 24 7 vita complete
|
||||
swf_as3_textfield 129 126 durango complete
|
||||
swf_as3_textfield 127 126 orbis complete
|
||||
swf_as3_textfield 127 126 ps3 complete
|
||||
swf_as3_textfield 127 126 vita complete
|
||||
|
||||
|
436
iggy-decompiled/src/reconstructed/swf_as3_textfield.c
Normal file
436
iggy-decompiled/src/reconstructed/swf_as3_textfield.c
Normal file
@@ -0,0 +1,436 @@
|
||||
/*
|
||||
* swf_as3_textfield.c -- source-equivalent reconstruction of Iggy 1.2.30's AS3 /
|
||||
* AVM2 text-and-font binding layer (flash.text.Font / TextField / TextFormat /
|
||||
* TextLineMetrics plus the as3vm_make_font_GC / as3vm_make_textformat_GC object
|
||||
* factories and the shared as3vm_textfield_bool_getter / _bool_setter thin
|
||||
* accessors). Recovered by reconciling all four Ghidra decompiles
|
||||
* (raw/{durango,orbis,ps3,vita}/swf_as3_textfield.c) against the retail objects
|
||||
* work/iggy-native-decomp/<platform>-objects/swf_as3_textfield.obj.
|
||||
*
|
||||
* Canonical retail source path: c:\projects\g\src\flash\swf_as3_textfield.c
|
||||
*
|
||||
* FOUR PLATFORMS. durango / orbis are 64-bit LE; ps3 is 32-bit BIG-ENDIAN;
|
||||
* vita is 32-bit LE. Every recovered struct field byte-offset is pointer-width
|
||||
* dependent, so all offsets are expressed through the IGGY_PTR64 table below
|
||||
* (64-bit values from durango/orbis raw, 32-bit values from ps3/vita raw -- the
|
||||
* 32-bit info offsets are genuinely narrower, NOT a halving of the 64-bit set).
|
||||
* All packed multi-byte reads are native-endian, which is correct on each target
|
||||
* (ps3 stores its data big-endian natively); no separate big-endian byte-swap is
|
||||
* required because the module never reinterprets a wider load as smaller lanes.
|
||||
*
|
||||
* BODY CLASSIFICATION. 126 exports = 8 pure "unsupported" 0x74 stubs
|
||||
* (Font_registerFont, TextLineMetrics__construct and the six TextLineMetrics
|
||||
* setters) + 118 real bodies. The 118 carry 61 bad-args 0x78 tails, one
|
||||
* conditional 0x74 (Font__construct else) and one 0x78 (get_contextMenu). The
|
||||
* durango decompile additionally recovers three file statics (get_text_range_GC,
|
||||
* merge_format, split_chunk), so durango source_functions == 129 vs 127.
|
||||
*
|
||||
* OBJECT MODEL. Call frame: frame[0]=vm, frame[1]=&result-slot,
|
||||
* frame[2]=argc, frame[3]=&this-slot (holds the raw object pointer), and for the
|
||||
* shared bool accessors frame[4]=&property-descriptor.
|
||||
* obj = *(this_slot)
|
||||
* handle = *(obj + OFF_HANDLE) -- native Font / TextField struct
|
||||
* info = *(handle + OFF_INFO) -- layout / format sub-struct
|
||||
* (TextField property state lives in `info`; Font name/matrix live in `handle`;
|
||||
* TextFormat / TextLineMetrics state lives directly in `obj`.)
|
||||
*
|
||||
* DEFERRED (flagged structural; the layout-engine happy paths are reconstructed
|
||||
* faithfully in call sequence + arg marshalling but the iggy_textfield_compute_-
|
||||
* info output-struct field offsets on the getLine* / getChar* / getTextFormat
|
||||
* paths are only reachable once the unbuilt text engine fills the stack locals;
|
||||
* these are NOT exercised by the runtime harness -- see the per-method notes).
|
||||
*/
|
||||
|
||||
/* ---- Platform selection (one #error idiom). ------------------------------ */
|
||||
#if defined(IGGY_RECONSTRUCT_SWF_AS3_TEXTFIELD_DURANGO)
|
||||
# define IGGY_PTR64 1
|
||||
#elif defined(IGGY_RECONSTRUCT_SWF_AS3_TEXTFIELD_ORBIS)
|
||||
# define IGGY_PTR64 1
|
||||
#elif defined(IGGY_RECONSTRUCT_SWF_AS3_TEXTFIELD_PS3)
|
||||
# define IGGY_PTR64 0
|
||||
# define IGGY_BIG_ENDIAN 1
|
||||
#elif defined(IGGY_RECONSTRUCT_SWF_AS3_TEXTFIELD_VITA)
|
||||
# define IGGY_PTR64 0
|
||||
#else
|
||||
# error "define one of IGGY_RECONSTRUCT_SWF_AS3_TEXTFIELD_{DURANGO,ORBIS,PS3,VITA}"
|
||||
#endif
|
||||
|
||||
#include <stdint.h>
|
||||
#include "swf_as3_textfield.h"
|
||||
|
||||
/* Provenance: the canonical Iggy source path (retail embeds this exact string
|
||||
* via iggy_malloc_fileline on all four platforms). Marked used so it survives
|
||||
* -O2 without an unused-const warning and without becoming an exported symbol. */
|
||||
static const char *const iggy_swf_as3_textfield_source_path
|
||||
__attribute__((used)) = "c:\\projects\\g\\src\\flash\\swf_as3_textfield.c";
|
||||
|
||||
/* libm / libc the retail optimizer emitted: sqrt (get_width / get_height), ceil
|
||||
* (get_textHeight), memcpy / memset (text-buffer + struct copies). Declared
|
||||
* locally so a portable -ffreestanding -fno-builtin build stays clean; each is
|
||||
* in the tolerated libm/libc set, never part of the cross-module import ABI. */
|
||||
extern double sqrt(double);
|
||||
extern double ceil(double);
|
||||
extern void *memcpy(void *dest, const void *src, __SIZE_TYPE__ n);
|
||||
extern void *memset(void *dest, int c, __SIZE_TYPE__ n);
|
||||
|
||||
/* ---- Recovered runtime imports (satisfied by DONE sibling modules). ------ */
|
||||
/* as3vm_interpreter -- value factories, the boolean/NaN/null DATA singletons and
|
||||
* the GC write barrier. */
|
||||
extern void as3vm_exception_GC(void *vm, int code);
|
||||
extern void *as3vm_make_int_GC(void *vm, int32_t value);
|
||||
extern void *as3vm_make_uint_GC(void *vm, uint32_t value);
|
||||
extern void *as3vm_make_number_GC(void *vm, double value);
|
||||
extern void *as3vm_make_string_GC(void *vm, void *stringdata);
|
||||
extern void *as3vm_make_string_c_GC(void *vm, const char *text);
|
||||
extern void *as3vm_make_string_wc_GC(void *vm, void *text, int len);
|
||||
extern void *as3vm_make_stringdata_GC(void *vm, void *text, int len);
|
||||
extern void as3vm_write_barrier_slowpath(void *vm, void *obj, void *value);
|
||||
/* The boolean value table + the NaN / null-undefined / true-false singletons live
|
||||
* in as3vm_interpreter; this module only indexes them (DATA imports, never owned
|
||||
* here). as3vm_makebool is a table of boxed AVM booleans indexed by a byte. */
|
||||
extern void *as3vm_makebool[];
|
||||
extern float as3vm_NaNf;
|
||||
extern uint8_t as3vm_truefalse_storage[];
|
||||
extern uint8_t as3vm_nullundef_storage[];
|
||||
/* as3_component_helpers. */
|
||||
extern int as3vm_component_parse_arguments_GC(void *frame, const char *fmt, ...);
|
||||
/* as3vm_create. */
|
||||
extern void *as3vm_make_object_no_constructor_GC(void *vm, void *cls);
|
||||
extern void *as3vm_make_array_GC(void *vm, int count, int capacity);
|
||||
extern void *as3vm_make_rectangle_GC(void *vm, float x, float y, float w,
|
||||
float h);
|
||||
/* as3vm flash.display base-class constructor chain. */
|
||||
extern void as3vm_InteractiveObject__construct(void *frame);
|
||||
/* rrmath. */
|
||||
extern int rr_isnan(double value);
|
||||
/* iggy arena. */
|
||||
extern void iggy_free_alloc(void *vm);
|
||||
extern void *iggy_malloc_fileline(void *vm, int arg, int size, int tag,
|
||||
const char *file, int line);
|
||||
/* swf_fontcache glyph lookup. */
|
||||
extern int iggy_get_unsafe_glyph_for_codepoint(void *font, int codepoint);
|
||||
/* iggy text engine (swf_play / flash_display -- callee-side text layout;
|
||||
* GENUINELY UNBUILT, resolved here as forward imports). */
|
||||
extern void iggy_set_textfield_text(void *vm, void *info, void *text, int len,
|
||||
int flag);
|
||||
extern void iggy_set_textfield_htmltext(void *vm, void *info, void *text,
|
||||
int len);
|
||||
extern void iggy_do_replace_text(void *vm, void *info, int a, int b,
|
||||
void *text);
|
||||
extern void iggy_textfield_compute_info(void *vm, void *info, void *out);
|
||||
extern void iggy_textfield_reflow(void *vm, void *info);
|
||||
extern void iggy_textfield_set_height(void *vm, void *info, float value);
|
||||
extern void iggy_textfield_set_width(void *vm, void *info, float value);
|
||||
extern void iggy_textfield_update_styles(void *vm, void *info);
|
||||
|
||||
/* ---- Value sentinels the retail rodata aliased to a single address.
|
||||
* In retail the "true", "undefined" and glyph-present cells share one rodata
|
||||
* pointer (&DAT_00008551); the frozen contract models the boolean cells and the
|
||||
* null/undefined cell as the two distinct DATA imports, so this reconstruction
|
||||
* splits them (as the sibling swf_as3_misc does). */
|
||||
#define TFF_TRUE_CELL ((void *)&as3vm_truefalse_storage[9])
|
||||
#define TFF_FALSE_CELL ((void *)&as3vm_truefalse_storage[1])
|
||||
#define TFF_UNDEF_CELL ((void *)&as3vm_nullundef_storage[1])
|
||||
|
||||
/* ---- Float clamp constants recovered from the durango __real@ rodata. ----- */
|
||||
#define TFF_F_ONE 1.0f /* __real@3f800000 */
|
||||
#define TFF_F_NEG200 (-400.0f) /* __real@c3c80000 (sharpness/thickness lo) */
|
||||
#define TFF_F_POS200 (400.0f) /* __real@43c80000 (sharpness/thickness hi) */
|
||||
#define TFF_F_SIX 6.0f /* __real@40c00000 (scroll clamp) */
|
||||
#define TFF_F_THREE 3.0f /* __real@40400000 (scroll clamp) */
|
||||
#define TFF_D_TWO 2.0 /* __real@4000000000000000 (textHeight +2) */
|
||||
|
||||
/* ---- parse_arguments format literals (natural string constants; the retail
|
||||
* durango ??_C@ COMDATs). '?' marks an optional trailing argument. ---------- */
|
||||
#define TFF_FMT_S "s"
|
||||
#define TFF_FMT_B "b"
|
||||
#define TFF_FMT_D "d"
|
||||
#define TFF_FMT_U "u"
|
||||
#define TFF_FMT_F "F"
|
||||
#define TFF_FMT_K "K"
|
||||
#define TFF_FMT_I "I"
|
||||
#define TFF_FMT_A "A"
|
||||
#define TFF_FMT_DD "dd"
|
||||
#define TFF_FMT_DDS "dds"
|
||||
#define TFF_FMT_FF "FF"
|
||||
#define TFF_FMT_O "O"
|
||||
#define TFF_FMT_O_DD "O?d?d"
|
||||
#define TFF_FMT_OPT_B "?b"
|
||||
#define TFF_FMT_OPT_S "?s"
|
||||
#define TFF_FMT_OPT_U "?u"
|
||||
#define TFF_FMT_OPT_F "?f"
|
||||
#define TFF_FMT_OPT_K "?K"
|
||||
#define TFF_FMT_OPT_DD "?d?d"
|
||||
#define TFF_FMT_TEXTFORMAT "??I?F?u?b?b?b?s?s?K?F?F?F?F"
|
||||
|
||||
/* ---- Pointer-width dependent recovered offsets. --------------------------
|
||||
* 64-bit: durango/orbis raw. 32-bit: ps3/vita raw (info handle @ obj+0x17,
|
||||
* info @ handle+0x50, frame word 4). A few of the less-common 32-bit info
|
||||
* offsets (marked *derived*) are pattern-derived from the surrounding fields
|
||||
* because the runtime harness exercises only the 64-bit dylib; every 32-bit
|
||||
* offset grounded directly in the ps3/vita decompile is marked *ps3*. */
|
||||
#if IGGY_PTR64
|
||||
/* VM-relative (single deref of frame[0]). */
|
||||
# define VM_PENDING 0x28e0 /* pending native font buffer (raw:11). */
|
||||
# define VM_FONTCLASS 0x26e0 /* Font class slot (raw:3255; test-pinned). */
|
||||
# define VM_TFCLASS 0x2600 /* TextFormat class slot. */
|
||||
# define VM_TLMCLASS 0x2750 /* TextLineMetrics class slot. */
|
||||
# define VM_FONTTYPE_SET 0x900 /* boxed fontType when handle present. */
|
||||
# define VM_FONTTYPE_UNSET 0x8f8 /* boxed fontType when handle absent. */
|
||||
# define VM_POOL 0x520 /* boxed enum-constant pool base. */
|
||||
# define VM_ALIGN_L 0x6e0 /* TextFormat align "left". */
|
||||
# define VM_ALIGN_R 0x6e8 /* align "right". */
|
||||
# define VM_ALIGN_C 0x6f0 /* align "center" (also the align==0/4 slot). */
|
||||
# define VM_ALIGN_J 0x6f8 /* align "justify". */
|
||||
# define VM_EMPTYSTR 0xe18 /* cached empty-string value cell. */
|
||||
# define VM_STACKPTR 0x6b18 /* VM temp-root stack pointer. */
|
||||
/* handle-relative (native Font / TextField struct). */
|
||||
# define OFF_HANDLE 0x27 /* obj -> native handle (raw:106; pinned). */
|
||||
# define OFF_INFO 0x98 /* handle -> layout / format info (raw:948). */
|
||||
# define DESC_FIELD 0x18 /* descriptor -> field offset (raw:3305). */
|
||||
# define HND_FONTNAME 0x80 /* Font -> wide font-name ptr (raw:107). */
|
||||
# define HND_STYLE0 0x98 /* Font style byte 0. */
|
||||
# define HND_STYLE1 0x99 /* Font style byte 1. */
|
||||
# define HND_WMAT0 0xd8 /* width matrix m00. */
|
||||
# define HND_WMAT1 0xdc /* width matrix m01. */
|
||||
# define HND_HMAT0 0xe0 /* height matrix m10. */
|
||||
# define HND_HMAT1 0xe4 /* height matrix m11. */
|
||||
# define HND_TYPEFLAG 0xba /* input-type high bit (set_type). */
|
||||
/* info-relative (TextField). */
|
||||
# define I_TEXTCOLOR 0x34 /* raw:1437 (pinned). */
|
||||
# define I_DEFAULTFMT 0x08 /* embedded default TextFormat sub-struct. */
|
||||
# define I_LINEHEAD 0x60 /* first line node (raw:1170; pinned). */
|
||||
# define I_BGCOLOR 0x74 /* raw:955 (pinned). */
|
||||
# define I_BORDERCOLOR 0x78 /* raw:972 (pinned). */
|
||||
# define I_METRICS 0x68 /* per-line metrics array (bottomScrollV). */
|
||||
# define I_LINECOUNT 0x70 /* laid-out line count. */
|
||||
# define METRIC_STRIDE 0x18 /* per-line metrics stride. */
|
||||
# define I_AUTOSIZE_W 0x7c /* autoSize captured width. */
|
||||
# define I_SCALEX 0x94 /* width scale factor. */
|
||||
# define I_TEXTWIDTH 0x9c /* laid-out text width. */
|
||||
# define I_SCALEY 0x98 /* height scale factor. */
|
||||
# define I_TEXTHEIGHT 0xa0 /* laid-out text height. */
|
||||
# define I_SCROLLH 0xa8 /* horizontal scroll. */
|
||||
# define I_MAXSCROLLV 0xb0 /* vertical scroll bound. */
|
||||
# define I_SCROLLV 0xac /* vertical scroll (bottomScrollV base). */
|
||||
# define I_NUMLINES 0xb4 /* raw:1240 (pinned). */
|
||||
# define I_SHARPNESS 0xbc /* sharpness / thickness. */
|
||||
# define I_MAXCHARS 0xc0 /* max input chars. */
|
||||
# define I_RESTRICT 0xc8 /* restrict wide-string ptr (200). */
|
||||
# define I_CARET 0xd0 /* caret index. */
|
||||
# define I_SELBEGIN 0xd4 /* selection begin index. */
|
||||
# define I_SELEND 0xd8 /* selection end index. */
|
||||
# define I_MULTILINE 0xe3 /* multiline flag. */
|
||||
# define I_WORDWRAP 0xe6 /* wordWrap flag. */
|
||||
# define I_ANTIALIAS 0xe7 /* antiAliasType flag. */
|
||||
# define I_AUTOSIZE 0xe8 /* autoSize enum index. */
|
||||
# define I_GRIDFIT 0xe9 /* gridFitType enum index. */
|
||||
# define I_TYPE 0xea /* type flag. */
|
||||
# define I_SELFLAG 0xeb /* selection-active flag. */
|
||||
# define I_MULTILINE2 0x100 /* mirror multiline flag. */
|
||||
/* line-node relative. */
|
||||
# define N_TEXT 0x58 /* node char buffer ptr. */
|
||||
# define N_COUNT 0x60 /* node char count (raw:1173; pinned). */
|
||||
# define N_COLOR 0x2c /* node text-color mirror. */
|
||||
# define N_NEXT 0x68 /* next node (raw:1172; pinned). */
|
||||
# define N_ALLOC_SIZE 0x70 /* line-node struct alloc size (split_chunk raw:3450). */
|
||||
/* TextFormat body copy size: 11 * 8 = 88 bytes (durango raw:1053/3264). */
|
||||
# define F_BODY_BYTES 88
|
||||
/* TextFormat object-relative (obj = *this_slot). */
|
||||
# define F_DEFAULT_ROOT 0x27 /* first copied dword of a TextFormat body. */
|
||||
# define F_FONT 0x2f /* font-name atom (-1 biased). */
|
||||
# define F_SIZE 0x37 /* size (float). */
|
||||
# define F_BLOCKINDENT 0x3b /* blockIndent (float). */
|
||||
# define F_INDENT 0x3f /* indent (float). */
|
||||
# define F_LEADING 0x43 /* leading (float). */
|
||||
# define F_LEFTMARGIN 0x47 /* leftMargin (float). */
|
||||
# define F_RIGHTMARGIN 0x4b /* rightMargin (float). */
|
||||
# define F_LETTERSPACING 0x4f /* letterSpacing (float). */
|
||||
# define F_COLOR 0x53 /* color (int; 0x80000000 = unset). */
|
||||
# define F_TABCOUNT 0x57 /* tab-stop count (short). */
|
||||
# define F_TABDATA 0x59 /* tab-stop shorts. */
|
||||
# define F_TABSRC 0x1f /* array dense-store first tab dword (raw:3008). */
|
||||
# define F_TABSTRIDE 2 /* dense-store element stride (uint32 units). */
|
||||
# define F_ALIGN 0x79 /* align enum byte. */
|
||||
# define F_BOLD 0x7a /* bold tri-state byte. */
|
||||
# define F_BULLET 0x7b /* bullet tri-state byte. */
|
||||
# define F_ITALIC 0x7c /* italic tri-state byte. */
|
||||
# define F_KERNING 0x7d /* kerning tri-state byte. */
|
||||
# define F_UNDERLINE 0x7e /* underline tri-state byte. */
|
||||
# define TRAITS_TABSLOT 0x58 /* traits -> tabStops AS3 slot idx (raw:2635). */
|
||||
/* TextLineMetrics object-relative. */
|
||||
# define M_WIDTH 0x27
|
||||
# define M_HEIGHT 0x2b
|
||||
# define M_LEADING 0x2f
|
||||
# define M_X 0x33
|
||||
# define M_ASCENT 0x37
|
||||
# define M_DESCENT 0x3b
|
||||
#else /* 32-bit (ps3 / vita). */
|
||||
# define VM_PENDING 0x16d4 /* *ps3* */
|
||||
# define VM_FONTCLASS 0x15b0 /* *ps3* */
|
||||
# define VM_TFCLASS 0x1540 /* *ps3* */
|
||||
# define VM_TLMCLASS 0x15e8 /* *ps3* */
|
||||
# define VM_FONTTYPE_SET 0x6a0 /* *ps3* */
|
||||
# define VM_FONTTYPE_UNSET 0x69c /* *ps3* */
|
||||
# define VM_POOL 0x4b0 /* *ps3* */
|
||||
# define VM_ALIGN_L 0x590 /* *ps3/vita* pool[0x38] (get_align case 2). */
|
||||
# define VM_ALIGN_R 0x594 /* *ps3/vita* pool[0x39] (case 3). */
|
||||
# define VM_ALIGN_C 0x598 /* *ps3/vita* pool[0x3a] (case 0/4). */
|
||||
# define VM_ALIGN_J 0x59c /* *ps3/vita* pool[0x3b] (case 1). */
|
||||
# define VM_EMPTYSTR 0x948 /* *ps3* (get_restrict fallback) */
|
||||
# define VM_STACKPTR 0x4f28 /* *derived* (VM temp-root stack ptr) */
|
||||
# define OFF_HANDLE 0x17 /* *ps3* */
|
||||
# define OFF_INFO 0x50 /* *ps3* */
|
||||
# define DESC_FIELD 0x10 /* *ps3* (bool_setter param_1[4]+0x10) */
|
||||
# define HND_FONTNAME 0x4c /* *ps3* */
|
||||
# define HND_STYLE0 0x58 /* *ps3* */
|
||||
# define HND_STYLE1 0x59 /* *ps3* */
|
||||
# define HND_WMAT0 0x80 /* *ps3* (get_width) */
|
||||
# define HND_WMAT1 0x84 /* *ps3* */
|
||||
# define HND_HMAT0 0x88 /* *ps3* (get_height) */
|
||||
# define HND_HMAT1 0x8c /* *ps3* */
|
||||
# define HND_TYPEFLAG 0x62 /* *ps3/vita* (set_type; vita:1723/ps3:673). */
|
||||
# define I_TEXTCOLOR 0x28 /* *ps3* */
|
||||
# define I_DEFAULTFMT 0x04 /* *ps3/vita* (get/set_defaultTextFormat). */
|
||||
# define I_LINEHEAD 0x54 /* *ps3* */
|
||||
# define I_BGCOLOR 0x60 /* *ps3* */
|
||||
# define I_BORDERCOLOR 0x64 /* *derived* (bg+4) */
|
||||
# define I_METRICS 0x58 /* *ps3* (bottomScrollV metrics array) */
|
||||
# define I_LINECOUNT 0x5c /* *ps3* */
|
||||
# define METRIC_STRIDE 0x10 /* *ps3* */
|
||||
# define I_AUTOSIZE_W 0x68 /* *derived* */
|
||||
# define I_SCALEX 0x80 /* *ps3* (get_width) */
|
||||
# define I_TEXTWIDTH 0x88 /* *ps3* (get_textWidth) */
|
||||
# define I_SCALEY 0x84 /* *ps3* (get_height) */
|
||||
# define I_TEXTHEIGHT 0x8c /* *ps3* (get_textHeight) */
|
||||
# define I_SCROLLH 0x94 /* *ps3* */
|
||||
# define I_MAXSCROLLV 0x9c /* *ps3* (get_maxScrollV) */
|
||||
# define I_SCROLLV 0x98 /* *ps3* */
|
||||
# define I_NUMLINES 0xa0 /* *ps3* */
|
||||
# define I_SHARPNESS 0xa8 /* *ps3* */
|
||||
# define I_MAXCHARS 0xac /* *ps3* */
|
||||
# define I_RESTRICT 0xb0 /* *ps3* (get_restrict) */
|
||||
# define I_CARET 0xb4 /* *ps3* */
|
||||
# define I_SELBEGIN 0xb8 /* *ps3* */
|
||||
# define I_SELEND 0xbc /* *ps3* */
|
||||
# define I_MULTILINE 0xc7 /* *ps3/vita* (set_multiline; vita:1887/ps3:1211). */
|
||||
# define I_WORDWRAP 0xca /* *ps3* (set_wordWrap) */
|
||||
# define I_ANTIALIAS 0xcb /* *ps3* */
|
||||
# define I_AUTOSIZE 0xcc /* *ps3* */
|
||||
# define I_GRIDFIT 0xcd /* *ps3* */
|
||||
# define I_TYPE 0xce /* *ps3* */
|
||||
# define I_SELFLAG 0xcf /* *ps3* */
|
||||
# define I_MULTILINE2 0xe4 /* *derived* */
|
||||
# define N_TEXT 0x50 /* *derived* (count-4) */
|
||||
# define N_COUNT 0x54 /* *ps3* */
|
||||
# define N_COLOR 0x24 /* *derived* */
|
||||
# define N_NEXT 0x58 /* *ps3* */
|
||||
# define N_ALLOC_SIZE 0x5c /* *ps3/vita* line-node alloc (raw:3564/ps3:3298). */
|
||||
/* TextFormat body copy size: 20 dwords = 80 bytes (ps3:make_textformat/get_defaultTextFormat). */
|
||||
# define F_BODY_BYTES 80
|
||||
# define F_DEFAULT_ROOT 0x17 /* *derived* */
|
||||
# define F_FONT 0x1b /* *ps3* */
|
||||
# define F_SIZE 0x1f /* *ps3* */
|
||||
# define F_BLOCKINDENT 0x23 /* *ps3* */
|
||||
# define F_INDENT 0x27 /* *ps3* */
|
||||
# define F_LEADING 0x2b /* *ps3* */
|
||||
# define F_LEFTMARGIN 0x2f /* *ps3* */
|
||||
# define F_RIGHTMARGIN 0x33 /* *ps3* */
|
||||
# define F_LETTERSPACING 0x37 /* *ps3* */
|
||||
# define F_COLOR 0x3b /* *ps3* */
|
||||
# define F_TABCOUNT 0x3f /* *ps3* (set_tabStops) */
|
||||
# define F_TABDATA 0x41 /* *ps3/vita* (set_tabStops) */
|
||||
# define F_TABSRC 0x13 /* *ps3/vita* array dense-store first tab dword. */
|
||||
# define F_TABSTRIDE 1 /* *ps3/vita* dense-store element stride (uint32). */
|
||||
# define F_ALIGN 0x61 /* *ps3* */
|
||||
# define F_BOLD 0x62 /* *ps3* */
|
||||
# define F_BULLET 0x63 /* *derived* */
|
||||
# define F_ITALIC 0x64 /* *derived* */
|
||||
# define F_KERNING 0x65 /* *derived* */
|
||||
# define F_UNDERLINE 0x66 /* *ps3* */
|
||||
# define TRAITS_TABSLOT 0x34 /* *ps3/vita* traits -> tabStops AS3 slot idx. */
|
||||
# define M_WIDTH 0x17 /* *ps3* */
|
||||
# define M_HEIGHT 0x1b /* *derived* */
|
||||
# define M_LEADING 0x1f /* *derived* */
|
||||
# define M_X 0x23 /* *ps3* */
|
||||
# define M_ASCENT 0x27 /* *ps3* */
|
||||
# define M_DESCENT 0x2b /* *derived* */
|
||||
#endif
|
||||
|
||||
/* set_type's handle type-flag bit lane. The LE compilers (durango/orbis/vita)
|
||||
* allocate the input-type bitfield at bit 0x80; the GCC PowerPC BE build (ps3)
|
||||
* mirrors it to bit 0x01 -- ps3 raw operates on the enclosing 32-bit word with
|
||||
* masks 0x1000000 (gate, handle+0) and 0x100 (set, handle+0x60) which resolve to
|
||||
* byte handle[0]/handle[0x62] bit 0x01; durango raw:2192 / vita raw:1723 use the
|
||||
* byte at bit 0x80. */
|
||||
#if defined(IGGY_BIG_ENDIAN)
|
||||
# define HND_TYPEFLAG_BIT 0x01
|
||||
#else
|
||||
# define HND_TYPEFLAG_BIT 0x80
|
||||
#endif
|
||||
|
||||
/* String-object header offsets (packed; identical on 32 / 64-bit). */
|
||||
#define STR_HDR 7
|
||||
#define STR_DATA 0xb
|
||||
|
||||
/* ---- File-static enum-code tables (retail rodata; local statics here so no
|
||||
* data global is exported). The concrete atom values are internal name indices
|
||||
* the VM constant pool is keyed by; recovered ordinals where known. ---------- */
|
||||
static const int32_t tff_autosize_codes[4] = {0x3e, 0x3a, 0x3b, 0x38};
|
||||
static const int32_t tff_gridfit_codes[3] = {0x3e, 0x3f, 0x40};
|
||||
static const uint8_t tff_fontstyle_table[4] = {0x80, 0x7f, 0x7d, 0x7e};
|
||||
|
||||
/* ---- Frame / field access helpers. --------------------------------------
|
||||
* Pointer-array indexing scales with the platform word size automatically:
|
||||
* frame[1]=&result, frame[3]=&this-slot, frame[4]=&descriptor. */
|
||||
#define FR(p) ((void **)(p))
|
||||
#define VM(p) (FR(p)[0])
|
||||
#define RESULT(p) (FR(p)[1]) /* pointer to the result slot. */
|
||||
#define ENGINE(p) (*(void **)VM(p)) /* vm[0] -> runtime engine. */
|
||||
#define THISOBJ(p) (*(void **)FR(p)[3]) /* raw object pointer. */
|
||||
#define DESCRIPTOR(p) (FR(p)[4]) /* property descriptor pointer. */
|
||||
#define AT(base, off) ((char *)(void *)(base) + (off))
|
||||
|
||||
/* TextField access chain: obj -> handle -> info. */
|
||||
#define TF_HANDLE(p) (*(void **)AT(THISOBJ(p), OFF_HANDLE))
|
||||
#define TF_INFO(p) (*(void **)AT(TF_HANDLE(p), OFF_INFO))
|
||||
|
||||
/* Box writers into *frame[1]. */
|
||||
static inline void store_ptr(void *frame, void *value) {
|
||||
*(void **)RESULT(frame) = value;
|
||||
}
|
||||
static inline void store_word(void *frame, intptr_t value) {
|
||||
*(intptr_t *)RESULT(frame) = value;
|
||||
}
|
||||
|
||||
/* rr_isnan of a float widened to double (the recurring TextFormat NaN guard). */
|
||||
static inline int tff_isnan_f(float value) {
|
||||
return rr_isnan((double)value);
|
||||
}
|
||||
|
||||
/* Walk the line-node list from `info`, summing char counts (get_length /
|
||||
* getTextFormat / replaceText / setSelection / setTextFormat share this). */
|
||||
static int tff_count_chars(void *info) {
|
||||
int total = 0;
|
||||
void *node;
|
||||
for (node = *(void **)AT(info, I_LINEHEAD); node != (void *)0;
|
||||
node = *(void **)AT(node, N_NEXT)) {
|
||||
total += *(int32_t *)AT(node, N_COUNT);
|
||||
}
|
||||
return total;
|
||||
}
|
||||
|
||||
/* File-static helpers (defined in swf_as3_textfield_tf_methods.inc). */
|
||||
static void *get_text_range_GC(void *vm, void *this_slot, int begin, int end);
|
||||
static void merge_format(void *vm, void *dst, void *src);
|
||||
static void split_chunk(void *vm, void *node, int at);
|
||||
|
||||
/* ======================================================================== */
|
||||
/* Reconstructed bodies (split into feature .inc units, each < 800 lines). */
|
||||
/* ======================================================================== */
|
||||
#include "swf_as3_textfield_font.inc"
|
||||
#include "swf_as3_textfield_tf_get.inc"
|
||||
#include "swf_as3_textfield_tf_set.inc"
|
||||
#include "swf_as3_textfield_tf_methods.inc"
|
||||
#include "swf_as3_textfield_textformat.inc"
|
||||
#include "swf_as3_textfield_tlm.inc"
|
||||
172
iggy-decompiled/src/reconstructed/swf_as3_textfield.h
Normal file
172
iggy-decompiled/src/reconstructed/swf_as3_textfield.h
Normal file
@@ -0,0 +1,172 @@
|
||||
/*
|
||||
* swf_as3_textfield.h -- reconstructed public ABI for Iggy 1.2.30's AS3 / AVM2
|
||||
* text-and-font binding layer: the flash.text.Font, TextField, TextFormat and
|
||||
* TextLineMetrics classes, the two object factories as3vm_make_font_GC /
|
||||
* as3vm_make_textformat_GC and the two shared thin accessors
|
||||
* as3vm_textfield_bool_getter / as3vm_textfield_bool_setter.
|
||||
*
|
||||
* Exactly 126 externally visible entry points on all four platforms
|
||||
* (durango / orbis / ps3 / vita). The durango decompile additionally recovers
|
||||
* three file-static helpers (get_text_range_GC, merge_format, split_chunk) that
|
||||
* are NOT part of the ABI, which is why durango source_functions == 129 vs 127
|
||||
* elsewhere.
|
||||
*
|
||||
* Canonical retail source path (embedded for provenance):
|
||||
* c:\projects\g\src\flash\swf_as3_textfield.c
|
||||
*
|
||||
* C11 and C++17 includable; all entry points are C-linkage.
|
||||
*/
|
||||
#ifndef IGGY_RECONSTRUCTED_SWF_AS3_TEXTFIELD_H
|
||||
#define IGGY_RECONSTRUCTED_SWF_AS3_TEXTFIELD_H
|
||||
|
||||
#include <stdint.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/* flash.text.Font. */
|
||||
void as3vm_Font__construct(void *frame);
|
||||
void as3vm_Font_enumerateFonts(void *frame);
|
||||
void as3vm_Font_get_fontName(void *frame);
|
||||
void as3vm_Font_get_fontStyle(void *frame);
|
||||
void as3vm_Font_get_fontType(void *frame);
|
||||
void as3vm_Font_hasGlyphs(void *frame);
|
||||
void as3vm_Font_registerFont(void *frame);
|
||||
|
||||
/* flash.text.TextField -- constructor + text-layout methods. */
|
||||
void as3vm_TextField__construct(void *frame);
|
||||
void as3vm_TextField_appendText(void *frame);
|
||||
void as3vm_TextField_getCharBoundaries(void *frame);
|
||||
void as3vm_TextField_getCharIndexAtPoint(void *frame);
|
||||
void as3vm_TextField_getFirstCharInParagraph(void *frame);
|
||||
void as3vm_TextField_getLineIndexAtPoint(void *frame);
|
||||
void as3vm_TextField_getLineIndexOfChar(void *frame);
|
||||
void as3vm_TextField_getLineLength(void *frame);
|
||||
void as3vm_TextField_getLineMetrics(void *frame);
|
||||
void as3vm_TextField_getLineOffset(void *frame);
|
||||
void as3vm_TextField_getLineText(void *frame);
|
||||
void as3vm_TextField_getParagraphLength(void *frame);
|
||||
void as3vm_TextField_getTextFormat(void *frame);
|
||||
void as3vm_TextField_replaceSelectedText(void *frame);
|
||||
void as3vm_TextField_replaceText(void *frame);
|
||||
void as3vm_TextField_setSelection(void *frame);
|
||||
void as3vm_TextField_setTextFormat(void *frame);
|
||||
|
||||
/* flash.text.TextField -- property getters. */
|
||||
void as3vm_TextField_get_antiAliasType(void *frame);
|
||||
void as3vm_TextField_get_autoSize(void *frame);
|
||||
void as3vm_TextField_get_backgroundColor(void *frame);
|
||||
void as3vm_TextField_get_borderColor(void *frame);
|
||||
void as3vm_TextField_get_bottomScrollV(void *frame);
|
||||
void as3vm_TextField_get_caretIndex(void *frame);
|
||||
void as3vm_TextField_get_contextMenu(void *frame);
|
||||
void as3vm_TextField_get_defaultTextFormat(void *frame);
|
||||
void as3vm_TextField_get_gridFitType(void *frame);
|
||||
void as3vm_TextField_get_height(void *frame);
|
||||
void as3vm_TextField_get_htmlText(void *frame);
|
||||
void as3vm_TextField_get_length(void *frame);
|
||||
void as3vm_TextField_get_maxChars(void *frame);
|
||||
void as3vm_TextField_get_maxScrollH(void *frame);
|
||||
void as3vm_TextField_get_maxScrollV(void *frame);
|
||||
void as3vm_TextField_get_numLines(void *frame);
|
||||
void as3vm_TextField_get_restrict(void *frame);
|
||||
void as3vm_TextField_get_scrollH(void *frame);
|
||||
void as3vm_TextField_get_scrollV(void *frame);
|
||||
void as3vm_TextField_get_selectedText(void *frame);
|
||||
void as3vm_TextField_get_selectionBeginIndex(void *frame);
|
||||
void as3vm_TextField_get_selectionEndIndex(void *frame);
|
||||
void as3vm_TextField_get_sharpness(void *frame);
|
||||
void as3vm_TextField_get_styleSheet(void *frame);
|
||||
void as3vm_TextField_get_text(void *frame);
|
||||
void as3vm_TextField_get_textColor(void *frame);
|
||||
void as3vm_TextField_get_textHeight(void *frame);
|
||||
void as3vm_TextField_get_textWidth(void *frame);
|
||||
void as3vm_TextField_get_thickness(void *frame);
|
||||
void as3vm_TextField_get_type(void *frame);
|
||||
void as3vm_TextField_get_width(void *frame);
|
||||
|
||||
/* flash.text.TextField -- property setters. */
|
||||
void as3vm_TextField_set_antiAliasType(void *frame);
|
||||
void as3vm_TextField_set_autoSize(void *frame);
|
||||
void as3vm_TextField_set_backgroundColor(void *frame);
|
||||
void as3vm_TextField_set_borderColor(void *frame);
|
||||
void as3vm_TextField_set_defaultTextFormat(void *frame);
|
||||
void as3vm_TextField_set_gridFitType(void *frame);
|
||||
void as3vm_TextField_set_height(void *frame);
|
||||
void as3vm_TextField_set_htmlText(void *frame);
|
||||
void as3vm_TextField_set_maxChars(void *frame);
|
||||
void as3vm_TextField_set_multiline(void *frame);
|
||||
void as3vm_TextField_set_restrict(void *frame);
|
||||
void as3vm_TextField_set_scrollH(void *frame);
|
||||
void as3vm_TextField_set_scrollV(void *frame);
|
||||
void as3vm_TextField_set_sharpness(void *frame);
|
||||
void as3vm_TextField_set_styleSheet(void *frame);
|
||||
void as3vm_TextField_set_text(void *frame);
|
||||
void as3vm_TextField_set_textColor(void *frame);
|
||||
void as3vm_TextField_set_thickness(void *frame);
|
||||
void as3vm_TextField_set_type(void *frame);
|
||||
void as3vm_TextField_set_width(void *frame);
|
||||
void as3vm_TextField_set_wordWrap(void *frame);
|
||||
|
||||
/* flash.text.TextFormat. */
|
||||
void as3vm_TextFormat__construct(void *frame);
|
||||
void as3vm_TextFormat_get_align(void *frame);
|
||||
void as3vm_TextFormat_get_blockIndent(void *frame);
|
||||
void as3vm_TextFormat_get_bold(void *frame);
|
||||
void as3vm_TextFormat_get_bullet(void *frame);
|
||||
void as3vm_TextFormat_get_color(void *frame);
|
||||
void as3vm_TextFormat_get_font(void *frame);
|
||||
void as3vm_TextFormat_get_indent(void *frame);
|
||||
void as3vm_TextFormat_get_italic(void *frame);
|
||||
void as3vm_TextFormat_get_kerning(void *frame);
|
||||
void as3vm_TextFormat_get_leading(void *frame);
|
||||
void as3vm_TextFormat_get_leftMargin(void *frame);
|
||||
void as3vm_TextFormat_get_letterSpacing(void *frame);
|
||||
void as3vm_TextFormat_get_rightMargin(void *frame);
|
||||
void as3vm_TextFormat_get_size(void *frame);
|
||||
void as3vm_TextFormat_get_tabStops(void *frame);
|
||||
void as3vm_TextFormat_get_underline(void *frame);
|
||||
void as3vm_TextFormat_set_align(void *frame);
|
||||
void as3vm_TextFormat_set_blockIndent(void *frame);
|
||||
void as3vm_TextFormat_set_bold(void *frame);
|
||||
void as3vm_TextFormat_set_bullet(void *frame);
|
||||
void as3vm_TextFormat_set_color(void *frame);
|
||||
void as3vm_TextFormat_set_font(void *frame);
|
||||
void as3vm_TextFormat_set_indent(void *frame);
|
||||
void as3vm_TextFormat_set_italic(void *frame);
|
||||
void as3vm_TextFormat_set_kerning(void *frame);
|
||||
void as3vm_TextFormat_set_leading(void *frame);
|
||||
void as3vm_TextFormat_set_leftMargin(void *frame);
|
||||
void as3vm_TextFormat_set_letterSpacing(void *frame);
|
||||
void as3vm_TextFormat_set_rightMargin(void *frame);
|
||||
void as3vm_TextFormat_set_size(void *frame);
|
||||
void as3vm_TextFormat_set_tabStops(void *frame);
|
||||
void as3vm_TextFormat_set_underline(void *frame);
|
||||
|
||||
/* flash.text.TextLineMetrics -- unsupported stubs (ctor + setters) + getters. */
|
||||
void as3vm_TextLineMetrics__construct(void *frame);
|
||||
void as3vm_TextLineMetrics_get_ascent(void *frame);
|
||||
void as3vm_TextLineMetrics_get_descent(void *frame);
|
||||
void as3vm_TextLineMetrics_get_height(void *frame);
|
||||
void as3vm_TextLineMetrics_get_leading(void *frame);
|
||||
void as3vm_TextLineMetrics_get_width(void *frame);
|
||||
void as3vm_TextLineMetrics_get_x(void *frame);
|
||||
void as3vm_TextLineMetrics_set_ascent(void *frame);
|
||||
void as3vm_TextLineMetrics_set_descent(void *frame);
|
||||
void as3vm_TextLineMetrics_set_height(void *frame);
|
||||
void as3vm_TextLineMetrics_set_leading(void *frame);
|
||||
void as3vm_TextLineMetrics_set_width(void *frame);
|
||||
void as3vm_TextLineMetrics_set_x(void *frame);
|
||||
|
||||
/* Object factories + shared descriptor-driven bool accessors. */
|
||||
void as3vm_make_font_GC(void *vm, void *handle);
|
||||
void as3vm_make_textformat_GC(void *vm, void *fmt);
|
||||
void as3vm_textfield_bool_getter(void *frame);
|
||||
void as3vm_textfield_bool_setter(void *frame);
|
||||
|
||||
#ifdef __cplusplus
|
||||
} /* extern "C" */
|
||||
#endif
|
||||
|
||||
#endif /* IGGY_RECONSTRUCTED_SWF_AS3_TEXTFIELD_H */
|
||||
198
iggy-decompiled/src/reconstructed/swf_as3_textfield_font.inc
Normal file
198
iggy-decompiled/src/reconstructed/swf_as3_textfield_font.inc
Normal file
@@ -0,0 +1,198 @@
|
||||
/*
|
||||
* swf_as3_textfield_font.inc -- flash.text.Font class (7 exports), the two object
|
||||
* factories (as3vm_make_font_GC / as3vm_make_textformat_GC) and the shared
|
||||
* descriptor-driven bool accessors. Included by swf_as3_textfield.c.
|
||||
*/
|
||||
|
||||
static void *as3vm_make_font_GC_obj(void *vm, void *handle);
|
||||
|
||||
/* ======================================================================== */
|
||||
/* flash.text.Font */
|
||||
/* ======================================================================== */
|
||||
|
||||
/* Real: adopt the VM's pending native font buffer (vm+VM_PENDING) into the
|
||||
* object handle slot; an empty pending slot raises 0x74 (raw:11-18). */
|
||||
void as3vm_Font__construct(void *frame) {
|
||||
void **pending = (void **)AT(VM(frame), VM_PENDING);
|
||||
if (*pending != (void *)0) {
|
||||
*(void **)AT(THISOBJ(frame), OFF_HANDLE) = *pending;
|
||||
*pending = (void *)0;
|
||||
return;
|
||||
}
|
||||
as3vm_exception_GC(VM(frame), 0x74);
|
||||
}
|
||||
|
||||
/* Real: enumerate the font engine's embedded fonts (type byte '\x16') into a
|
||||
* fresh AS3 array, pushing it as a GC temp-root while it is populated. A parse
|
||||
* failure raises 0x78; the "device fonts" request yields an empty array
|
||||
* (raw:42-96). DEFERRED structurally (engine font-table walk; not exercised). */
|
||||
void as3vm_Font_enumerateFonts(void *frame) {
|
||||
int device_fonts = 0;
|
||||
void *vm = VM(frame);
|
||||
void *engine;
|
||||
int font_count;
|
||||
void **font_table;
|
||||
int embedded = 0;
|
||||
int i;
|
||||
void *arr;
|
||||
void **root;
|
||||
if (as3vm_component_parse_arguments_GC(frame, TFF_FMT_OPT_B, &device_fonts) !=
|
||||
0) {
|
||||
as3vm_exception_GC(vm, 0x78);
|
||||
return;
|
||||
}
|
||||
if (device_fonts != 0) {
|
||||
store_ptr(frame, as3vm_make_array_GC(vm, 0, 0));
|
||||
return;
|
||||
}
|
||||
engine = *(void **)vm;
|
||||
font_count = *(int32_t *)AT(engine, 0xa0);
|
||||
font_table = *(void ***)AT(engine, 0x98);
|
||||
for (i = 0; i < font_count; ++i) {
|
||||
char *f = (char *)font_table[i];
|
||||
if (f != (char *)0 && *f == '\x16') {
|
||||
++embedded;
|
||||
}
|
||||
}
|
||||
arr = as3vm_make_array_GC(vm, embedded, embedded);
|
||||
/* push arr onto the VM temp-root stack (vm+VM_STACKPTR). */
|
||||
root = *(void ***)AT(vm, VM_STACKPTR);
|
||||
*root = arr;
|
||||
*(char **)AT(vm, VM_STACKPTR) = (char *)root + sizeof(void *);
|
||||
{
|
||||
intptr_t slot = 0x20;
|
||||
for (i = 0; i < font_count; ++i) {
|
||||
char *f = (char *)font_table[i];
|
||||
if (f != (char *)0 && *f == '\x16') {
|
||||
void *fnt = as3vm_make_font_GC_obj(vm, f);
|
||||
void **cur = *(void ***)AT(vm, VM_STACKPTR);
|
||||
char *backing = *(char **)AT(cur[-1], 0x2f);
|
||||
uint8_t bs = *(uint8_t *)backing;
|
||||
uint8_t ob = *(uint8_t *)fnt;
|
||||
if (((uintptr_t)fnt & 3) == 1 && fnt != (void *)0x7 &&
|
||||
0x17 < (uint8_t)(bs & (uint8_t)~ob)) {
|
||||
as3vm_write_barrier_slowpath(vm, backing - 1, (char *)fnt - 1);
|
||||
}
|
||||
*(void **)(backing + slot - 1) = fnt;
|
||||
slot += 8;
|
||||
}
|
||||
}
|
||||
}
|
||||
/* pop and box the populated array. */
|
||||
*(char **)AT(vm, VM_STACKPTR) =
|
||||
(char *)*(void ***)AT(vm, VM_STACKPTR) - sizeof(void *);
|
||||
store_ptr(frame, *(void **)*(void ***)AT(vm, VM_STACKPTR));
|
||||
}
|
||||
|
||||
/* Real: box the wide font-name string from the handle (raw:106-110; pinned). */
|
||||
void as3vm_Font_get_fontName(void *frame) {
|
||||
void *handle = *(void **)AT(THISOBJ(frame), OFF_HANDLE);
|
||||
store_ptr(frame,
|
||||
as3vm_make_string_wc_GC(VM(frame),
|
||||
*(void **)AT(handle, HND_FONTNAME), -1));
|
||||
}
|
||||
|
||||
/* Real: index the VM constant pool by the handle's two style bytes (raw:119). */
|
||||
void as3vm_Font_get_fontStyle(void *frame) {
|
||||
void *handle = *(void **)AT(THISOBJ(frame), OFF_HANDLE);
|
||||
if (handle != (void *)0) {
|
||||
uint8_t b0 = *(uint8_t *)AT(handle, HND_STYLE0);
|
||||
uint8_t b1 = *(uint8_t *)AT(handle, HND_STYLE1);
|
||||
uint8_t code = tff_fontstyle_table[(b0 * 2 + b1) & 3];
|
||||
store_ptr(frame,
|
||||
*(void **)AT(VM(frame), VM_POOL + (intptr_t)code * sizeof(void *)));
|
||||
}
|
||||
}
|
||||
|
||||
/* Real: box the VM-cached fontType, selected by whether the handle is set
|
||||
* (raw:143-150; pinned). */
|
||||
void as3vm_Font_get_fontType(void *frame) {
|
||||
if (*(void **)AT(THISOBJ(frame), OFF_HANDLE) != (void *)0) {
|
||||
store_ptr(frame, *(void **)AT(VM(frame), VM_FONTTYPE_SET));
|
||||
} else {
|
||||
store_ptr(frame, *(void **)AT(VM(frame), VM_FONTTYPE_UNSET));
|
||||
}
|
||||
}
|
||||
|
||||
/* Real: parse a string, probe each code unit against the font cache; any missing
|
||||
* glyph yields "false", all present yields "true". A parse failure raises 0x78
|
||||
* (raw:155-190; pinned). */
|
||||
void as3vm_Font_hasGlyphs(void *frame) {
|
||||
void *arg = (void *)0;
|
||||
void *handle;
|
||||
void *strdata;
|
||||
int len;
|
||||
int i;
|
||||
if (as3vm_component_parse_arguments_GC(frame, TFF_FMT_S, &arg) != 0) {
|
||||
as3vm_exception_GC(VM(frame), 0x78);
|
||||
return;
|
||||
}
|
||||
strdata = *(void **)AT(arg, STR_HDR);
|
||||
len = *(int32_t *)AT(strdata, STR_HDR);
|
||||
handle = *(void **)AT(THISOBJ(frame), OFF_HANDLE);
|
||||
for (i = 0; i < len; ++i) {
|
||||
uint16_t cp = *(uint16_t *)AT(strdata, STR_DATA + (intptr_t)i * 2);
|
||||
if (iggy_get_unsafe_glyph_for_codepoint(handle, cp) < 0) {
|
||||
store_ptr(frame, TFF_FALSE_CELL);
|
||||
return;
|
||||
}
|
||||
}
|
||||
store_ptr(frame, TFF_TRUE_CELL);
|
||||
}
|
||||
|
||||
/* Pure 0x74 stub: font registration is unsupported (raw:196-201). */
|
||||
void as3vm_Font_registerFont(void *frame) {
|
||||
as3vm_exception_GC(VM(frame), 0x74);
|
||||
}
|
||||
|
||||
/* ======================================================================== */
|
||||
/* Object factories */
|
||||
/* ======================================================================== */
|
||||
|
||||
/* Internal: build a Font object wrapping a native handle (used by both the
|
||||
* public factory and enumerateFonts). */
|
||||
static void *as3vm_make_font_GC_obj(void *vm, void *handle) {
|
||||
void *obj =
|
||||
as3vm_make_object_no_constructor_GC(vm, *(void **)AT(vm, VM_FONTCLASS));
|
||||
*(void **)AT(obj, OFF_HANDLE) = handle;
|
||||
return obj;
|
||||
}
|
||||
|
||||
/* Real: allocate a Font object from the VM's Font class and stamp its native
|
||||
* handle (raw:3250-3258; pinned). */
|
||||
void as3vm_make_font_GC(void *vm, void *handle) {
|
||||
(void)as3vm_make_font_GC_obj(vm, handle);
|
||||
}
|
||||
|
||||
/* Real: allocate a TextFormat object from the VM's TextFormat class and copy the
|
||||
* eleven-word format body into it (raw:3264-3289). */
|
||||
void as3vm_make_textformat_GC(void *vm, void *fmt) {
|
||||
void *obj =
|
||||
as3vm_make_object_no_constructor_GC(vm, *(void **)AT(vm, VM_TFCLASS));
|
||||
memcpy(AT(obj, F_DEFAULT_ROOT), fmt, F_BODY_BYTES);
|
||||
}
|
||||
|
||||
/* ======================================================================== */
|
||||
/* Shared descriptor-driven bool accessors */
|
||||
/* ======================================================================== */
|
||||
|
||||
/* Real: box a bool from `info + descriptor.field` through the as3vm_makebool
|
||||
* table (raw:3295-3305; pinned). */
|
||||
void as3vm_textfield_bool_getter(void *frame) {
|
||||
int off = *(int32_t *)AT(DESCRIPTOR(frame), DESC_FIELD);
|
||||
uint8_t idx = *(uint8_t *)AT(TF_INFO(frame), off);
|
||||
store_ptr(frame, as3vm_makebool[idx]);
|
||||
}
|
||||
|
||||
/* Real: parse a bool and write it to `info + descriptor.field`. A parse failure
|
||||
* raises 0x78 (raw:3311-3326; pinned). */
|
||||
void as3vm_textfield_bool_setter(void *frame) {
|
||||
uint8_t value = 0;
|
||||
int off;
|
||||
if (as3vm_component_parse_arguments_GC(frame, TFF_FMT_B, &value) != 0) {
|
||||
as3vm_exception_GC(VM(frame), 0x78);
|
||||
return;
|
||||
}
|
||||
off = *(int32_t *)AT(DESCRIPTOR(frame), DESC_FIELD);
|
||||
*(uint8_t *)AT(TF_INFO(frame), off) = value;
|
||||
}
|
||||
@@ -0,0 +1,314 @@
|
||||
/*
|
||||
* swf_as3_textfield_textformat.inc -- flash.text.TextFormat class.
|
||||
* The object pointer is *this-slot directly; its attributes live at fixed byte
|
||||
* offsets in the object (no handle / info indirection). Included by
|
||||
* swf_as3_textfield.c.
|
||||
*/
|
||||
|
||||
/* Box a float attribute as a number, or the undefined sentinel when NaN. */
|
||||
static void tff_box_float_attr(void *frame, int off) {
|
||||
float v = *(float *)AT(THISOBJ(frame), off);
|
||||
if (tff_isnan_f(v)) {
|
||||
store_ptr(frame, TFF_UNDEF_CELL);
|
||||
return;
|
||||
}
|
||||
store_ptr(frame, as3vm_make_number_GC(VM(frame), (double)v));
|
||||
}
|
||||
|
||||
/* Real: TextFormat(font, size, color, bold, italic, underline, url, target,
|
||||
* align, leftMargin, rightMargin, indent, leading) -- parse with NaN / sentinel
|
||||
* defaults and populate the object. Bad args -> 0x78 (raw:2263). */
|
||||
void as3vm_TextFormat__construct(void *frame) {
|
||||
void *obj;
|
||||
void *font = TFF_UNDEF_CELL;
|
||||
void *url = TFF_UNDEF_CELL;
|
||||
void *target = TFF_UNDEF_CELL;
|
||||
float size = as3vm_NaNf;
|
||||
float left_margin = as3vm_NaNf;
|
||||
float right_margin = as3vm_NaNf;
|
||||
float indent = as3vm_NaNf;
|
||||
float leading = as3vm_NaNf;
|
||||
int32_t color = (int32_t)0x80000000;
|
||||
int32_t bold = 2;
|
||||
int32_t italic = 2;
|
||||
int32_t underline = 2;
|
||||
int align = -1;
|
||||
if (as3vm_component_parse_arguments_GC(
|
||||
frame, TFF_FMT_TEXTFORMAT, &font, &size, &color, &bold, &italic,
|
||||
&underline, &url, &target, &align, &left_margin, &right_margin,
|
||||
&indent, &leading) != 0) {
|
||||
as3vm_exception_GC(VM(frame), 0x78);
|
||||
return;
|
||||
}
|
||||
obj = THISOBJ(frame);
|
||||
*(void **)AT(obj, F_FONT) =
|
||||
(font != TFF_UNDEF_CELL) ? (void *)((char *)font - 1) : (void *)0;
|
||||
*(float *)AT(obj, F_SIZE) = size;
|
||||
*(int32_t *)AT(obj, F_COLOR) = color;
|
||||
*(uint8_t *)AT(obj, F_BOLD) = (uint8_t)bold;
|
||||
*(uint8_t *)AT(obj, F_ITALIC) = (uint8_t)italic;
|
||||
*(uint8_t *)AT(obj, F_UNDERLINE) = (uint8_t)underline;
|
||||
if (align == 0x38) {
|
||||
*(uint8_t *)AT(obj, F_ALIGN) = 2;
|
||||
} else if (align == 0x39) {
|
||||
*(uint8_t *)AT(obj, F_ALIGN) = 3;
|
||||
} else if (align == 0x3a) {
|
||||
*(uint8_t *)AT(obj, F_ALIGN) = 0;
|
||||
} else if (align == 0x3b) {
|
||||
*(uint8_t *)AT(obj, F_ALIGN) = 1;
|
||||
} else {
|
||||
*(uint8_t *)AT(obj, F_ALIGN) = 4;
|
||||
}
|
||||
*(float *)AT(obj, F_LEFTMARGIN) = left_margin;
|
||||
*(float *)AT(obj, F_RIGHTMARGIN) = right_margin;
|
||||
*(float *)AT(obj, F_INDENT) = indent;
|
||||
*(float *)AT(obj, F_LEADING) = leading;
|
||||
*(float *)AT(obj, F_BLOCKINDENT) = as3vm_NaNf;
|
||||
*(float *)AT(obj, F_LETTERSPACING) = as3vm_NaNf;
|
||||
*(uint16_t *)AT(obj, F_TABCOUNT) = 0;
|
||||
/* Initialize the tabStops AS3 property slot to the null/undefined cell
|
||||
* (durango raw:2334-2336 / vita raw ??_construct writes &DAT_...5011). */
|
||||
{
|
||||
void *traits = *(void **)AT(obj, STR_HDR);
|
||||
uint16_t slot = **(uint16_t **)AT(traits, TRAITS_TABSLOT);
|
||||
*(void **)((char *)obj + slot - 1) = TFF_UNDEF_CELL;
|
||||
}
|
||||
}
|
||||
|
||||
/* Real: map the align enum byte to the VM-cached align string (raw:2347). */
|
||||
void as3vm_TextFormat_get_align(void *frame) {
|
||||
char a = *(char *)AT(THISOBJ(frame), F_ALIGN);
|
||||
switch (a) {
|
||||
case 1:
|
||||
store_ptr(frame, *(void **)AT(VM(frame), VM_ALIGN_J));
|
||||
return;
|
||||
case 2:
|
||||
store_ptr(frame, *(void **)AT(VM(frame), VM_ALIGN_L));
|
||||
return;
|
||||
case 3:
|
||||
store_ptr(frame, *(void **)AT(VM(frame), VM_ALIGN_R));
|
||||
return;
|
||||
case 0:
|
||||
case 4:
|
||||
store_ptr(frame, *(void **)AT(VM(frame), VM_ALIGN_C));
|
||||
return;
|
||||
default:
|
||||
as3vm_exception_GC(VM(frame), 0x78);
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
/* Real float attributes (raw:2379/2465/2515/2539/2563/2587/2611). */
|
||||
void as3vm_TextFormat_get_blockIndent(void *frame) {
|
||||
tff_box_float_attr(frame, F_BLOCKINDENT);
|
||||
}
|
||||
void as3vm_TextFormat_get_indent(void *frame) {
|
||||
tff_box_float_attr(frame, F_INDENT);
|
||||
}
|
||||
void as3vm_TextFormat_get_leading(void *frame) {
|
||||
tff_box_float_attr(frame, F_LEADING);
|
||||
}
|
||||
void as3vm_TextFormat_get_leftMargin(void *frame) {
|
||||
tff_box_float_attr(frame, F_LEFTMARGIN);
|
||||
}
|
||||
void as3vm_TextFormat_get_letterSpacing(void *frame) {
|
||||
tff_box_float_attr(frame, F_LETTERSPACING);
|
||||
}
|
||||
void as3vm_TextFormat_get_rightMargin(void *frame) {
|
||||
tff_box_float_attr(frame, F_RIGHTMARGIN);
|
||||
}
|
||||
void as3vm_TextFormat_get_size(void *frame) {
|
||||
tff_box_float_attr(frame, F_SIZE);
|
||||
}
|
||||
|
||||
/* Real tri-state booleans -> as3vm_makebool table (raw:2403/2416/2489/2502). */
|
||||
void as3vm_TextFormat_get_bold(void *frame) {
|
||||
store_ptr(frame, as3vm_makebool[*(uint8_t *)AT(THISOBJ(frame), F_BOLD)]);
|
||||
}
|
||||
void as3vm_TextFormat_get_bullet(void *frame) {
|
||||
store_ptr(frame, as3vm_makebool[*(uint8_t *)AT(THISOBJ(frame), F_BULLET)]);
|
||||
}
|
||||
void as3vm_TextFormat_get_italic(void *frame) {
|
||||
store_ptr(frame, as3vm_makebool[*(uint8_t *)AT(THISOBJ(frame), F_ITALIC)]);
|
||||
}
|
||||
void as3vm_TextFormat_get_kerning(void *frame) {
|
||||
store_ptr(frame, as3vm_makebool[*(uint8_t *)AT(THISOBJ(frame), F_KERNING)]);
|
||||
}
|
||||
void as3vm_TextFormat_get_underline(void *frame) {
|
||||
store_ptr(frame, as3vm_makebool[*(uint8_t *)AT(THISOBJ(frame), F_UNDERLINE)]);
|
||||
}
|
||||
|
||||
/* Real: color is undefined when unset (0x80000000), else a boxed uint
|
||||
* (raw:2429). */
|
||||
void as3vm_TextFormat_get_color(void *frame) {
|
||||
int32_t color = *(int32_t *)AT(THISOBJ(frame), F_COLOR);
|
||||
if (color == (int32_t)0x80000000) {
|
||||
store_ptr(frame, TFF_UNDEF_CELL);
|
||||
return;
|
||||
}
|
||||
store_ptr(frame, as3vm_make_uint_GC(VM(frame), (uint32_t)color));
|
||||
}
|
||||
|
||||
/* Real: the font-name atom (+1 biased) or the "Times New Roman" default
|
||||
* (raw:2447). */
|
||||
void as3vm_TextFormat_get_font(void *frame) {
|
||||
void *font = *(void **)AT(THISOBJ(frame), F_FONT);
|
||||
if (font != (void *)0) {
|
||||
store_ptr(frame, (void *)((char *)font + 1));
|
||||
return;
|
||||
}
|
||||
store_ptr(frame, as3vm_make_string_c_GC(VM(frame), "Times New Roman"));
|
||||
}
|
||||
|
||||
/* Real: box the tab-stops array from the object's property slot (raw:2635). */
|
||||
void as3vm_TextFormat_get_tabStops(void *frame) {
|
||||
void *obj = THISOBJ(frame);
|
||||
void *traits = *(void **)AT(obj, STR_HDR);
|
||||
uint16_t slot = **(uint16_t **)AT(traits, TRAITS_TABSLOT);
|
||||
store_ptr(frame, *(void **)((char *)obj + slot - 1));
|
||||
}
|
||||
|
||||
/* ---- Setters -------------------------------------------------------------- */
|
||||
|
||||
/* Store a parsed double (default NaN) as a narrowed float attribute. Bad args
|
||||
* -> 0x78. */
|
||||
static void tff_set_float_attr(void *frame, int off) {
|
||||
double v = (double)as3vm_NaNf;
|
||||
if (as3vm_component_parse_arguments_GC(frame, TFF_FMT_OPT_F, &v) != 0) {
|
||||
as3vm_exception_GC(VM(frame), 0x78);
|
||||
return;
|
||||
}
|
||||
*(float *)AT(THISOBJ(frame), off) = (float)v;
|
||||
}
|
||||
|
||||
/* Store a parsed tri-state (default 2) as a byte-field attribute (retail stores
|
||||
* a 4-byte value -- a wart preserved here). Bad args -> 0x78. */
|
||||
static void tff_set_tristate_attr(void *frame, int off) {
|
||||
int32_t v = 2;
|
||||
if (as3vm_component_parse_arguments_GC(frame, TFF_FMT_OPT_B, &v) != 0) {
|
||||
as3vm_exception_GC(VM(frame), 0x78);
|
||||
return;
|
||||
}
|
||||
*(uint32_t *)AT(THISOBJ(frame), off) = (uint32_t)v;
|
||||
}
|
||||
|
||||
/* Real: parse an align enum (default -1), map to the align byte. Bad args or an
|
||||
* out-of-range enum raises 0x78 (raw:2662). */
|
||||
void as3vm_TextFormat_set_align(void *frame) {
|
||||
int value = -1;
|
||||
void *obj;
|
||||
if (as3vm_component_parse_arguments_GC(frame, TFF_FMT_OPT_K, &value) != 0 ||
|
||||
(value != -1 && (uint32_t)(value - 0x38) > 3u)) {
|
||||
as3vm_exception_GC(VM(frame), 0x78);
|
||||
return;
|
||||
}
|
||||
obj = THISOBJ(frame);
|
||||
if (value == 0x38) {
|
||||
*(uint8_t *)AT(obj, F_ALIGN) = 2;
|
||||
} else if (value == 0x39) {
|
||||
*(uint8_t *)AT(obj, F_ALIGN) = 3;
|
||||
} else if (value == 0x3a) {
|
||||
*(uint8_t *)AT(obj, F_ALIGN) = 0;
|
||||
} else if (value == 0x3b) {
|
||||
*(uint8_t *)AT(obj, F_ALIGN) = 1;
|
||||
} else {
|
||||
*(uint8_t *)AT(obj, F_ALIGN) = 4;
|
||||
}
|
||||
}
|
||||
|
||||
void as3vm_TextFormat_set_blockIndent(void *frame) {
|
||||
tff_set_float_attr(frame, F_BLOCKINDENT);
|
||||
}
|
||||
void as3vm_TextFormat_set_indent(void *frame) {
|
||||
tff_set_float_attr(frame, F_INDENT);
|
||||
}
|
||||
void as3vm_TextFormat_set_leading(void *frame) {
|
||||
tff_set_float_attr(frame, F_LEADING);
|
||||
}
|
||||
void as3vm_TextFormat_set_leftMargin(void *frame) {
|
||||
tff_set_float_attr(frame, F_LEFTMARGIN);
|
||||
}
|
||||
void as3vm_TextFormat_set_letterSpacing(void *frame) {
|
||||
tff_set_float_attr(frame, F_LETTERSPACING);
|
||||
}
|
||||
void as3vm_TextFormat_set_rightMargin(void *frame) {
|
||||
tff_set_float_attr(frame, F_RIGHTMARGIN);
|
||||
}
|
||||
void as3vm_TextFormat_set_size(void *frame) {
|
||||
tff_set_float_attr(frame, F_SIZE);
|
||||
}
|
||||
|
||||
void as3vm_TextFormat_set_bold(void *frame) {
|
||||
tff_set_tristate_attr(frame, F_BOLD);
|
||||
}
|
||||
void as3vm_TextFormat_set_bullet(void *frame) {
|
||||
tff_set_tristate_attr(frame, F_BULLET);
|
||||
}
|
||||
void as3vm_TextFormat_set_italic(void *frame) {
|
||||
tff_set_tristate_attr(frame, F_ITALIC);
|
||||
}
|
||||
void as3vm_TextFormat_set_kerning(void *frame) {
|
||||
tff_set_tristate_attr(frame, F_KERNING);
|
||||
}
|
||||
void as3vm_TextFormat_set_underline(void *frame) {
|
||||
tff_set_tristate_attr(frame, F_UNDERLINE);
|
||||
}
|
||||
|
||||
/* Real: parse a uint (default 0x80000000 = unset), store color. Bad args ->
|
||||
* 0x78 (raw:2767). */
|
||||
void as3vm_TextFormat_set_color(void *frame) {
|
||||
int32_t value = (int32_t)0x80000000;
|
||||
if (as3vm_component_parse_arguments_GC(frame, TFF_FMT_OPT_U, &value) != 0) {
|
||||
as3vm_exception_GC(VM(frame), 0x78);
|
||||
return;
|
||||
}
|
||||
*(int32_t *)AT(THISOBJ(frame), F_COLOR) = value;
|
||||
}
|
||||
|
||||
/* Real: parse a font-name atom, store it (-1 biased). Bad args -> 0x78
|
||||
* (raw:2787). */
|
||||
void as3vm_TextFormat_set_font(void *frame) {
|
||||
void *value = (void *)0;
|
||||
if (as3vm_component_parse_arguments_GC(frame, TFF_FMT_I, &value) != 0) {
|
||||
as3vm_exception_GC(VM(frame), 0x78);
|
||||
return;
|
||||
}
|
||||
*(void **)AT(THISOBJ(frame), F_FONT) = (void *)((char *)value - 1);
|
||||
}
|
||||
|
||||
/* Real: parse a tab-stops array, write-barrier it into the property slot and
|
||||
* copy up to 16 halved tab positions. Bad args -> 0x78 (raw:3008). */
|
||||
void as3vm_TextFormat_set_tabStops(void *frame) {
|
||||
void *arr = (void *)0;
|
||||
void *obj;
|
||||
void *traits;
|
||||
void *data;
|
||||
uint16_t slot;
|
||||
uint32_t n;
|
||||
if (as3vm_component_parse_arguments_GC(frame, TFF_FMT_A, &arr) != 0) {
|
||||
as3vm_exception_GC(VM(frame), 0x78);
|
||||
return;
|
||||
}
|
||||
obj = THISOBJ(frame);
|
||||
if (((uintptr_t)arr & 3) == 1 && arr != (void *)0x7 &&
|
||||
0x17 < (uint8_t)(*(uint8_t *)obj & (uint8_t)~*(uint8_t *)arr)) {
|
||||
as3vm_write_barrier_slowpath(VM(frame), (char *)obj - 1, (char *)arr - 1);
|
||||
}
|
||||
traits = *(void **)AT(obj, STR_HDR);
|
||||
slot = **(uint16_t **)AT(traits, TRAITS_TABSLOT);
|
||||
*(void **)((char *)obj + slot - 1) = arr;
|
||||
data = *(void **)AT(arr, F_FONT);
|
||||
n = *(uint32_t *)AT(data, STR_HDR);
|
||||
if ((int)n > 0x10) {
|
||||
n = 0x10;
|
||||
}
|
||||
*(uint16_t *)AT(obj, F_TABCOUNT) = (uint16_t)n;
|
||||
if ((int)n > 0) {
|
||||
const uint32_t *src = (const uint32_t *)AT(data, F_TABSRC);
|
||||
uint16_t *dst = (uint16_t *)AT(obj, F_TABDATA);
|
||||
uint32_t i;
|
||||
for (i = 0; i < n; ++i) {
|
||||
dst[i] = (uint16_t)(src[i * F_TABSTRIDE] >> 1);
|
||||
}
|
||||
}
|
||||
}
|
||||
309
iggy-decompiled/src/reconstructed/swf_as3_textfield_tf_get.inc
Normal file
309
iggy-decompiled/src/reconstructed/swf_as3_textfield_tf_get.inc
Normal file
@@ -0,0 +1,309 @@
|
||||
/*
|
||||
* swf_as3_textfield_tf_get.inc -- flash.text.TextField property getters.
|
||||
* Included by swf_as3_textfield.c.
|
||||
*/
|
||||
|
||||
/* Real: box the VM-cached antiAliasType constant, selected by the info flag
|
||||
* (raw:915). */
|
||||
void as3vm_TextField_get_antiAliasType(void *frame) {
|
||||
int flag = *(char *)AT(TF_INFO(frame), I_ANTIALIAS) != '\0';
|
||||
int32_t code = flag ? 0x3c : 0x3d;
|
||||
store_ptr(frame,
|
||||
*(void **)AT(VM(frame), VM_POOL + (intptr_t)code * sizeof(void *)));
|
||||
}
|
||||
|
||||
/* Real: index the VM constant pool by the autoSize enum code (raw:931). */
|
||||
void as3vm_TextField_get_autoSize(void *frame) {
|
||||
uint8_t idx = *(uint8_t *)AT(TF_INFO(frame), I_AUTOSIZE);
|
||||
int32_t code = tff_autosize_codes[idx & 3u];
|
||||
store_ptr(frame,
|
||||
*(void **)AT(VM(frame), VM_POOL + (intptr_t)code * sizeof(void *)));
|
||||
}
|
||||
|
||||
/* Real: box the backgroundColor uint (raw:948; pinned). */
|
||||
void as3vm_TextField_get_backgroundColor(void *frame) {
|
||||
store_ptr(frame,
|
||||
as3vm_make_uint_GC(VM(frame),
|
||||
*(uint32_t *)AT(TF_INFO(frame), I_BGCOLOR)));
|
||||
}
|
||||
|
||||
/* Real: box the borderColor uint (raw:965; pinned). */
|
||||
void as3vm_TextField_get_borderColor(void *frame) {
|
||||
store_ptr(frame,
|
||||
as3vm_make_uint_GC(VM(frame),
|
||||
*(uint32_t *)AT(TF_INFO(frame), I_BORDERCOLOR)));
|
||||
}
|
||||
|
||||
/* Real: the bottom visible line: advance from scrollV while lines fit within the
|
||||
* viewport height, then box (line*2 + 2) (raw:982). DEFERRED structurally
|
||||
* (per-line metrics walk; not exercised). */
|
||||
void as3vm_TextField_get_bottomScrollV(void *frame) {
|
||||
void *info = TF_INFO(frame);
|
||||
char *metrics = *(char **)AT(info, I_METRICS);
|
||||
int scroll_v = *(int32_t *)AT(info, I_SCROLLV);
|
||||
int line_count = *(int32_t *)AT(info, I_LINECOUNT);
|
||||
float view_h = *(float *)AT(info, I_SCALEY);
|
||||
int bottom = scroll_v;
|
||||
if (metrics != (char *)0) {
|
||||
int i = scroll_v;
|
||||
while (i < line_count) {
|
||||
float top = *(float *)(metrics + (intptr_t)i * METRIC_STRIDE);
|
||||
float baseline = *(float *)(metrics + 4 + (intptr_t)i * METRIC_STRIDE);
|
||||
if (view_h < baseline - top) {
|
||||
break;
|
||||
}
|
||||
++i;
|
||||
}
|
||||
bottom = i - 1;
|
||||
if (bottom < scroll_v) {
|
||||
bottom = scroll_v;
|
||||
}
|
||||
}
|
||||
store_word(frame, (intptr_t)(bottom * 2 + 2));
|
||||
}
|
||||
|
||||
/* Real: box (caretIndex * 2) (raw:1028). */
|
||||
void as3vm_TextField_get_caretIndex(void *frame) {
|
||||
store_word(frame,
|
||||
(intptr_t)(*(int32_t *)AT(TF_INFO(frame), I_CARET) * 2));
|
||||
}
|
||||
|
||||
/* Real: contextMenu is unsupported -> 0x78 (raw:1042). */
|
||||
void as3vm_TextField_get_contextMenu(void *frame) {
|
||||
as3vm_exception_GC(VM(frame), 0x78);
|
||||
}
|
||||
|
||||
/* Real: build a TextFormat object seeded from the embedded default format
|
||||
* sub-struct (info+I_DEFAULTFMT) (raw:1053). */
|
||||
void as3vm_TextField_get_defaultTextFormat(void *frame) {
|
||||
void *info = TF_INFO(frame);
|
||||
void *obj = as3vm_make_object_no_constructor_GC(
|
||||
VM(frame), *(void **)AT(VM(frame), VM_TFCLASS));
|
||||
memcpy(AT(obj, F_DEFAULT_ROOT), AT(info, I_DEFAULTFMT), F_BODY_BYTES);
|
||||
store_ptr(frame, obj);
|
||||
}
|
||||
|
||||
/* Real: index the VM constant pool by the gridFitType enum code (raw:1087). */
|
||||
void as3vm_TextField_get_gridFitType(void *frame) {
|
||||
uint8_t idx = *(uint8_t *)AT(TF_INFO(frame), I_GRIDFIT);
|
||||
int32_t code = tff_gridfit_codes[idx];
|
||||
store_ptr(frame,
|
||||
*(void **)AT(VM(frame), VM_POOL + (intptr_t)code * sizeof(void *)));
|
||||
}
|
||||
|
||||
/* Real: height = sqrt(m10^2 + m11^2) * info.scaleY, boxed as a number
|
||||
* (raw:1105). */
|
||||
void as3vm_TextField_get_height(void *frame) {
|
||||
void *handle = *(void **)AT(THISOBJ(frame), OFF_HANDLE);
|
||||
float m0 = *(float *)AT(handle, HND_HMAT0);
|
||||
float m1 = *(float *)AT(handle, HND_HMAT1);
|
||||
float len = (float)sqrt((double)(m0 * m0 + m1 * m1));
|
||||
float scale = *(float *)AT(*(void **)AT(handle, OFF_INFO), I_SCALEY);
|
||||
store_ptr(frame, as3vm_make_number_GC(VM(frame), (double)(len * scale)));
|
||||
}
|
||||
|
||||
/* Real: concatenate all line-node char buffers into a fresh string (raw:1128). */
|
||||
void as3vm_TextField_get_htmlText(void *frame) {
|
||||
void *info = TF_INFO(frame);
|
||||
void *node;
|
||||
int total = 0;
|
||||
int pos = 0;
|
||||
void *sd;
|
||||
for (node = *(void **)AT(info, I_LINEHEAD); node != (void *)0;
|
||||
node = *(void **)AT(node, N_NEXT)) {
|
||||
if (*(void **)AT(node, N_TEXT) != (void *)0) {
|
||||
total += *(int32_t *)AT(node, N_COUNT);
|
||||
}
|
||||
}
|
||||
sd = as3vm_make_stringdata_GC(VM(frame), (void *)0, total);
|
||||
for (node = *(void **)AT(info, I_LINEHEAD); node != (void *)0;
|
||||
node = *(void **)AT(node, N_NEXT)) {
|
||||
void *src = *(void **)AT(node, N_TEXT);
|
||||
if (src != (void *)0) {
|
||||
int n = *(int32_t *)AT(node, N_COUNT);
|
||||
memcpy(AT(sd, STR_DATA + (intptr_t)pos * 2), src, (__SIZE_TYPE__)n * 2);
|
||||
pos += n;
|
||||
}
|
||||
}
|
||||
store_ptr(frame, as3vm_make_string_GC(VM(frame), sd));
|
||||
}
|
||||
|
||||
/* Real: box (total char count * 2) (raw:1165; pinned). */
|
||||
void as3vm_TextField_get_length(void *frame) {
|
||||
store_word(frame, (intptr_t)(tff_count_chars(TF_INFO(frame)) * 2));
|
||||
}
|
||||
|
||||
/* Real: box the maxChars int (raw:1185). */
|
||||
void as3vm_TextField_get_maxChars(void *frame) {
|
||||
store_ptr(frame,
|
||||
as3vm_make_int_GC(VM(frame),
|
||||
*(int32_t *)AT(TF_INFO(frame), I_MAXCHARS)));
|
||||
}
|
||||
|
||||
/* Real: box ((textWidth - 6 - 3) clamped >= 0, floored, * 2) (raw:1202). */
|
||||
void as3vm_TextField_get_maxScrollH(void *frame) {
|
||||
void *info = TF_INFO(frame);
|
||||
float v = *(float *)AT(info, I_TEXTWIDTH) -
|
||||
((*(float *)AT(info, I_SCALEX) - TFF_F_SIX) - TFF_F_THREE);
|
||||
if (v < 0.0f) {
|
||||
v = 0.0f;
|
||||
}
|
||||
store_word(frame, (intptr_t)((int)v * 2));
|
||||
}
|
||||
|
||||
/* Real: box (maxScrollV * 2 + 2) (raw:1222). */
|
||||
void as3vm_TextField_get_maxScrollV(void *frame) {
|
||||
store_word(frame,
|
||||
(intptr_t)(*(int32_t *)AT(TF_INFO(frame), I_MAXSCROLLV) * 2 + 2));
|
||||
}
|
||||
|
||||
/* Real: box (numLines * 2) (raw:1236; pinned). */
|
||||
void as3vm_TextField_get_numLines(void *frame) {
|
||||
store_word(frame,
|
||||
(intptr_t)(*(int32_t *)AT(TF_INFO(frame), I_NUMLINES) * 2));
|
||||
}
|
||||
|
||||
/* Real: parse (rejected extra), then box the restrict wide-string or the cached
|
||||
* empty string. A parse failure raises 0x78 (raw:1250). */
|
||||
void as3vm_TextField_get_restrict(void *frame) {
|
||||
uint16_t *r;
|
||||
if (as3vm_component_parse_arguments_GC(frame, TFF_FMT_OPT_S,
|
||||
(void *)0) != 0) {
|
||||
as3vm_exception_GC(VM(frame), 0x78);
|
||||
return;
|
||||
}
|
||||
r = *(uint16_t **)AT(TF_INFO(frame), I_RESTRICT);
|
||||
if (r == (uint16_t *)0) {
|
||||
store_ptr(frame, *(void **)AT(VM(frame), VM_EMPTYSTR));
|
||||
return;
|
||||
}
|
||||
store_ptr(frame, as3vm_make_string_wc_GC(VM(frame), r + 1, *r));
|
||||
}
|
||||
|
||||
/* Real: box (scrollH * 2) (raw:1278). */
|
||||
void as3vm_TextField_get_scrollH(void *frame) {
|
||||
store_word(frame,
|
||||
(intptr_t)(*(int32_t *)AT(TF_INFO(frame), I_SCROLLH) * 2));
|
||||
}
|
||||
|
||||
/* Real: box (scrollV * 2 + 2) (raw:1292). */
|
||||
void as3vm_TextField_get_scrollV(void *frame) {
|
||||
store_word(frame,
|
||||
(intptr_t)(*(int32_t *)AT(TF_INFO(frame), I_SCROLLV) * 2 + 2));
|
||||
}
|
||||
|
||||
/* Real: the current selection as a string, or the cached empty string
|
||||
* (raw:1306). */
|
||||
void as3vm_TextField_get_selectedText(void *frame) {
|
||||
void *info = TF_INFO(frame);
|
||||
if (*(char *)AT(info, I_SELFLAG) != '\0') {
|
||||
store_ptr(frame,
|
||||
get_text_range_GC(VM(frame), THISOBJ(frame),
|
||||
*(int32_t *)AT(info, I_SELBEGIN),
|
||||
*(int32_t *)AT(info, I_SELEND)));
|
||||
return;
|
||||
}
|
||||
store_ptr(frame, *(void **)AT(VM(frame), VM_EMPTYSTR));
|
||||
}
|
||||
|
||||
/* Real: box (selectionBeginIndex * 2), or caret when no selection (raw:1327). */
|
||||
void as3vm_TextField_get_selectionBeginIndex(void *frame) {
|
||||
void *info = TF_INFO(frame);
|
||||
if (*(char *)AT(info, I_SELFLAG) != '\0') {
|
||||
store_word(frame, (intptr_t)(*(int32_t *)AT(info, I_SELBEGIN) * 2));
|
||||
return;
|
||||
}
|
||||
store_word(frame, (intptr_t)(*(int32_t *)AT(info, I_CARET) * 2));
|
||||
}
|
||||
|
||||
/* Real: box (selectionEndIndex * 2), or caret when no selection (raw:1345). */
|
||||
void as3vm_TextField_get_selectionEndIndex(void *frame) {
|
||||
void *info = TF_INFO(frame);
|
||||
if (*(char *)AT(info, I_SELFLAG) != '\0') {
|
||||
store_word(frame, (intptr_t)(*(int32_t *)AT(info, I_SELEND) * 2));
|
||||
return;
|
||||
}
|
||||
store_word(frame, (intptr_t)(*(int32_t *)AT(info, I_CARET) * 2));
|
||||
}
|
||||
|
||||
/* Real: box the sharpness float as a number (raw:1363). */
|
||||
void as3vm_TextField_get_sharpness(void *frame) {
|
||||
store_ptr(frame,
|
||||
as3vm_make_number_GC(
|
||||
VM(frame), (double)*(float *)AT(TF_INFO(frame), I_SHARPNESS)));
|
||||
}
|
||||
|
||||
/* Real: styleSheet is always the null/undefined sentinel (raw:1381). */
|
||||
void as3vm_TextField_get_styleSheet(void *frame) {
|
||||
store_ptr(frame, TFF_UNDEF_CELL);
|
||||
}
|
||||
|
||||
/* Real: concatenate all line-node char buffers into a fresh string (raw:1392). */
|
||||
void as3vm_TextField_get_text(void *frame) {
|
||||
void *info = TF_INFO(frame);
|
||||
void *node;
|
||||
int total = 0;
|
||||
int pos = 0;
|
||||
void *sd;
|
||||
for (node = *(void **)AT(info, I_LINEHEAD); node != (void *)0;
|
||||
node = *(void **)AT(node, N_NEXT)) {
|
||||
if (*(void **)AT(node, N_TEXT) != (void *)0) {
|
||||
total += *(int32_t *)AT(node, N_COUNT);
|
||||
}
|
||||
}
|
||||
sd = as3vm_make_stringdata_GC(VM(frame), (void *)0, total);
|
||||
for (node = *(void **)AT(info, I_LINEHEAD); node != (void *)0;
|
||||
node = *(void **)AT(node, N_NEXT)) {
|
||||
void *src = *(void **)AT(node, N_TEXT);
|
||||
if (src != (void *)0) {
|
||||
int n = *(int32_t *)AT(node, N_COUNT);
|
||||
memcpy(AT(sd, STR_DATA + (intptr_t)pos * 2), src, (__SIZE_TYPE__)n * 2);
|
||||
pos += n;
|
||||
}
|
||||
}
|
||||
store_ptr(frame, as3vm_make_string_GC(VM(frame), sd));
|
||||
}
|
||||
|
||||
/* Real: box the textColor uint (raw:1429; pinned). */
|
||||
void as3vm_TextField_get_textColor(void *frame) {
|
||||
store_ptr(frame,
|
||||
as3vm_make_uint_GC(VM(frame),
|
||||
*(uint32_t *)AT(TF_INFO(frame), I_TEXTCOLOR)));
|
||||
}
|
||||
|
||||
/* Real: box (ceil(textHeight) + 2.0) as a number (raw:1446). */
|
||||
void as3vm_TextField_get_textHeight(void *frame) {
|
||||
double h = ceil((double)*(float *)AT(TF_INFO(frame), I_TEXTHEIGHT));
|
||||
store_ptr(frame, as3vm_make_number_GC(VM(frame), h + TFF_D_TWO));
|
||||
}
|
||||
|
||||
/* Real: box (textWidth + 1.0) as a number (raw:1466). */
|
||||
void as3vm_TextField_get_textWidth(void *frame) {
|
||||
double w = (double)(*(float *)AT(TF_INFO(frame), I_TEXTWIDTH) + TFF_F_ONE);
|
||||
store_ptr(frame, as3vm_make_number_GC(VM(frame), w));
|
||||
}
|
||||
|
||||
/* Real: box the thickness float as a number (raw:1484). */
|
||||
void as3vm_TextField_get_thickness(void *frame) {
|
||||
store_ptr(frame,
|
||||
as3vm_make_number_GC(
|
||||
VM(frame), (double)*(float *)AT(TF_INFO(frame), I_SHARPNESS)));
|
||||
}
|
||||
|
||||
/* Real: box the VM-cached type constant, selected by the info flag (raw:1502). */
|
||||
void as3vm_TextField_get_type(void *frame) {
|
||||
int flag = *(char *)AT(TF_INFO(frame), I_TYPE) != '\0';
|
||||
int32_t code = flag ? 0x42 : 0x41;
|
||||
store_ptr(frame, *(void **)AT(VM(frame), VM_POOL + (intptr_t)code * sizeof(void *)));
|
||||
}
|
||||
|
||||
/* Real: width = sqrt(m00^2 + m01^2) * info.scaleX, boxed as a number
|
||||
* (raw:1518). */
|
||||
void as3vm_TextField_get_width(void *frame) {
|
||||
void *handle = *(void **)AT(THISOBJ(frame), OFF_HANDLE);
|
||||
float m0 = *(float *)AT(handle, HND_WMAT0);
|
||||
float m1 = *(float *)AT(handle, HND_WMAT1);
|
||||
float len = (float)sqrt((double)(m0 * m0 + m1 * m1));
|
||||
float scale = *(float *)AT(*(void **)AT(handle, OFF_INFO), I_SCALEX);
|
||||
store_ptr(frame, as3vm_make_number_GC(VM(frame), (double)(len * scale)));
|
||||
}
|
||||
@@ -0,0 +1,597 @@
|
||||
/*
|
||||
* swf_as3_textfield_tf_methods.inc -- flash.text.TextField text-layout methods
|
||||
* plus the three durango file statics (get_text_range_GC, merge_format,
|
||||
* split_chunk). Included by swf_as3_textfield.c.
|
||||
*
|
||||
* The getLine* / getChar* / getLineMetrics / getTextFormat happy paths call the
|
||||
* (genuinely unbuilt) iggy_textfield_compute_info engine, which fills a stack
|
||||
* query buffer whose field byte-offsets are transcribed from the durango
|
||||
* decompile. These happy paths are DEFERRED / not exercised by the runtime
|
||||
* harness; the parse -> validate -> compute -> box call sequence and arg
|
||||
* marshalling are reconstructed faithfully. Query-buffer accessors: */
|
||||
#define TFQ_I(q, off) (*(int32_t *)AT((q), (off)))
|
||||
#define TFQ_F(q, off) (*(float *)AT((q), (off)))
|
||||
|
||||
/* ======================================================================== */
|
||||
/* Text mutation */
|
||||
/* ======================================================================== */
|
||||
|
||||
/* Real: parse a string, append it via the text engine. Bad args -> 0x78
|
||||
* (raw:218-235; pinned). */
|
||||
void as3vm_TextField_appendText(void *frame) {
|
||||
void *arg = (void *)0;
|
||||
void *strdata;
|
||||
if (as3vm_component_parse_arguments_GC(frame, TFF_FMT_S, &arg) != 0) {
|
||||
as3vm_exception_GC(VM(frame), 0x78);
|
||||
return;
|
||||
}
|
||||
strdata = *(void **)AT(arg, STR_HDR);
|
||||
iggy_set_textfield_text(ENGINE(frame), TF_INFO(frame), AT(strdata, STR_DATA),
|
||||
*(int32_t *)AT(strdata, STR_HDR), 1);
|
||||
}
|
||||
|
||||
/* Real: parse (begin, end, text), clamp to the char range, replace via the
|
||||
* engine. Bad args -> 0x78 (raw:1574). */
|
||||
void as3vm_TextField_replaceText(void *frame) {
|
||||
int begin = 0;
|
||||
int end = 0;
|
||||
void *text = (void *)0;
|
||||
void *info;
|
||||
int total;
|
||||
if (as3vm_component_parse_arguments_GC(frame, TFF_FMT_DDS, &begin, &end,
|
||||
&text) != 0) {
|
||||
as3vm_exception_GC(VM(frame), 0x78);
|
||||
return;
|
||||
}
|
||||
info = TF_INFO(frame);
|
||||
total = tff_count_chars(info);
|
||||
if (begin < 0) {
|
||||
begin = 0;
|
||||
}
|
||||
if (total < end) {
|
||||
end = total;
|
||||
}
|
||||
if (end < begin) {
|
||||
begin = end;
|
||||
}
|
||||
iggy_do_replace_text(ENGINE(frame), info, begin, end, text);
|
||||
}
|
||||
|
||||
/* Real: replace the current selection (or insert at the caret) via the engine.
|
||||
* Bad args -> 0x78 (raw:1541). */
|
||||
void as3vm_TextField_replaceSelectedText(void *frame) {
|
||||
void *text = (void *)0;
|
||||
void *info;
|
||||
if (as3vm_component_parse_arguments_GC(frame, TFF_FMT_S, &text) != 0) {
|
||||
as3vm_exception_GC(VM(frame), 0x78);
|
||||
return;
|
||||
}
|
||||
info = TF_INFO(frame);
|
||||
if (*(char *)AT(info, I_MULTILINE2) == '\0') {
|
||||
*(uint8_t *)AT(info, I_SELFLAG) = 0;
|
||||
*(int32_t *)AT(info, I_CARET) = 0;
|
||||
}
|
||||
if (*(char *)AT(info, I_SELFLAG) != '\0') {
|
||||
iggy_do_replace_text(ENGINE(frame), info, *(int32_t *)AT(info, I_SELBEGIN),
|
||||
*(int32_t *)AT(info, I_SELEND), text);
|
||||
return;
|
||||
}
|
||||
iggy_do_replace_text(ENGINE(frame), info, *(int32_t *)AT(info, I_CARET),
|
||||
*(int32_t *)AT(info, I_CARET), text);
|
||||
}
|
||||
|
||||
/* Real: parse (begin, end), clamp/normalise, set or clear the selection
|
||||
* (raw:1613). */
|
||||
void as3vm_TextField_setSelection(void *frame) {
|
||||
int begin = 0;
|
||||
int end = 0;
|
||||
void *info;
|
||||
int total;
|
||||
if (as3vm_component_parse_arguments_GC(frame, TFF_FMT_DD, &begin, &end) != 0) {
|
||||
as3vm_exception_GC(VM(frame), 0x78);
|
||||
return;
|
||||
}
|
||||
info = TF_INFO(frame);
|
||||
total = tff_count_chars(info);
|
||||
if (begin < 0) {
|
||||
begin = 0;
|
||||
}
|
||||
if (total < end) {
|
||||
end = total;
|
||||
}
|
||||
if (end < 0) {
|
||||
end = 0;
|
||||
}
|
||||
if (begin <= end && begin != end) {
|
||||
*(uint8_t *)AT(info, I_SELFLAG) = 1;
|
||||
*(int32_t *)AT(info, I_SELBEGIN) = begin;
|
||||
*(int32_t *)AT(info, I_SELEND) = end;
|
||||
return;
|
||||
}
|
||||
*(uint8_t *)AT(info, I_SELFLAG) = 0;
|
||||
*(int32_t *)AT(info, I_CARET) = (begin <= end) ? begin : end;
|
||||
}
|
||||
|
||||
/* ======================================================================== */
|
||||
/* Line / char queries (compute_info-backed; DEFERRED happy paths) */
|
||||
/* ======================================================================== */
|
||||
|
||||
/* Real: parse a line index (>= 0), query the layout, box (offset * 2). Bad args
|
||||
* or an out-of-range line raises 0x78 (raw:545; the negative-index reject is
|
||||
* pinned). */
|
||||
void as3vm_TextField_getLineOffset(void *frame) {
|
||||
int idx = 0;
|
||||
if (as3vm_component_parse_arguments_GC(frame, TFF_FMT_D, &idx) == 0 &&
|
||||
idx >= 0) {
|
||||
unsigned char q[0x60];
|
||||
TFQ_I(q, 0x34) = idx;
|
||||
TFQ_I(q, 0x00) = 0;
|
||||
TFQ_I(q, 0x40) = 0;
|
||||
TFQ_I(q, 0x14) = -2;
|
||||
iggy_textfield_compute_info(ENGINE(frame), TF_INFO(frame), q);
|
||||
if (TFQ_I(q, 0x34) != -1) {
|
||||
store_word(frame, (intptr_t)(TFQ_I(q, 0x38) * 2));
|
||||
return;
|
||||
}
|
||||
}
|
||||
as3vm_exception_GC(VM(frame), 0x78);
|
||||
}
|
||||
|
||||
/* Real: parse a line index (>= 0), query the layout, box the paragraph length.
|
||||
* Bad args raises 0x78 (raw:669; the parse reject is pinned). */
|
||||
void as3vm_TextField_getParagraphLength(void *frame) {
|
||||
int idx = 0;
|
||||
if (as3vm_component_parse_arguments_GC(frame, TFF_FMT_D, &idx) == 0 &&
|
||||
idx >= 0) {
|
||||
unsigned char q[0x60];
|
||||
TFQ_I(q, 0x14) = idx;
|
||||
TFQ_I(q, 0x00) = 0;
|
||||
TFQ_I(q, 0x40) = 0;
|
||||
TFQ_I(q, 0x34) = -2;
|
||||
iggy_textfield_compute_info(ENGINE(frame), TF_INFO(frame), q);
|
||||
if (TFQ_I(q, 0x14) != -1) {
|
||||
store_word(frame,
|
||||
(intptr_t)((TFQ_I(q, 0x30) - TFQ_I(q, 0x2c)) * 2 + 2));
|
||||
return;
|
||||
}
|
||||
}
|
||||
as3vm_exception_GC(VM(frame), 0x78);
|
||||
}
|
||||
|
||||
/* Real: parse a char index (>= 0), query the layout, box the first char of the
|
||||
* paragraph. Bad args or an out-of-range index raises 0x78 (raw:333). */
|
||||
void as3vm_TextField_getFirstCharInParagraph(void *frame) {
|
||||
int idx = 0;
|
||||
if (as3vm_component_parse_arguments_GC(frame, TFF_FMT_D, &idx) == 0 &&
|
||||
idx >= 0) {
|
||||
unsigned char q[0x60];
|
||||
TFQ_I(q, 0x14) = idx;
|
||||
TFQ_I(q, 0x00) = 0;
|
||||
TFQ_I(q, 0x40) = 0;
|
||||
TFQ_I(q, 0x34) = -2;
|
||||
iggy_textfield_compute_info(ENGINE(frame), TF_INFO(frame), q);
|
||||
if (TFQ_I(q, 0x14) != -1) {
|
||||
store_word(frame, (intptr_t)(TFQ_I(q, 0x2c) * 2));
|
||||
return;
|
||||
}
|
||||
}
|
||||
as3vm_exception_GC(VM(frame), 0x78);
|
||||
}
|
||||
|
||||
/* Real: parse a char index (>= 0), query the layout, box the line index. Bad
|
||||
* args or an out-of-range index raises 0x78 (raw:411). */
|
||||
void as3vm_TextField_getLineIndexOfChar(void *frame) {
|
||||
int idx = 0;
|
||||
if (as3vm_component_parse_arguments_GC(frame, TFF_FMT_D, &idx) == 0 &&
|
||||
idx >= 0) {
|
||||
unsigned char q[0x60];
|
||||
TFQ_I(q, 0x14) = idx;
|
||||
TFQ_I(q, 0x00) = 0;
|
||||
TFQ_I(q, 0x40) = 0;
|
||||
TFQ_I(q, 0x34) = -2;
|
||||
iggy_textfield_compute_info(ENGINE(frame), TF_INFO(frame), q);
|
||||
if (TFQ_I(q, 0x14) != -1) {
|
||||
store_word(frame, (intptr_t)(TFQ_I(q, 0x28) * 2));
|
||||
return;
|
||||
}
|
||||
}
|
||||
as3vm_exception_GC(VM(frame), 0x78);
|
||||
}
|
||||
|
||||
/* Real: parse a line index (>= 0), query the layout, box the line char count.
|
||||
* Bad args or an out-of-range line raises 0x78 (raw:450). */
|
||||
void as3vm_TextField_getLineLength(void *frame) {
|
||||
int idx = 0;
|
||||
if (as3vm_component_parse_arguments_GC(frame, TFF_FMT_D, &idx) == 0 &&
|
||||
idx >= 0) {
|
||||
unsigned char q[0x60];
|
||||
TFQ_I(q, 0x34) = idx;
|
||||
TFQ_I(q, 0x00) = 0;
|
||||
TFQ_I(q, 0x40) = 0;
|
||||
TFQ_I(q, 0x14) = -2;
|
||||
iggy_textfield_compute_info(ENGINE(frame), TF_INFO(frame), q);
|
||||
if (TFQ_I(q, 0x34) != -1) {
|
||||
store_word(frame, (intptr_t)(TFQ_I(q, 0x3c) * 2));
|
||||
return;
|
||||
}
|
||||
}
|
||||
as3vm_exception_GC(VM(frame), 0x78);
|
||||
}
|
||||
|
||||
/* Real: parse a (x, y) point, query the layout, box the char index (raw:294). */
|
||||
void as3vm_TextField_getCharIndexAtPoint(void *frame) {
|
||||
unsigned char q[0x60];
|
||||
if (as3vm_component_parse_arguments_GC(frame, TFF_FMT_FF, AT(q, 4),
|
||||
AT(q, 8)) == 0) {
|
||||
TFQ_I(q, 0x00) = 1;
|
||||
TFQ_I(q, 0x40) = 0;
|
||||
TFQ_I(q, 0x34) = -2;
|
||||
TFQ_I(q, 0x14) = -2;
|
||||
iggy_textfield_compute_info(ENGINE(frame), TF_INFO(frame), q);
|
||||
store_word(frame, (intptr_t)(TFQ_I(q, 0x0c) * 2));
|
||||
return;
|
||||
}
|
||||
as3vm_exception_GC(VM(frame), 0x78);
|
||||
}
|
||||
|
||||
/* Real: parse a (x, y) point, query the layout, box the line index (raw:372). */
|
||||
void as3vm_TextField_getLineIndexAtPoint(void *frame) {
|
||||
unsigned char q[0x60];
|
||||
if (as3vm_component_parse_arguments_GC(frame, TFF_FMT_FF, AT(q, 4),
|
||||
AT(q, 8)) == 0) {
|
||||
TFQ_I(q, 0x00) = 1;
|
||||
TFQ_I(q, 0x40) = 0;
|
||||
TFQ_I(q, 0x34) = -2;
|
||||
TFQ_I(q, 0x14) = -2;
|
||||
iggy_textfield_compute_info(ENGINE(frame), TF_INFO(frame), q);
|
||||
store_word(frame, (intptr_t)(TFQ_I(q, 0x10) * 2));
|
||||
return;
|
||||
}
|
||||
as3vm_exception_GC(VM(frame), 0x78);
|
||||
}
|
||||
|
||||
/* Real: parse a char index (>= 0), query the layout, box the char bounding
|
||||
* rectangle; an out-of-range index yields the undefined sentinel. Bad args
|
||||
* raises 0x78 (raw:244). */
|
||||
void as3vm_TextField_getCharBoundaries(void *frame) {
|
||||
int idx = 0;
|
||||
if (as3vm_component_parse_arguments_GC(frame, TFF_FMT_D, &idx) == 0 &&
|
||||
idx >= 0) {
|
||||
unsigned char q[0x60];
|
||||
TFQ_I(q, 0x14) = idx;
|
||||
TFQ_I(q, 0x00) = 0;
|
||||
TFQ_I(q, 0x40) = 0;
|
||||
TFQ_I(q, 0x34) = -2;
|
||||
iggy_textfield_compute_info(ENGINE(frame), TF_INFO(frame), q);
|
||||
if (TFQ_I(q, 0x14) < 0) {
|
||||
store_ptr(frame, TFF_UNDEF_CELL);
|
||||
} else {
|
||||
float x = TFQ_F(q, 0x18);
|
||||
float y = TFQ_F(q, 0x1c);
|
||||
float right = TFQ_F(q, 0x20);
|
||||
float bottom = TFQ_F(q, 0x24);
|
||||
store_ptr(frame, as3vm_make_rectangle_GC(VM(frame), x, y, right - x,
|
||||
bottom - y));
|
||||
}
|
||||
return;
|
||||
}
|
||||
as3vm_exception_GC(VM(frame), 0x78);
|
||||
}
|
||||
|
||||
/* Real: parse a line index (>= 0), query the layout, box (line index * 2) and a
|
||||
* fresh TextLineMetrics object built from the query. Bad args or an
|
||||
* out-of-range line raises 0x78 (raw:489). */
|
||||
void as3vm_TextField_getLineMetrics(void *frame) {
|
||||
int idx = 0;
|
||||
void *vm = VM(frame);
|
||||
if (as3vm_component_parse_arguments_GC(frame, TFF_FMT_D, &idx) == 0 &&
|
||||
idx >= 0) {
|
||||
unsigned char q[0x60];
|
||||
TFQ_I(q, 0x34) = idx;
|
||||
TFQ_I(q, 0x00) = 0;
|
||||
TFQ_I(q, 0x40) = 1;
|
||||
TFQ_I(q, 0x14) = -2;
|
||||
iggy_textfield_compute_info(ENGINE(frame), TF_INFO(frame), q);
|
||||
if (TFQ_I(q, 0x34) != -1) {
|
||||
void *obj =
|
||||
as3vm_make_object_no_constructor_GC(vm, *(void **)AT(vm, VM_TLMCLASS));
|
||||
*(uint32_t *)AT(obj, M_ASCENT) = (uint32_t)TFQ_I(q, 0x44);
|
||||
*(uint32_t *)AT(obj, M_DESCENT) = (uint32_t)TFQ_I(q, 0x48);
|
||||
*(uint32_t *)AT(obj, M_WIDTH) = (uint32_t)TFQ_I(q, 0x54);
|
||||
*(uint32_t *)AT(obj, M_HEIGHT) = (uint32_t)TFQ_I(q, 0x4c);
|
||||
*(uint32_t *)AT(obj, M_LEADING) = (uint32_t)TFQ_I(q, 0x50);
|
||||
*(uint32_t *)AT(obj, M_X) = (uint32_t)TFQ_I(q, 0x58);
|
||||
store_word(frame, (intptr_t)(TFQ_I(q, 0x38) * 2));
|
||||
*(void **)RESULT(frame) = obj;
|
||||
return;
|
||||
}
|
||||
}
|
||||
as3vm_exception_GC(vm, 0x78);
|
||||
}
|
||||
|
||||
/* Real: parse a line index (>= 0), build a wide string of the line's text by
|
||||
* walking the char nodes. Bad args or an out-of-range line raises 0x78
|
||||
* (raw:584). DEFERRED structurally (needs the engine to fill the line span). */
|
||||
void as3vm_TextField_getLineText(void *frame) {
|
||||
int idx = 0;
|
||||
if (as3vm_component_parse_arguments_GC(frame, TFF_FMT_D, &idx) == 0 &&
|
||||
idx >= 0) {
|
||||
unsigned char q[0x60];
|
||||
void *info;
|
||||
void *node;
|
||||
void *str;
|
||||
void *strdata;
|
||||
int len;
|
||||
int skip;
|
||||
int written = 0;
|
||||
TFQ_I(q, 0x34) = idx;
|
||||
TFQ_I(q, 0x00) = 0;
|
||||
TFQ_I(q, 0x40) = 0;
|
||||
TFQ_I(q, 0x14) = -2;
|
||||
info = TF_INFO(frame);
|
||||
iggy_textfield_compute_info(ENGINE(frame), info, q);
|
||||
if (TFQ_I(q, 0x34) == -1) {
|
||||
as3vm_exception_GC(VM(frame), 0x78);
|
||||
return;
|
||||
}
|
||||
len = TFQ_I(q, 0x3c); /* line char count. */
|
||||
str = as3vm_make_string_wc_GC(VM(frame), (void *)0, len);
|
||||
strdata = *(void **)AT(str, STR_HDR);
|
||||
/* locate the node holding the line start (TFQ_I(q,0x40) = start char). */
|
||||
skip = 0;
|
||||
{
|
||||
int acc = 0;
|
||||
for (node = *(void **)AT(info, I_LINEHEAD); node != (void *)0;
|
||||
node = *(void **)AT(node, N_NEXT)) {
|
||||
if (*(void **)AT(node, N_TEXT) != (void *)0) {
|
||||
int c = *(int32_t *)AT(node, N_COUNT) + acc;
|
||||
if (TFQ_I(q, 0x40) < c) {
|
||||
skip = TFQ_I(q, 0x40) - acc;
|
||||
break;
|
||||
}
|
||||
acc = c;
|
||||
}
|
||||
}
|
||||
}
|
||||
while (node != (void *)0 && written < len) {
|
||||
if (*(void **)AT(node, N_TEXT) == (void *)0) {
|
||||
*(uint16_t *)AT(strdata, STR_DATA + (intptr_t)written * 2) = 0x20;
|
||||
++written;
|
||||
} else {
|
||||
int c = *(int32_t *)AT(node, N_COUNT) - skip;
|
||||
if (len < c + written) {
|
||||
c = len - written;
|
||||
}
|
||||
memcpy(AT(strdata, STR_DATA + (intptr_t)written * 2),
|
||||
(char *)*(void **)AT(node, N_TEXT) + (intptr_t)skip * 2,
|
||||
(__SIZE_TYPE__)c * 2);
|
||||
skip = 0;
|
||||
written += c;
|
||||
}
|
||||
node = *(void **)AT(node, N_NEXT);
|
||||
}
|
||||
store_ptr(frame, str);
|
||||
return;
|
||||
}
|
||||
as3vm_exception_GC(VM(frame), 0x78);
|
||||
}
|
||||
|
||||
/* ======================================================================== */
|
||||
/* getTextFormat / setTextFormat */
|
||||
/* ======================================================================== */
|
||||
|
||||
/* Real: parse (?begin, ?end), walk the char nodes over the range, collapse every
|
||||
* format attribute (NaN / 0x80000000 / 2 mark "mixed"), and build a merged
|
||||
* TextFormat object. Bad args -> 0x78 (raw:708). DEFERRED structurally (the
|
||||
* chunk-format layout is transcribed but only reachable with a laid-out field).
|
||||
*/
|
||||
void as3vm_TextField_getTextFormat(void *frame) {
|
||||
int begin = -1;
|
||||
int end = -1;
|
||||
void *vm = VM(frame);
|
||||
void *info;
|
||||
void *node;
|
||||
int total = 0;
|
||||
int have = 0;
|
||||
int pos = 0;
|
||||
unsigned char merged[0x60];
|
||||
void *obj;
|
||||
if (as3vm_component_parse_arguments_GC(frame, TFF_FMT_OPT_DD, &begin, &end) !=
|
||||
0) {
|
||||
as3vm_exception_GC(vm, 0x78);
|
||||
return;
|
||||
}
|
||||
memset(merged, 0, sizeof(merged));
|
||||
info = TF_INFO(frame);
|
||||
total = tff_count_chars(info);
|
||||
if (end < 0) {
|
||||
end = total;
|
||||
if (begin >= 0) {
|
||||
end = begin + 1;
|
||||
}
|
||||
}
|
||||
if (total < end) {
|
||||
end = total;
|
||||
}
|
||||
if (begin < 0) {
|
||||
begin = 0;
|
||||
}
|
||||
if (end < begin) {
|
||||
begin = end;
|
||||
}
|
||||
for (node = *(void **)AT(info, I_LINEHEAD); node != (void *)0;
|
||||
node = *(void **)AT(node, N_NEXT)) {
|
||||
int count = *(int32_t *)AT(node, N_COUNT);
|
||||
if (pos < end && begin < count + pos) {
|
||||
if (have == 0) {
|
||||
memcpy(merged, node, F_BODY_BYTES);
|
||||
have = 1;
|
||||
} else {
|
||||
merge_format((void *)0, merged, node);
|
||||
}
|
||||
}
|
||||
pos += count;
|
||||
}
|
||||
obj = as3vm_make_object_no_constructor_GC(vm, *(void **)AT(vm, VM_TFCLASS));
|
||||
memcpy(AT(obj, F_DEFAULT_ROOT), merged, F_BODY_BYTES);
|
||||
store_ptr(frame, obj);
|
||||
}
|
||||
|
||||
/* Real: parse (TextFormat, ?begin, ?end), split the char nodes at the range
|
||||
* boundaries and merge the format into each spanned node, then update styles and
|
||||
* reflow. Bad args -> 0x78 (raw:1658). DEFERRED structurally. */
|
||||
void as3vm_TextField_setTextFormat(void *frame) {
|
||||
void *fmt = (void *)0;
|
||||
int begin = -1;
|
||||
int end = -1;
|
||||
void *engine = ENGINE(frame);
|
||||
void *info;
|
||||
void *node;
|
||||
int total = 0;
|
||||
int pos = 0;
|
||||
if (as3vm_component_parse_arguments_GC(frame, TFF_FMT_O_DD,
|
||||
*(void **)AT(VM(frame), VM_TFCLASS),
|
||||
&fmt, &begin, &end) != 0) {
|
||||
as3vm_exception_GC(VM(frame), 0x78);
|
||||
return;
|
||||
}
|
||||
info = TF_INFO(frame);
|
||||
total = tff_count_chars(info);
|
||||
if (end < 0) {
|
||||
if (begin < 0) {
|
||||
begin = 0;
|
||||
end = total;
|
||||
} else {
|
||||
end = begin + 1;
|
||||
}
|
||||
}
|
||||
if (total < end) {
|
||||
end = total;
|
||||
}
|
||||
if (end < begin) {
|
||||
begin = end;
|
||||
}
|
||||
for (node = *(void **)AT(info, I_LINEHEAD); node != (void *)0;) {
|
||||
int count = *(int32_t *)AT(node, N_COUNT);
|
||||
if (pos < end && begin < count + pos) {
|
||||
void *target = node;
|
||||
if (pos < begin) {
|
||||
if (end < count + pos) {
|
||||
split_chunk(engine, node, end - pos);
|
||||
}
|
||||
split_chunk(engine, node, begin - pos);
|
||||
target = *(void **)AT(node, N_NEXT);
|
||||
} else if (end < count + pos) {
|
||||
split_chunk(engine, node, end - pos);
|
||||
}
|
||||
merge_format(engine, target, AT(fmt, OFF_HANDLE));
|
||||
}
|
||||
pos += count;
|
||||
node = *(void **)AT(node, N_NEXT);
|
||||
}
|
||||
iggy_textfield_update_styles(engine, info);
|
||||
iggy_textfield_reflow(engine, info);
|
||||
}
|
||||
|
||||
/* ======================================================================== */
|
||||
/* File statics (durango source_functions == 129) */
|
||||
/* ======================================================================== */
|
||||
|
||||
/* Copy the char range [begin, end) out of the char-node list into a fresh
|
||||
* string, pushing the source object as a GC temp-root across the allocation
|
||||
* (raw:3332). */
|
||||
static void *get_text_range_GC(void *vm, void *obj, int begin, int end) {
|
||||
void **root = *(void ***)AT(vm, VM_STACKPTR);
|
||||
void *sd;
|
||||
void *info;
|
||||
void *node;
|
||||
int pos = 0;
|
||||
*root = obj;
|
||||
*(char **)AT(vm, VM_STACKPTR) = (char *)(root + 1);
|
||||
sd = as3vm_make_stringdata_GC(vm, (void *)0, end - begin);
|
||||
root = *(void ***)AT(vm, VM_STACKPTR);
|
||||
*(char **)AT(vm, VM_STACKPTR) = (char *)(root - 1);
|
||||
obj = root[-1];
|
||||
info = *(void **)AT(*(void **)AT(obj, OFF_HANDLE), OFF_INFO);
|
||||
for (node = *(void **)AT(info, I_LINEHEAD); node != (void *)0;
|
||||
node = *(void **)AT(node, N_NEXT)) {
|
||||
int count = *(int32_t *)AT(node, N_COUNT);
|
||||
if (pos < end && begin < count + pos) {
|
||||
int stop = count + pos;
|
||||
int start = pos;
|
||||
if (end < stop) {
|
||||
stop = end;
|
||||
}
|
||||
if (start < begin) {
|
||||
start = begin;
|
||||
}
|
||||
memcpy(AT(sd, STR_DATA + (intptr_t)(start - begin) * 2),
|
||||
(char *)*(void **)AT(node, N_TEXT) + (intptr_t)(start - pos) * 2,
|
||||
(__SIZE_TYPE__)(stop - start) * 2);
|
||||
}
|
||||
pos += count;
|
||||
}
|
||||
return as3vm_make_string_GC(vm, sd);
|
||||
}
|
||||
|
||||
/* Merge every non-"unset" format attribute from src into dst: floats guarded by
|
||||
* rr_isnan, the color by 0x80000000, the tri-state bytes by 2, the font ptr by
|
||||
* NULL (raw:3371). */
|
||||
static void merge_format(void *vm, void *dst, void *src) {
|
||||
/* Offsets are relative to the format-body root; expressing them as
|
||||
* (F_field - F_DEFAULT_ROOT) auto-adapts to the 64-bit (durango raw:3371) and
|
||||
* 32-bit (vita raw:1938 / ps3) layouts. 64-bit floats resolve to
|
||||
* {0x10,0x14,0x28,0x18,0x1c,0x20,0x24}, color 0x2c, align 0x52, tristates
|
||||
* 0x53-0x57, font 0x08; 32-bit to {0x08,0x0c,0x20,0x10,0x14,0x18,0x1c}, color
|
||||
* 0x24, align 0x4a, tristates 0x4b-0x4f, font 0x04. */
|
||||
static const int float_fields[7] = {
|
||||
F_SIZE - F_DEFAULT_ROOT, F_BLOCKINDENT - F_DEFAULT_ROOT,
|
||||
F_LETTERSPACING - F_DEFAULT_ROOT, F_INDENT - F_DEFAULT_ROOT,
|
||||
F_LEADING - F_DEFAULT_ROOT, F_LEFTMARGIN - F_DEFAULT_ROOT,
|
||||
F_RIGHTMARGIN - F_DEFAULT_ROOT};
|
||||
const int color_off = F_COLOR - F_DEFAULT_ROOT;
|
||||
const int align_off = F_ALIGN - F_DEFAULT_ROOT;
|
||||
const int font_off = F_FONT - F_DEFAULT_ROOT;
|
||||
int i;
|
||||
(void)vm;
|
||||
for (i = 0; i < 7; ++i) {
|
||||
int off = float_fields[i];
|
||||
if (!tff_isnan_f(*(float *)AT(src, off))) {
|
||||
*(uint32_t *)AT(dst, off) = *(uint32_t *)AT(src, off);
|
||||
}
|
||||
}
|
||||
if (*(int32_t *)AT(src, color_off) != (int32_t)0x80000000) {
|
||||
*(int32_t *)AT(dst, color_off) = *(int32_t *)AT(src, color_off);
|
||||
}
|
||||
if (*(char *)AT(src, align_off) != '\x04') {
|
||||
*(char *)AT(dst, align_off) = *(char *)AT(src, align_off);
|
||||
}
|
||||
for (i = align_off + 1; i <= align_off + 5; ++i) {
|
||||
if (*(char *)AT(src, i) != '\x02') {
|
||||
*(char *)AT(dst, i) = *(char *)AT(src, i);
|
||||
}
|
||||
}
|
||||
if (*(void **)AT(src, font_off) != (void *)0) {
|
||||
*(void **)AT(dst, font_off) = *(void **)AT(src, font_off);
|
||||
}
|
||||
}
|
||||
|
||||
/* Split a char node at `at`, allocating a fresh trailing node that inherits the
|
||||
* format body and takes ownership of the tail char buffer (raw:3448). */
|
||||
static void split_chunk(void *vm, void *node, int at) {
|
||||
int tail = *(int32_t *)AT(node, N_COUNT) - at;
|
||||
void *tail_node = iggy_malloc_fileline(vm, 0, N_ALLOC_SIZE, 0x19,
|
||||
iggy_swf_as3_textfield_source_path,
|
||||
0x475);
|
||||
void *tail_text = iggy_malloc_fileline(vm, 0, tail * 4, 0x1a,
|
||||
iggy_swf_as3_textfield_source_path,
|
||||
0x476);
|
||||
*(void **)AT(tail_node, N_TEXT) = tail_text;
|
||||
memcpy(tail_text, (char *)*(void **)AT(node, N_TEXT) + (intptr_t)at * 2,
|
||||
(__SIZE_TYPE__)tail * 2);
|
||||
*(int32_t *)AT(tail_node, N_COUNT) = tail;
|
||||
memcpy(AT(tail_node, 0), AT(node, 0), F_BODY_BYTES); /* fmt header. */
|
||||
*(void **)AT(tail_node, N_NEXT) = *(void **)AT(node, N_NEXT);
|
||||
*(void **)AT(node, N_NEXT) = tail_node;
|
||||
*(int32_t *)AT(node, N_COUNT) = at;
|
||||
}
|
||||
333
iggy-decompiled/src/reconstructed/swf_as3_textfield_tf_set.inc
Normal file
333
iggy-decompiled/src/reconstructed/swf_as3_textfield_tf_set.inc
Normal file
@@ -0,0 +1,333 @@
|
||||
/*
|
||||
* swf_as3_textfield_tf_set.inc -- flash.text.TextField __construct + property
|
||||
* setters. Included by swf_as3_textfield.c.
|
||||
*/
|
||||
|
||||
/* Real: chain to the InteractiveObject base constructor (raw:207). */
|
||||
void as3vm_TextField__construct(void *frame) {
|
||||
as3vm_InteractiveObject__construct(frame);
|
||||
}
|
||||
|
||||
/* Real: parse an enum, accept 0x3c/0x3d, store the flag (raw:1743). */
|
||||
void as3vm_TextField_set_antiAliasType(void *frame) {
|
||||
int value = 0;
|
||||
if (as3vm_component_parse_arguments_GC(frame, TFF_FMT_K, &value) == 0 &&
|
||||
(uint32_t)(value - 0x3c) < 2u) {
|
||||
*(uint8_t *)AT(TF_INFO(frame), I_ANTIALIAS) = (uint8_t)(value != 0x3d);
|
||||
return;
|
||||
}
|
||||
as3vm_exception_GC(VM(frame), 0x78);
|
||||
}
|
||||
|
||||
/* Real: parse an enum, match it against the autoSize codes, store the index,
|
||||
* capture the width and reflow. Bad args -> 0x78 (raw:1763). */
|
||||
void as3vm_TextField_set_autoSize(void *frame) {
|
||||
int value = 0;
|
||||
int i;
|
||||
if (as3vm_component_parse_arguments_GC(frame, TFF_FMT_K, &value) == 0) {
|
||||
for (i = 0; i < 4; ++i) {
|
||||
if (tff_autosize_codes[i] == value) {
|
||||
void *info = TF_INFO(frame);
|
||||
*(uint8_t *)AT(info, I_AUTOSIZE) = (uint8_t)i;
|
||||
*(uint32_t *)AT(info, I_AUTOSIZE_W) = *(uint32_t *)AT(info, I_SCALEX);
|
||||
iggy_textfield_reflow(ENGINE(frame), info);
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
as3vm_exception_GC(VM(frame), 0x78);
|
||||
}
|
||||
|
||||
/* Real: parse a uint, mask to 24 bits, write backgroundColor. A parse failure
|
||||
* raises 0x78 (raw:1795; pinned). */
|
||||
void as3vm_TextField_set_backgroundColor(void *frame) {
|
||||
uint32_t value = 0;
|
||||
if (as3vm_component_parse_arguments_GC(frame, TFF_FMT_U, &value) != 0) {
|
||||
as3vm_exception_GC(VM(frame), 0x78);
|
||||
return;
|
||||
}
|
||||
*(uint32_t *)AT(TF_INFO(frame), I_BGCOLOR) = value & 0xffffffu;
|
||||
}
|
||||
|
||||
/* Real: parse a uint, mask to 24 bits, write borderColor. A parse failure
|
||||
* raises 0x78 (raw:1815; pinned). */
|
||||
void as3vm_TextField_set_borderColor(void *frame) {
|
||||
uint32_t value = 0;
|
||||
if (as3vm_component_parse_arguments_GC(frame, TFF_FMT_U, &value) != 0) {
|
||||
as3vm_exception_GC(VM(frame), 0x78);
|
||||
return;
|
||||
}
|
||||
*(uint32_t *)AT(TF_INFO(frame), I_BORDERCOLOR) = value & 0xffffffu;
|
||||
}
|
||||
|
||||
/* Real: parse a TextFormat and merge it into the embedded default format. A
|
||||
* parse failure raises 0x78 (raw:1835). */
|
||||
void as3vm_TextField_set_defaultTextFormat(void *frame) {
|
||||
void *fmt = (void *)0;
|
||||
if (as3vm_component_parse_arguments_GC(frame, TFF_FMT_O,
|
||||
*(void **)AT(VM(frame), VM_TFCLASS),
|
||||
&fmt) != 0) {
|
||||
as3vm_exception_GC(VM(frame), 0x78);
|
||||
return;
|
||||
}
|
||||
merge_format(ENGINE(frame), AT(TF_INFO(frame), I_DEFAULTFMT),
|
||||
AT(fmt, OFF_HANDLE));
|
||||
}
|
||||
|
||||
/* Real: parse an enum, match it against the gridFit codes, store the index. Bad
|
||||
* args -> 0x78 (raw:1858). */
|
||||
void as3vm_TextField_set_gridFitType(void *frame) {
|
||||
int value = 0;
|
||||
int i;
|
||||
if (as3vm_component_parse_arguments_GC(frame, TFF_FMT_K, &value) == 0) {
|
||||
for (i = 0; i < 3; ++i) {
|
||||
if (tff_gridfit_codes[i] == value) {
|
||||
*(uint8_t *)AT(TF_INFO(frame), I_GRIDFIT) = (uint8_t)i;
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
as3vm_exception_GC(VM(frame), 0x78);
|
||||
}
|
||||
|
||||
/* Real: parse a float, forward to the layout engine. Bad args -> 0x78
|
||||
* (raw:1885). */
|
||||
void as3vm_TextField_set_height(void *frame) {
|
||||
float value = 0.0f;
|
||||
if (as3vm_component_parse_arguments_GC(frame, TFF_FMT_F, &value) != 0) {
|
||||
as3vm_exception_GC(VM(frame), 0x78);
|
||||
return;
|
||||
}
|
||||
iggy_textfield_set_height(ENGINE(frame), TF_INFO(frame), value);
|
||||
}
|
||||
|
||||
/* Real: parse a string, hand it to the HTML text engine. Bad args -> 0x78
|
||||
* (raw:1906). */
|
||||
void as3vm_TextField_set_htmlText(void *frame) {
|
||||
void *arg = (void *)0;
|
||||
void *strdata;
|
||||
if (as3vm_component_parse_arguments_GC(frame, TFF_FMT_S, &arg) != 0) {
|
||||
as3vm_exception_GC(VM(frame), 0x78);
|
||||
return;
|
||||
}
|
||||
strdata = *(void **)AT(arg, STR_HDR);
|
||||
iggy_set_textfield_htmltext(ENGINE(frame), TF_INFO(frame),
|
||||
AT(strdata, STR_DATA),
|
||||
*(int32_t *)AT(strdata, STR_HDR));
|
||||
}
|
||||
|
||||
/* Real: parse an int, write maxChars. Bad args -> 0x78 (raw:1929). */
|
||||
void as3vm_TextField_set_maxChars(void *frame) {
|
||||
int32_t value = 0;
|
||||
if (as3vm_component_parse_arguments_GC(frame, TFF_FMT_D, &value) != 0) {
|
||||
as3vm_exception_GC(VM(frame), 0x78);
|
||||
return;
|
||||
}
|
||||
*(int32_t *)AT(TF_INFO(frame), I_MAXCHARS) = value;
|
||||
}
|
||||
|
||||
/* Real: parse a bool, set the multiline flag pair, reflow. Bad args -> 0x78
|
||||
* (raw:1949). */
|
||||
void as3vm_TextField_set_multiline(void *frame) {
|
||||
int value = 0;
|
||||
void *info;
|
||||
if (as3vm_component_parse_arguments_GC(frame, TFF_FMT_B, &value) != 0) {
|
||||
as3vm_exception_GC(VM(frame), 0x78);
|
||||
return;
|
||||
}
|
||||
info = TF_INFO(frame);
|
||||
*(uint8_t *)AT(info, I_MULTILINE) = (uint8_t)value;
|
||||
*(uint8_t *)AT(info, I_MULTILINE2) = (uint8_t)(value == 0);
|
||||
iggy_textfield_reflow(ENGINE(frame), info);
|
||||
}
|
||||
|
||||
/* Real: parse an optional string, (re)allocate and copy the restrict buffer. A
|
||||
* parse failure raises 0x78 (raw:1974). */
|
||||
void as3vm_TextField_set_restrict(void *frame) {
|
||||
void *arg = TFF_UNDEF_CELL;
|
||||
void *info;
|
||||
if (as3vm_component_parse_arguments_GC(frame, TFF_FMT_OPT_S, &arg) != 0) {
|
||||
as3vm_exception_GC(VM(frame), 0x78);
|
||||
return;
|
||||
}
|
||||
info = TF_INFO(frame);
|
||||
if (*(void **)AT(info, I_RESTRICT) != (void *)0) {
|
||||
iggy_free_alloc(ENGINE(frame));
|
||||
*(void **)AT(info, I_RESTRICT) = (void *)0;
|
||||
}
|
||||
if (arg != TFF_UNDEF_CELL) {
|
||||
void *strdata = *(void **)AT(arg, STR_HDR);
|
||||
int len = *(int32_t *)AT(strdata, STR_HDR);
|
||||
if (len != 0) {
|
||||
uint16_t *buf;
|
||||
if (len > 0xffff) {
|
||||
len = 0x10000;
|
||||
}
|
||||
buf = (uint16_t *)iggy_malloc_fileline(
|
||||
ENGINE(frame), 0, len * 2 + 2, 0x17,
|
||||
iggy_swf_as3_textfield_source_path, 0x148);
|
||||
*(uint16_t **)AT(info, I_RESTRICT) = buf;
|
||||
*buf = (uint16_t)len;
|
||||
memcpy((char *)*(uint16_t **)AT(info, I_RESTRICT) + 2,
|
||||
AT(strdata, STR_DATA), (__SIZE_TYPE__)len * 2);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* Real: parse an int, clamp against maxScrollH, floor at 0, store (raw:2017). */
|
||||
void as3vm_TextField_set_scrollH(void *frame) {
|
||||
int value = 0;
|
||||
void *info;
|
||||
float bound;
|
||||
if (as3vm_component_parse_arguments_GC(frame, TFF_FMT_D, &value) != 0) {
|
||||
as3vm_exception_GC(VM(frame), 0x78);
|
||||
return;
|
||||
}
|
||||
info = TF_INFO(frame);
|
||||
bound = *(float *)AT(info, I_TEXTWIDTH) -
|
||||
((*(float *)AT(info, I_SCALEX) - TFF_F_SIX) - TFF_F_THREE);
|
||||
if (bound < (float)value) {
|
||||
value = (int)bound;
|
||||
}
|
||||
if (value < 0) {
|
||||
value = 0;
|
||||
}
|
||||
*(int32_t *)AT(info, I_SCROLLH) = value;
|
||||
}
|
||||
|
||||
/* Real: parse an int, clamp against maxScrollV, floor at 0, store (raw:2049). */
|
||||
void as3vm_TextField_set_scrollV(void *frame) {
|
||||
int value = 0;
|
||||
void *info;
|
||||
int bound;
|
||||
int clamped;
|
||||
if (as3vm_component_parse_arguments_GC(frame, TFF_FMT_D, &value) != 0) {
|
||||
as3vm_exception_GC(VM(frame), 0x78);
|
||||
return;
|
||||
}
|
||||
info = TF_INFO(frame);
|
||||
bound = *(int32_t *)AT(info, I_MAXSCROLLV);
|
||||
clamped = value - 1;
|
||||
if (bound <= clamped) {
|
||||
clamped = bound;
|
||||
}
|
||||
if (clamped <= 0) {
|
||||
clamped = 0;
|
||||
}
|
||||
*(int32_t *)AT(info, I_SCROLLV) = clamped;
|
||||
}
|
||||
|
||||
/* Real: parse a float, clamp to [-400, 400], store as sharpness (raw:2080). */
|
||||
void as3vm_TextField_set_sharpness(void *frame) {
|
||||
float value = 0.0f;
|
||||
if (as3vm_component_parse_arguments_GC(frame, TFF_FMT_F, &value) != 0) {
|
||||
as3vm_exception_GC(VM(frame), 0x78);
|
||||
return;
|
||||
}
|
||||
if (value < TFF_F_NEG200) {
|
||||
value = TFF_F_NEG200;
|
||||
} else if (value > TFF_F_POS200) {
|
||||
value = TFF_F_POS200;
|
||||
}
|
||||
*(float *)AT(TF_INFO(frame), I_SHARPNESS) = value;
|
||||
}
|
||||
|
||||
/* Real: styleSheet is unsupported -> 0x78 (raw:2106). */
|
||||
void as3vm_TextField_set_styleSheet(void *frame) {
|
||||
as3vm_exception_GC(VM(frame), 0x78);
|
||||
}
|
||||
|
||||
/* Real: parse a string, hand it to the text engine (replace mode). Bad args ->
|
||||
* 0x78 (raw:2117). */
|
||||
void as3vm_TextField_set_text(void *frame) {
|
||||
void *arg = (void *)0;
|
||||
void *strdata;
|
||||
if (as3vm_component_parse_arguments_GC(frame, TFF_FMT_S, &arg) != 0) {
|
||||
as3vm_exception_GC(VM(frame), 0x78);
|
||||
return;
|
||||
}
|
||||
strdata = *(void **)AT(arg, STR_HDR);
|
||||
iggy_set_textfield_text(ENGINE(frame), TF_INFO(frame),
|
||||
AT(strdata, STR_DATA),
|
||||
*(int32_t *)AT(strdata, STR_HDR), 0);
|
||||
}
|
||||
|
||||
/* Real: parse a uint, store textColor and mirror it into every line node. Bad
|
||||
* args -> 0x78 (raw:2140). */
|
||||
void as3vm_TextField_set_textColor(void *frame) {
|
||||
uint32_t value = 0;
|
||||
void *info;
|
||||
void *node;
|
||||
if (as3vm_component_parse_arguments_GC(frame, TFF_FMT_U, &value) != 0) {
|
||||
as3vm_exception_GC(VM(frame), 0x78);
|
||||
return;
|
||||
}
|
||||
info = TF_INFO(frame);
|
||||
*(uint32_t *)AT(info, I_TEXTCOLOR) = value;
|
||||
for (node = *(void **)AT(info, I_LINEHEAD); node != (void *)0;
|
||||
node = *(void **)AT(node, N_NEXT)) {
|
||||
*(uint32_t *)AT(node, N_COLOR) = value;
|
||||
}
|
||||
}
|
||||
|
||||
/* Real: parse a float, clamp to [-400, 400], store as thickness (raw:2166). */
|
||||
void as3vm_TextField_set_thickness(void *frame) {
|
||||
float value = 0.0f;
|
||||
if (as3vm_component_parse_arguments_GC(frame, TFF_FMT_F, &value) != 0) {
|
||||
as3vm_exception_GC(VM(frame), 0x78);
|
||||
return;
|
||||
}
|
||||
if (value < TFF_F_NEG200) {
|
||||
value = TFF_F_NEG200;
|
||||
} else if (value > TFF_F_POS200) {
|
||||
value = TFF_F_POS200;
|
||||
}
|
||||
*(float *)AT(TF_INFO(frame), I_SHARPNESS) = value;
|
||||
}
|
||||
|
||||
/* Real: parse an enum, accept 0x41/0x42, store the type flag and mirror it into
|
||||
* the handle's input-type bit. Bad args -> 0x78 (raw:2192). */
|
||||
void as3vm_TextField_set_type(void *frame) {
|
||||
int value = 0;
|
||||
if (as3vm_component_parse_arguments_GC(frame, TFF_FMT_K, &value) == 0 &&
|
||||
(uint32_t)(value - 0x41) < 2u) {
|
||||
void *handle = *(void **)AT(THISOBJ(frame), OFF_HANDLE);
|
||||
uint8_t *flags = (uint8_t *)handle;
|
||||
*(uint8_t *)AT(TF_INFO(frame), I_TYPE) = (uint8_t)(value == 0x42);
|
||||
if ((*flags & HND_TYPEFLAG_BIT) == 0) {
|
||||
uint8_t *tf = (uint8_t *)AT(handle, HND_TYPEFLAG);
|
||||
if (value == 0x42) {
|
||||
*tf = (uint8_t)(*tf | HND_TYPEFLAG_BIT);
|
||||
} else {
|
||||
*tf = (uint8_t)(*tf & (uint8_t)~HND_TYPEFLAG_BIT);
|
||||
}
|
||||
}
|
||||
return;
|
||||
}
|
||||
as3vm_exception_GC(VM(frame), 0x78);
|
||||
}
|
||||
|
||||
/* Real: parse a float, forward to the layout engine. Bad args -> 0x78
|
||||
* (raw:2217). */
|
||||
void as3vm_TextField_set_width(void *frame) {
|
||||
float value = 0.0f;
|
||||
if (as3vm_component_parse_arguments_GC(frame, TFF_FMT_F, &value) != 0) {
|
||||
as3vm_exception_GC(VM(frame), 0x78);
|
||||
return;
|
||||
}
|
||||
iggy_textfield_set_width(ENGINE(frame), TF_INFO(frame), value);
|
||||
}
|
||||
|
||||
/* Real: parse a bool, store the wordWrap flag, reflow. Bad args -> 0x78
|
||||
* (raw:2238). */
|
||||
void as3vm_TextField_set_wordWrap(void *frame) {
|
||||
uint8_t value = 0;
|
||||
void *info;
|
||||
if (as3vm_component_parse_arguments_GC(frame, TFF_FMT_B, &value) != 0) {
|
||||
as3vm_exception_GC(VM(frame), 0x78);
|
||||
return;
|
||||
}
|
||||
info = TF_INFO(frame);
|
||||
*(uint8_t *)AT(info, I_WORDWRAP) = value;
|
||||
iggy_textfield_reflow(ENGINE(frame), info);
|
||||
}
|
||||
57
iggy-decompiled/src/reconstructed/swf_as3_textfield_tlm.inc
Normal file
57
iggy-decompiled/src/reconstructed/swf_as3_textfield_tlm.inc
Normal file
@@ -0,0 +1,57 @@
|
||||
/*
|
||||
* swf_as3_textfield_tlm.inc -- flash.text.TextLineMetrics. The constructor and
|
||||
* all six setters are pure "unsupported" 0x74 stubs; the six getters box a float
|
||||
* field of the object directly. Included by swf_as3_textfield.c.
|
||||
*/
|
||||
|
||||
/* Box a TextLineMetrics float field as a number. */
|
||||
static void tff_tlm_get(void *frame, int off) {
|
||||
store_ptr(frame,
|
||||
as3vm_make_number_GC(VM(frame),
|
||||
(double)*(float *)AT(THISOBJ(frame), off)));
|
||||
}
|
||||
|
||||
/* Pure 0x74 stub: TextLineMetrics is not user-constructible (raw:3077). */
|
||||
void as3vm_TextLineMetrics__construct(void *frame) {
|
||||
as3vm_exception_GC(VM(frame), 0x74);
|
||||
}
|
||||
|
||||
/* Real getters (raw:3088/3104/3120/3136/3152/3168). */
|
||||
void as3vm_TextLineMetrics_get_ascent(void *frame) {
|
||||
tff_tlm_get(frame, M_ASCENT);
|
||||
}
|
||||
void as3vm_TextLineMetrics_get_descent(void *frame) {
|
||||
tff_tlm_get(frame, M_DESCENT);
|
||||
}
|
||||
void as3vm_TextLineMetrics_get_height(void *frame) {
|
||||
tff_tlm_get(frame, M_HEIGHT);
|
||||
}
|
||||
void as3vm_TextLineMetrics_get_leading(void *frame) {
|
||||
tff_tlm_get(frame, M_LEADING);
|
||||
}
|
||||
void as3vm_TextLineMetrics_get_width(void *frame) {
|
||||
tff_tlm_get(frame, M_WIDTH);
|
||||
}
|
||||
void as3vm_TextLineMetrics_get_x(void *frame) {
|
||||
tff_tlm_get(frame, M_X);
|
||||
}
|
||||
|
||||
/* Pure 0x74 stubs: the setters are unsupported (raw:3184-3244). */
|
||||
void as3vm_TextLineMetrics_set_ascent(void *frame) {
|
||||
as3vm_exception_GC(VM(frame), 0x74);
|
||||
}
|
||||
void as3vm_TextLineMetrics_set_descent(void *frame) {
|
||||
as3vm_exception_GC(VM(frame), 0x74);
|
||||
}
|
||||
void as3vm_TextLineMetrics_set_height(void *frame) {
|
||||
as3vm_exception_GC(VM(frame), 0x74);
|
||||
}
|
||||
void as3vm_TextLineMetrics_set_leading(void *frame) {
|
||||
as3vm_exception_GC(VM(frame), 0x74);
|
||||
}
|
||||
void as3vm_TextLineMetrics_set_width(void *frame) {
|
||||
as3vm_exception_GC(VM(frame), 0x74);
|
||||
}
|
||||
void as3vm_TextLineMetrics_set_x(void *frame) {
|
||||
as3vm_exception_GC(VM(frame), 0x74);
|
||||
}
|
||||
457
tests/support/swf_as3_textfield_test_support.c
Normal file
457
tests/support/swf_as3_textfield_test_support.c
Normal file
@@ -0,0 +1,457 @@
|
||||
/*
|
||||
* Host harness for the reconstructed swf_as3_textfield translation unit.
|
||||
*
|
||||
* swf_as3_textfield is Iggy's AS3 / AVM2 text-and-font binding layer: the
|
||||
* flash.text.Font, TextField, TextFormat and TextLineMetrics classes plus the
|
||||
* two object factories as3vm_make_font_GC / as3vm_make_textformat_GC and the two
|
||||
* shared thin accessors as3vm_textfield_bool_getter / _bool_setter. It exports
|
||||
* EXACTLY 126 entry points on all four platforms (durango / orbis / ps3 / vita);
|
||||
* the durango decompile additionally recovers file-static helpers so the durango
|
||||
* source_functions count is 129 vs 127 on the other three platforms.
|
||||
*
|
||||
* BODY CLASSIFICATION (recovered from raw/durango, cross-checked vs orbis / ps3 /
|
||||
* vita) -- the 126 exports are MOSTLY REAL, NOT uniform. There are 70
|
||||
* as3vm_exception_GC calls total: NINE raise 0x74 and SIXTY-ONE raise 0x78.
|
||||
* EIGHT are pure "unsupported" stubs -- each `as3vm_exception_GC(vm, 0x74)`
|
||||
* only, no field access:
|
||||
* Font_registerFont, TextLineMetrics__construct and the six
|
||||
* TextLineMetrics setters (set_ascent / _descent / _height / _leading /
|
||||
* _width / _x).
|
||||
* The NINTH 0x74 lives inside the REAL Font__construct (the else branch when no
|
||||
* pending native font buffer is present -- analogous to ByteArray__construct in
|
||||
* swf_as3_misc).
|
||||
* The SIXTY-ONE 0x78 raises are the bad-args tails of REAL bodies (parse
|
||||
* failure or an out-of-range index): every setter that parses arguments, the
|
||||
* text methods (appendText / getLineOffset / getParagraphLength / replaceText /
|
||||
* ...) and Font_hasGlyphs.
|
||||
* Everything else is a REAL body: property getters that read a native-object
|
||||
* field and box it, property setters that parse then write a field, the object
|
||||
* factories, and the deep text-layout methods that call the iggy_textfield_*
|
||||
* engine.
|
||||
*
|
||||
* OBJECT MODEL (durango 64-bit -- the runtime test builds ONLY the durango dylib
|
||||
* so the 64-bit layout is authoritative):
|
||||
* frame[0]=vm, frame[1]=&result slot (a getter writes its box to *frame[1]),
|
||||
* frame[2]=argc, frame[3]=&this-slot (holds the RAW object pointer), and for
|
||||
* the shared bool accessors frame[4]=&property-descriptor.
|
||||
* obj = *(this_slot)
|
||||
* handle = *(obj + 0x27) -- the native Font / TextField struct
|
||||
* info = *(handle + 0x98) -- the layout / format sub-struct
|
||||
* Representative TextField fields inside `info`: textColor uint @ +0x34,
|
||||
* backgroundColor uint @ +0x74, borderColor uint @ +0x78, numLines int @ +0xb4,
|
||||
* the line-node list head @ +0x60 (node+0x60 = char count, node+0x68 = next).
|
||||
* Font__construct adopts the pending native buffer at vm+0x28e0 into obj+0x27.
|
||||
* as3vm_make_font_GC builds an object from the Font class at vm+0x26e0 and
|
||||
* stores the native handle at obj+0x27.
|
||||
*
|
||||
* (32-bit ps3 / vita differ: frame stride 4, handle @ obj+0x17, info @ handle+0x50,
|
||||
* numLines @ info+0xa0, result <<1 -- flagged structural, NOT exercised here.)
|
||||
*
|
||||
* The symbols supplied below are exactly the genuine nm ' U ' imports of the
|
||||
* retail object, modelled here as recording / controllable stubs so the durango
|
||||
* dylib links and the real bodies actually run. DATA imports
|
||||
* (as3vm_makebool / as3vm_NaNf / as3vm_truefalse_storage / as3vm_nullundef_storage)
|
||||
* are defined as real storage. libm / libc (sqrt / ceil / memcpy / memset) resolve
|
||||
* from libSystem at load time.
|
||||
*/
|
||||
|
||||
#include <stdarg.h>
|
||||
#include <stdint.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
/* ---- Recording counters. ---- */
|
||||
static size_t exception_count;
|
||||
static size_t parse_count;
|
||||
static size_t make_uint_count;
|
||||
static size_t make_int_count;
|
||||
static size_t make_number_count;
|
||||
static size_t make_object_count;
|
||||
static size_t make_array_count;
|
||||
static size_t make_rectangle_count;
|
||||
static size_t make_string_count;
|
||||
static size_t make_string_c_count;
|
||||
static size_t make_string_wc_count;
|
||||
static size_t make_stringdata_count;
|
||||
static size_t free_count;
|
||||
static size_t glyph_count;
|
||||
static size_t set_text_count;
|
||||
static size_t set_htmltext_count;
|
||||
static size_t replace_text_count;
|
||||
static size_t compute_info_count;
|
||||
static size_t reflow_count;
|
||||
static size_t set_height_count;
|
||||
static size_t set_width_count;
|
||||
static size_t update_styles_count;
|
||||
static size_t interactive_ctor_count;
|
||||
static size_t write_barrier_count;
|
||||
static size_t malloc_fileline_count;
|
||||
|
||||
static int32_t last_exception_code;
|
||||
static uint32_t last_uint_arg;
|
||||
static double last_number_arg;
|
||||
static void *last_object;
|
||||
static void *last_object_class;
|
||||
static void *last_string_wc_ptr;
|
||||
static int last_string_wc_len;
|
||||
static void *last_set_text_info;
|
||||
static void *last_compute_info_info;
|
||||
static const char *last_parse_fmt;
|
||||
static int last_glyph_codepoint;
|
||||
|
||||
/* ---- Controls. ---- */
|
||||
static int parse_ret;
|
||||
static int parse_writes_out;
|
||||
static const uint8_t *parse_out_bytes;
|
||||
static size_t parse_out_len;
|
||||
static uint8_t parse_out_store[64];
|
||||
static int glyph_ret;
|
||||
|
||||
/* ---- Owned-by-sibling DATA the module indexes into. ---- */
|
||||
void *as3vm_makebool[64];
|
||||
float as3vm_NaNf;
|
||||
uint8_t as3vm_truefalse_storage[64];
|
||||
uint8_t as3vm_nullundef_storage[64];
|
||||
|
||||
/* ---- Bump pool backing the object-allocator fakes. ---- */
|
||||
static uint8_t fake_pool[1 << 20];
|
||||
static size_t fake_used;
|
||||
|
||||
static void *pool_bump(size_t size) {
|
||||
size_t base = (fake_used + 15u) & ~(size_t)15u;
|
||||
size_t rounded = (size + 15u) & ~(size_t)15u;
|
||||
if (rounded == 0u) {
|
||||
rounded = 16u;
|
||||
}
|
||||
if (base + rounded > sizeof(fake_pool)) {
|
||||
return 0;
|
||||
}
|
||||
fake_used = base + rounded;
|
||||
memset(fake_pool + base, 0, rounded);
|
||||
return fake_pool + base;
|
||||
}
|
||||
|
||||
void swf_as3_textfield_test_reset(void) {
|
||||
exception_count = 0;
|
||||
parse_count = 0;
|
||||
make_uint_count = 0;
|
||||
make_int_count = 0;
|
||||
make_number_count = 0;
|
||||
make_object_count = 0;
|
||||
make_array_count = 0;
|
||||
make_rectangle_count = 0;
|
||||
make_string_count = 0;
|
||||
make_string_c_count = 0;
|
||||
make_string_wc_count = 0;
|
||||
make_stringdata_count = 0;
|
||||
free_count = 0;
|
||||
glyph_count = 0;
|
||||
set_text_count = 0;
|
||||
set_htmltext_count = 0;
|
||||
replace_text_count = 0;
|
||||
compute_info_count = 0;
|
||||
reflow_count = 0;
|
||||
set_height_count = 0;
|
||||
set_width_count = 0;
|
||||
update_styles_count = 0;
|
||||
interactive_ctor_count = 0;
|
||||
write_barrier_count = 0;
|
||||
malloc_fileline_count = 0;
|
||||
last_exception_code = 0;
|
||||
last_uint_arg = 0;
|
||||
last_number_arg = 0.0;
|
||||
last_object = 0;
|
||||
last_object_class = 0;
|
||||
last_string_wc_ptr = 0;
|
||||
last_string_wc_len = 0;
|
||||
last_set_text_info = 0;
|
||||
last_compute_info_info = 0;
|
||||
last_parse_fmt = 0;
|
||||
last_glyph_codepoint = 0;
|
||||
parse_ret = 0;
|
||||
parse_writes_out = 0;
|
||||
parse_out_bytes = 0;
|
||||
parse_out_len = 0;
|
||||
glyph_ret = 0;
|
||||
fake_used = 0;
|
||||
memset(parse_out_store, 0, sizeof(parse_out_store));
|
||||
memset(as3vm_makebool, 0, sizeof(as3vm_makebool));
|
||||
memset(as3vm_truefalse_storage, 0, sizeof(as3vm_truefalse_storage));
|
||||
memset(as3vm_nullundef_storage, 0, sizeof(as3vm_nullundef_storage));
|
||||
as3vm_NaNf = 0.0f;
|
||||
}
|
||||
|
||||
/* ---- Count / last-value accessors. ---- */
|
||||
size_t swf_as3_textfield_test_exception_count(void) { return exception_count; }
|
||||
size_t swf_as3_textfield_test_parse_count(void) { return parse_count; }
|
||||
size_t swf_as3_textfield_test_make_uint_count(void) { return make_uint_count; }
|
||||
size_t swf_as3_textfield_test_make_int_count(void) { return make_int_count; }
|
||||
size_t swf_as3_textfield_test_make_number_count(void) { return make_number_count; }
|
||||
size_t swf_as3_textfield_test_make_object_count(void) { return make_object_count; }
|
||||
size_t swf_as3_textfield_test_make_array_count(void) { return make_array_count; }
|
||||
size_t swf_as3_textfield_test_make_rectangle_count(void) {
|
||||
return make_rectangle_count;
|
||||
}
|
||||
size_t swf_as3_textfield_test_make_string_count(void) { return make_string_count; }
|
||||
size_t swf_as3_textfield_test_make_string_c_count(void) {
|
||||
return make_string_c_count;
|
||||
}
|
||||
size_t swf_as3_textfield_test_make_string_wc_count(void) {
|
||||
return make_string_wc_count;
|
||||
}
|
||||
size_t swf_as3_textfield_test_make_stringdata_count(void) {
|
||||
return make_stringdata_count;
|
||||
}
|
||||
size_t swf_as3_textfield_test_free_count(void) { return free_count; }
|
||||
size_t swf_as3_textfield_test_glyph_count(void) { return glyph_count; }
|
||||
size_t swf_as3_textfield_test_set_text_count(void) { return set_text_count; }
|
||||
size_t swf_as3_textfield_test_set_htmltext_count(void) {
|
||||
return set_htmltext_count;
|
||||
}
|
||||
size_t swf_as3_textfield_test_replace_text_count(void) {
|
||||
return replace_text_count;
|
||||
}
|
||||
size_t swf_as3_textfield_test_compute_info_count(void) {
|
||||
return compute_info_count;
|
||||
}
|
||||
size_t swf_as3_textfield_test_reflow_count(void) { return reflow_count; }
|
||||
size_t swf_as3_textfield_test_set_height_count(void) { return set_height_count; }
|
||||
size_t swf_as3_textfield_test_set_width_count(void) { return set_width_count; }
|
||||
size_t swf_as3_textfield_test_update_styles_count(void) {
|
||||
return update_styles_count;
|
||||
}
|
||||
size_t swf_as3_textfield_test_interactive_ctor_count(void) {
|
||||
return interactive_ctor_count;
|
||||
}
|
||||
|
||||
int32_t swf_as3_textfield_test_last_exception_code(void) {
|
||||
return last_exception_code;
|
||||
}
|
||||
uint32_t swf_as3_textfield_test_last_uint_arg(void) { return last_uint_arg; }
|
||||
double swf_as3_textfield_test_last_number_arg(void) { return last_number_arg; }
|
||||
void *swf_as3_textfield_test_last_object(void) { return last_object; }
|
||||
void *swf_as3_textfield_test_last_object_class(void) { return last_object_class; }
|
||||
void *swf_as3_textfield_test_last_string_wc_ptr(void) {
|
||||
return last_string_wc_ptr;
|
||||
}
|
||||
int swf_as3_textfield_test_last_string_wc_len(void) { return last_string_wc_len; }
|
||||
void *swf_as3_textfield_test_last_set_text_info(void) {
|
||||
return last_set_text_info;
|
||||
}
|
||||
void *swf_as3_textfield_test_last_compute_info_info(void) {
|
||||
return last_compute_info_info;
|
||||
}
|
||||
int swf_as3_textfield_test_last_glyph_codepoint(void) {
|
||||
return last_glyph_codepoint;
|
||||
}
|
||||
void *swf_as3_textfield_test_makebool_base(void) { return as3vm_makebool; }
|
||||
|
||||
/* ---- Controls. ---- */
|
||||
void swf_as3_textfield_test_set_parse_ret(int value) { parse_ret = value; }
|
||||
void swf_as3_textfield_test_set_parse_out(const void *bytes, size_t len) {
|
||||
if (len > sizeof(parse_out_store)) {
|
||||
len = sizeof(parse_out_store);
|
||||
}
|
||||
memcpy(parse_out_store, bytes, len);
|
||||
parse_out_bytes = parse_out_store;
|
||||
parse_out_len = len;
|
||||
parse_writes_out = 1;
|
||||
}
|
||||
void swf_as3_textfield_test_set_glyph_ret(int value) { glyph_ret = value; }
|
||||
void swf_as3_textfield_test_set_makebool(int index, void *value) {
|
||||
if (index >= 0 && index < 64) {
|
||||
as3vm_makebool[index] = value;
|
||||
}
|
||||
}
|
||||
|
||||
/* ---- Imports (recording / controllable stubs). ---- */
|
||||
|
||||
/* as3vm_interpreter (DONE). */
|
||||
void as3vm_exception_GC(void *vm, int code) {
|
||||
(void)vm;
|
||||
last_exception_code = code;
|
||||
++exception_count;
|
||||
}
|
||||
|
||||
/* as3_component_helpers (DONE). Variadic across callers ("s", "s_u", "s_d",
|
||||
* "s_b", ...). When armed, copies parse_out_bytes into the first pointer
|
||||
* argument so the callers' out slot resolves to controllable data. */
|
||||
int as3vm_component_parse_arguments_GC(void *frame, const char *fmt, ...) {
|
||||
(void)frame;
|
||||
++parse_count;
|
||||
last_parse_fmt = fmt;
|
||||
if (parse_writes_out) {
|
||||
va_list ap;
|
||||
va_start(ap, fmt);
|
||||
void *out = va_arg(ap, void *);
|
||||
if (out && parse_out_bytes) {
|
||||
memcpy(out, parse_out_bytes, parse_out_len);
|
||||
}
|
||||
va_end(ap);
|
||||
}
|
||||
return parse_ret;
|
||||
}
|
||||
|
||||
/* as3vm_interpreter / as3vm_create number+string+object factories (DONE). */
|
||||
void *as3vm_make_object_no_constructor_GC(void *vm, void *cls) {
|
||||
(void)vm;
|
||||
++make_object_count;
|
||||
last_object_class = cls;
|
||||
last_object = pool_bump(0x100u);
|
||||
return last_object;
|
||||
}
|
||||
void *as3vm_make_uint_GC(void *vm, uint32_t value) {
|
||||
(void)vm;
|
||||
++make_uint_count;
|
||||
last_uint_arg = value;
|
||||
return pool_bump(0x10u);
|
||||
}
|
||||
void *as3vm_make_int_GC(void *vm, int32_t value) {
|
||||
(void)vm;
|
||||
++make_int_count;
|
||||
last_uint_arg = (uint32_t)value;
|
||||
return pool_bump(0x10u);
|
||||
}
|
||||
void *as3vm_make_number_GC(void *vm, double value) {
|
||||
(void)vm;
|
||||
++make_number_count;
|
||||
last_number_arg = value;
|
||||
return pool_bump(0x10u);
|
||||
}
|
||||
void *as3vm_make_array_GC(void *vm, int count) {
|
||||
(void)vm;
|
||||
(void)count;
|
||||
++make_array_count;
|
||||
return pool_bump(0x40u);
|
||||
}
|
||||
void *as3vm_make_rectangle_GC(void *vm, float a, float b, float c, float d) {
|
||||
(void)vm;
|
||||
(void)a;
|
||||
(void)b;
|
||||
(void)c;
|
||||
(void)d;
|
||||
++make_rectangle_count;
|
||||
return pool_bump(0x40u);
|
||||
}
|
||||
void *as3vm_make_string_GC(void *vm, void *text) {
|
||||
(void)vm;
|
||||
(void)text;
|
||||
++make_string_count;
|
||||
return pool_bump(0x10u);
|
||||
}
|
||||
void *as3vm_make_string_c_GC(void *vm, const char *text) {
|
||||
(void)vm;
|
||||
(void)text;
|
||||
++make_string_c_count;
|
||||
return pool_bump(0x10u);
|
||||
}
|
||||
void *as3vm_make_string_wc_GC(void *vm, void *text, int len) {
|
||||
(void)vm;
|
||||
++make_string_wc_count;
|
||||
last_string_wc_ptr = text;
|
||||
last_string_wc_len = len;
|
||||
return pool_bump(0x10u);
|
||||
}
|
||||
void *as3vm_make_stringdata_GC(void *vm, void *text, int len) {
|
||||
(void)vm;
|
||||
(void)text;
|
||||
(void)len;
|
||||
++make_stringdata_count;
|
||||
return pool_bump(0x20u);
|
||||
}
|
||||
|
||||
/* as3vm_interpreter GC write barrier (DONE). */
|
||||
void as3vm_write_barrier_slowpath(void *vm, void *obj, void *value) {
|
||||
(void)vm;
|
||||
(void)obj;
|
||||
(void)value;
|
||||
++write_barrier_count;
|
||||
}
|
||||
|
||||
/* as3vm flash.display base-class constructor chain (DONE). */
|
||||
void as3vm_InteractiveObject__construct(void *frame) {
|
||||
(void)frame;
|
||||
++interactive_ctor_count;
|
||||
}
|
||||
|
||||
/* rrmath NaN classifier (DONE). */
|
||||
int rr_isnan(double value) { return value != value; }
|
||||
|
||||
/* iggy arena (DONE). */
|
||||
void iggy_free_alloc(void *ptr) {
|
||||
(void)ptr;
|
||||
++free_count;
|
||||
}
|
||||
void *iggy_malloc_fileline(void *arena, size_t size, const char *file, int line) {
|
||||
(void)arena;
|
||||
(void)file;
|
||||
(void)line;
|
||||
++malloc_fileline_count;
|
||||
return pool_bump(size ? size : 16u);
|
||||
}
|
||||
|
||||
/* fontcache glyph lookup (DONE). */
|
||||
int iggy_get_unsafe_glyph_for_codepoint(void *font, int codepoint) {
|
||||
(void)font;
|
||||
++glyph_count;
|
||||
last_glyph_codepoint = codepoint;
|
||||
return glyph_ret;
|
||||
}
|
||||
|
||||
/* iggy text engine (swf_play / flash_display -- callee-side text layout). */
|
||||
void iggy_set_textfield_text(void *vm, void *info, void *text, int len,
|
||||
int flag) {
|
||||
(void)vm;
|
||||
(void)text;
|
||||
(void)len;
|
||||
(void)flag;
|
||||
++set_text_count;
|
||||
last_set_text_info = info;
|
||||
}
|
||||
void iggy_set_textfield_htmltext(void *vm, void *info, void *text, int len,
|
||||
int flag) {
|
||||
(void)vm;
|
||||
(void)info;
|
||||
(void)text;
|
||||
(void)len;
|
||||
(void)flag;
|
||||
++set_htmltext_count;
|
||||
}
|
||||
void iggy_do_replace_text(void *vm, void *info, int a, int b, void *text,
|
||||
int len) {
|
||||
(void)vm;
|
||||
(void)info;
|
||||
(void)a;
|
||||
(void)b;
|
||||
(void)text;
|
||||
(void)len;
|
||||
++replace_text_count;
|
||||
}
|
||||
void iggy_textfield_compute_info(void *vm, void *info, void *out) {
|
||||
(void)vm;
|
||||
(void)out;
|
||||
++compute_info_count;
|
||||
last_compute_info_info = info;
|
||||
}
|
||||
void iggy_textfield_reflow(void *vm, void *info) {
|
||||
(void)vm;
|
||||
(void)info;
|
||||
++reflow_count;
|
||||
}
|
||||
void iggy_textfield_set_height(void *vm, void *info, float value) {
|
||||
(void)vm;
|
||||
(void)info;
|
||||
(void)value;
|
||||
++set_height_count;
|
||||
}
|
||||
void iggy_textfield_set_width(void *vm, void *info, float value) {
|
||||
(void)vm;
|
||||
(void)info;
|
||||
(void)value;
|
||||
++set_width_count;
|
||||
}
|
||||
void iggy_textfield_update_styles(void *vm, void *info) {
|
||||
(void)vm;
|
||||
(void)info;
|
||||
++update_styles_count;
|
||||
}
|
||||
571
tests/test_reconstructed_swf_as3_textfield.py
Normal file
571
tests/test_reconstructed_swf_as3_textfield.py
Normal file
@@ -0,0 +1,571 @@
|
||||
"""Runtime tests for the reconstructed swf_as3_textfield translation unit.
|
||||
|
||||
RED STATE: swf_as3_textfield.c / swf_as3_textfield.h do not exist yet, so
|
||||
setUpClass raises "missing swf_as3_textfield runtime inputs". Every assertion
|
||||
below is grounded in a specific line of
|
||||
iggy-decompiled/raw/durango/swf_as3_textfield.c (cited inline) so a faithful
|
||||
DURANGO reconstruction turns these green.
|
||||
|
||||
swf_as3_textfield is Iggy's AS3 / AVM2 text-and-font binding layer: the
|
||||
flash.text.Font, TextField, TextFormat and TextLineMetrics classes plus the two
|
||||
object factories as3vm_make_font_GC / as3vm_make_textformat_GC and the two shared
|
||||
thin accessors as3vm_textfield_bool_getter / _bool_setter. It exports EXACTLY
|
||||
126 entry points on all four platforms (the durango decompile also recovers
|
||||
file-static helpers, so durango source_functions == 129 vs 127 on the others).
|
||||
|
||||
BODY CLASSIFICATION -- the 126 exports are MOSTLY REAL, NOT uniform. There are
|
||||
70 as3vm_exception_GC calls: NINE raise 0x74 and SIXTY-ONE raise 0x78.
|
||||
EIGHT are pure "unsupported" stubs (0x74 only, no field access):
|
||||
Font_registerFont, TextLineMetrics__construct and the six TextLineMetrics
|
||||
setters (set_ascent/_descent/_height/_leading/_width/_x)
|
||||
(raw:199/3080/3187/3198/3209/3220/3231/3242).
|
||||
The NINTH 0x74 is the else branch of the REAL Font__construct (raw:17).
|
||||
The 61 0x78 raises are the bad-args tails of REAL bodies (parse failure or an
|
||||
out-of-range index): the arg-parsing setters, the text methods and
|
||||
Font_hasGlyphs. Everything else is a REAL property getter / setter / factory /
|
||||
text-layout body.
|
||||
|
||||
OBJECT MODEL (durango 64-bit -- the runtime test builds ONLY the durango dylib so
|
||||
the 64-bit layout is authoritative):
|
||||
frame[0]=vm, frame[1]=&result slot (a getter writes its box to *frame[1]),
|
||||
frame[2]=argc, frame[3]=&this-slot (holds the RAW object pointer); the shared
|
||||
bool accessors also read frame[4]=&property-descriptor.
|
||||
obj = *(this_slot)
|
||||
handle = *(obj + 0x27) -- the native Font / TextField struct
|
||||
info = *(handle + 0x98) -- the layout / format sub-struct
|
||||
Representative TextField fields inside `info`: textColor uint @ +0x34,
|
||||
backgroundColor uint @ +0x74, borderColor uint @ +0x78, numLines int @ +0xb4,
|
||||
line-node list head @ +0x60 (node+0x60 = char count, node+0x68 = next).
|
||||
|
||||
WHAT IS PINNED (real, deterministic DURANGO behavior):
|
||||
- the eight pure stubs raise ONLY 0x74 (raw:199/3080/3187-3242).
|
||||
- Font__construct adopts *(vm+0x28e0) into obj+0x27 and clears the pending slot;
|
||||
an empty pending slot raises 0x74 (raw:11-18).
|
||||
- Font_get_fontType boxes *(vm+0x900) when the handle is set, else *(vm+0x8f8)
|
||||
(raw:143-150).
|
||||
- Font_get_fontName boxes make_string_wc(vm, *(handle+0x80), -1) (raw:106-110).
|
||||
- Font_hasGlyphs parses "s"; a parse failure raises 0x78 (raw:167-171).
|
||||
- TextField_get_numLines writes (*(int*)(info+0xb4)) * 2 to *frame[1] (raw:1236).
|
||||
- TextField_get_length sums the line-node char counts * 2 (raw:1165-1181).
|
||||
- TextField_get_textColor / _backgroundColor / _borderColor box the uint at
|
||||
info+0x34 / +0x74 / +0x78 via as3vm_make_uint_GC (raw:948/965/1429).
|
||||
- TextField_set_backgroundColor / _borderColor parse "s_u" then write
|
||||
(value & 0xffffff) to info+0x74 / +0x78; a parse failure raises 0x78
|
||||
(raw:1795-1811 / 1815-1831).
|
||||
- as3vm_textfield_bool_setter parses "s_b" then writes the byte at
|
||||
info + *(int*)(frame[4]+0x18); a parse failure raises 0x78 (raw:3309-3333).
|
||||
- as3vm_textfield_bool_getter indexes as3vm_makebool by the byte at
|
||||
info + *(int*)(frame[4]+0x18) (raw:3295-3305).
|
||||
- TextField_appendText parses "s" then invokes iggy_set_textfield_text on `info`;
|
||||
a parse failure raises 0x78 (raw:224-236).
|
||||
- getLineOffset / getParagraphLength raise 0x78 on a parse failure or a negative
|
||||
line index (raw:557-577 / 682-702).
|
||||
- as3vm_make_font_GC builds an object from the Font class at vm+0x26e0 and stores
|
||||
the native handle at obj+0x27 (raw:3254-3257).
|
||||
|
||||
DEFERRED (flagged structural, NOT exercised): the getLineOffset / getParagraphLength
|
||||
happy path (needs iggy_textfield_compute_info to fill stack locals); the deep
|
||||
layout methods getLineMetrics / getCharBoundaries / getTextFormat; htmlText parse;
|
||||
the TextFormat property block; the 32-bit ps3 / vita struct (handle @ obj+0x17,
|
||||
info @ handle+0x50, numLines @ info+0xa0, frame stride 4).
|
||||
|
||||
Full-suite runs use python3.12 (the machine python3 is 3.14, which SEGFAULTs at
|
||||
teardown on the full suite via an unrelated CPython ctypes-GC bug -- exit 139
|
||||
AFTER the last "ok" with 0 fail/err is a teardown artifact, not a failure).
|
||||
"""
|
||||
|
||||
import ctypes
|
||||
import shutil
|
||||
import struct
|
||||
from pathlib import Path
|
||||
import subprocess
|
||||
import tempfile
|
||||
import unittest
|
||||
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
RECONSTRUCTED = ROOT / "iggy-decompiled/src/reconstructed"
|
||||
SOURCE = RECONSTRUCTED / "swf_as3_textfield.c"
|
||||
HEADER = RECONSTRUCTED / "swf_as3_textfield.h"
|
||||
SUPPORT = ROOT / "tests/support/swf_as3_textfield_test_support.c"
|
||||
|
||||
MASK64 = (1 << 64) - 1
|
||||
|
||||
# 64-bit DURANGO object-model offsets (cited per test).
|
||||
OFF_HANDLE = 0x27 # obj -> native Font / TextField handle (raw:106 et al).
|
||||
OFF_INFO = 0x98 # handle -> layout / format sub-struct (raw:948).
|
||||
OFF_TEXTCOLOR = 0x34 # info -> textColor uint (raw:1437).
|
||||
OFF_BGCOLOR = 0x74 # info -> backgroundColor uint (raw:955).
|
||||
OFF_BORDERCOLOR = 0x78 # info -> borderColor uint (raw:972).
|
||||
OFF_NUMLINES = 0xB4 # info -> numLines int (raw:1240).
|
||||
OFF_LINEHEAD = 0x60 # info -> first line node (raw:1170).
|
||||
OFF_NODE_COUNT = 0x60 # line node -> char count (raw:1173).
|
||||
OFF_NODE_NEXT = 0x68 # line node -> next node (raw:1172).
|
||||
OFF_PENDING = 0x28E0 # vm -> pending native font buffer (raw:11).
|
||||
OFF_FONTCLASS = 0x26E0 # vm -> Font class pointer (raw:3254).
|
||||
OFF_FONTTYPE_SET = 0x900 # vm -> boxed value when handle present (raw:145).
|
||||
OFF_FONTTYPE_UNSET = 0x8F8 # vm -> boxed value when handle absent (raw:149).
|
||||
OFF_FONTNAME = 0x80 # handle -> wide font-name pointer (raw:107).
|
||||
OFF_DESC_FIELD = 0x18 # property descriptor -> field offset (raw:3305/3332).
|
||||
|
||||
# The eight pure "unsupported" stubs -- each raises ONLY exception 0x74.
|
||||
STUB_METHODS = (
|
||||
"as3vm_Font_registerFont",
|
||||
"as3vm_TextLineMetrics__construct",
|
||||
"as3vm_TextLineMetrics_set_ascent",
|
||||
"as3vm_TextLineMetrics_set_descent",
|
||||
"as3vm_TextLineMetrics_set_height",
|
||||
"as3vm_TextLineMetrics_set_leading",
|
||||
"as3vm_TextLineMetrics_set_width",
|
||||
"as3vm_TextLineMetrics_set_x",
|
||||
)
|
||||
|
||||
|
||||
class ReconstructedSwfAs3TextfieldTests(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
missing = [str(path) for path in (SOURCE, HEADER, SUPPORT)
|
||||
if not path.exists()]
|
||||
if missing:
|
||||
raise AssertionError(
|
||||
"missing swf_as3_textfield runtime inputs: " + ", ".join(missing))
|
||||
cls.temp = tempfile.TemporaryDirectory()
|
||||
cls.base = Path(cls.temp.name) / "swf_as3_textfield.dylib"
|
||||
build = subprocess.run([
|
||||
"clang", "-dynamiclib", "-std=c11", "-O2", "-Wall", "-Wextra",
|
||||
"-Werror", "-Wl,-undefined,dynamic_lookup",
|
||||
"-DIGGY_RECONSTRUCT_SWF_AS3_TEXTFIELD_DURANGO=1",
|
||||
"-I", str(RECONSTRUCTED),
|
||||
str(SOURCE), str(SUPPORT), "-o", str(cls.base),
|
||||
], capture_output=True, text=True)
|
||||
if build.returncode:
|
||||
raise AssertionError(build.stdout + build.stderr)
|
||||
|
||||
@classmethod
|
||||
def tearDownClass(cls):
|
||||
cls.temp.cleanup()
|
||||
|
||||
def setUp(self):
|
||||
unique = (Path(self.temp.name) /
|
||||
f"swf_as3_textfield_{self._testMethodName}.dylib")
|
||||
shutil.copyfile(self.base, unique)
|
||||
self.lib = ctypes.CDLL(str(unique))
|
||||
self.lib.swf_as3_textfield_test_reset()
|
||||
self._keep = []
|
||||
|
||||
# --- harness accessors -------------------------------------------- #
|
||||
|
||||
def _count(self, name):
|
||||
fn = getattr(self.lib, f"swf_as3_textfield_test_{name}_count")
|
||||
fn.restype = ctypes.c_size_t
|
||||
fn.argtypes = []
|
||||
return fn()
|
||||
|
||||
def _last_exc(self):
|
||||
self.lib.swf_as3_textfield_test_last_exception_code.restype = \
|
||||
ctypes.c_int32
|
||||
return self.lib.swf_as3_textfield_test_last_exception_code()
|
||||
|
||||
def _last_uint(self):
|
||||
self.lib.swf_as3_textfield_test_last_uint_arg.restype = ctypes.c_uint32
|
||||
return self.lib.swf_as3_textfield_test_last_uint_arg()
|
||||
|
||||
def _ptr(self, name):
|
||||
fn = getattr(self.lib, f"swf_as3_textfield_test_{name}")
|
||||
fn.restype = ctypes.c_void_p
|
||||
fn.argtypes = []
|
||||
return fn() or 0
|
||||
|
||||
def _set_parse_ret(self, value):
|
||||
self.lib.swf_as3_textfield_test_set_parse_ret.argtypes = [ctypes.c_int]
|
||||
self.lib.swf_as3_textfield_test_set_parse_ret(value)
|
||||
|
||||
def _set_parse_out(self, data):
|
||||
self.lib.swf_as3_textfield_test_set_parse_out.argtypes = [
|
||||
ctypes.c_void_p, ctypes.c_size_t]
|
||||
buf = (ctypes.c_uint8 * len(data)).from_buffer_copy(data)
|
||||
self._keep.append(buf)
|
||||
self.lib.swf_as3_textfield_test_set_parse_out(
|
||||
ctypes.c_void_p(ctypes.addressof(buf)), len(data))
|
||||
|
||||
def _set_makebool(self, index, value):
|
||||
self.lib.swf_as3_textfield_test_set_makebool.argtypes = [
|
||||
ctypes.c_int, ctypes.c_void_p]
|
||||
self.lib.swf_as3_textfield_test_set_makebool(index,
|
||||
ctypes.c_void_p(value))
|
||||
|
||||
# --- buffer helpers ----------------------------------------------- #
|
||||
|
||||
def _buf(self, size):
|
||||
buf = (ctypes.c_uint8 * size)()
|
||||
self._keep.append(buf)
|
||||
return buf
|
||||
|
||||
def _addr(self, buf):
|
||||
return ctypes.addressof(buf)
|
||||
|
||||
def _poke_u64(self, buf, offset, value):
|
||||
ctypes.c_uint64.from_buffer(buf, offset).value = value & MASK64
|
||||
|
||||
def _peek_u64(self, buf, offset):
|
||||
return ctypes.c_uint64.from_buffer(buf, offset).value
|
||||
|
||||
def _poke_u32(self, buf, offset, value):
|
||||
ctypes.c_uint32.from_buffer(buf, offset).value = value & 0xFFFFFFFF
|
||||
|
||||
def _peek_u32(self, buf, offset):
|
||||
return ctypes.c_uint32.from_buffer(buf, offset).value
|
||||
|
||||
def _frame(self, vm=0, result=0, this_slot=0, argc=0, descriptor=0):
|
||||
frame = self._buf(0x30)
|
||||
self._poke_u64(frame, 0x00, vm)
|
||||
self._poke_u64(frame, 0x08, result)
|
||||
ctypes.c_int32.from_buffer(frame, 0x10).value = argc
|
||||
self._poke_u64(frame, 0x18, this_slot)
|
||||
self._poke_u64(frame, 0x20, descriptor)
|
||||
return frame
|
||||
|
||||
def _this_slot(self, obj_addr):
|
||||
slot = self._buf(8)
|
||||
self._poke_u64(slot, 0, obj_addr)
|
||||
return slot
|
||||
|
||||
def _vm(self, size=0x2A00):
|
||||
return self._buf(size)
|
||||
|
||||
def _textfield(self):
|
||||
# Builds an obj -> handle -> info chain and returns (obj, handle, info).
|
||||
info = self._buf(0x200)
|
||||
handle = self._buf(0x200)
|
||||
obj = self._buf(0x80)
|
||||
self._poke_u64(handle, OFF_INFO, self._addr(info))
|
||||
self._poke_u64(obj, OFF_HANDLE, self._addr(handle))
|
||||
return obj, handle, info
|
||||
|
||||
def _call_frame(self, name, frame):
|
||||
fn = getattr(self.lib, name)
|
||||
fn.restype = None
|
||||
fn.argtypes = [ctypes.c_void_p]
|
||||
fn(ctypes.c_void_p(self._addr(frame)))
|
||||
|
||||
# ------------------------------------------------------------------ #
|
||||
# The eight pure stubs -- each raises exception 0x74 only.
|
||||
# ------------------------------------------------------------------ #
|
||||
|
||||
def test_pure_stubs_raise_0x74(self):
|
||||
# raw:199/3080/3187-3242 each stub is `as3vm_exception_GC(vm, 0x74)`.
|
||||
self.assertEqual(len(STUB_METHODS), 8)
|
||||
for name in STUB_METHODS:
|
||||
self.lib.swf_as3_textfield_test_reset()
|
||||
vm = self._buf(0x40)
|
||||
frame = self._frame(vm=self._addr(vm))
|
||||
self._call_frame(name, frame)
|
||||
self.assertEqual(self._count("exception"), 1, name)
|
||||
self.assertEqual(self._last_exc(), 0x74, name)
|
||||
|
||||
# ------------------------------------------------------------------ #
|
||||
# Font__construct -- adopt pending buffer / else raise 0x74.
|
||||
# ------------------------------------------------------------------ #
|
||||
|
||||
def test_font_construct_adopts_pending_buffer(self):
|
||||
# raw:11-16 *(vm+0x28e0) != 0 -> obj+0x27 := it; the pending slot clears.
|
||||
vm = self._vm()
|
||||
self._poke_u64(vm, OFF_PENDING, 0xCAFEF00D)
|
||||
obj = self._buf(0x80)
|
||||
this_slot = self._this_slot(self._addr(obj))
|
||||
frame = self._frame(vm=self._addr(vm),
|
||||
this_slot=self._addr(this_slot))
|
||||
self._call_frame("as3vm_Font__construct", frame)
|
||||
self.assertEqual(self._peek_u64(obj, OFF_HANDLE), 0xCAFEF00D)
|
||||
self.assertEqual(self._peek_u64(vm, OFF_PENDING), 0)
|
||||
self.assertEqual(self._count("exception"), 0)
|
||||
|
||||
def test_font_construct_empty_pending_raises_0x74(self):
|
||||
# raw:17 *(vm+0x28e0) == 0 -> exception 0x74.
|
||||
vm = self._vm() # pending slot already zero.
|
||||
obj = self._buf(0x80)
|
||||
this_slot = self._this_slot(self._addr(obj))
|
||||
frame = self._frame(vm=self._addr(vm),
|
||||
this_slot=self._addr(this_slot))
|
||||
self._call_frame("as3vm_Font__construct", frame)
|
||||
self.assertEqual(self._count("exception"), 1)
|
||||
self.assertEqual(self._last_exc(), 0x74)
|
||||
|
||||
# ------------------------------------------------------------------ #
|
||||
# Font getters.
|
||||
# ------------------------------------------------------------------ #
|
||||
|
||||
def test_font_get_font_type_selects_vm_cached_value(self):
|
||||
# raw:143-150 handle set -> box *(vm+0x900); handle null -> *(vm+0x8f8).
|
||||
vm = self._vm()
|
||||
self._poke_u64(vm, OFF_FONTTYPE_SET, 0xF0F0F0)
|
||||
self._poke_u64(vm, OFF_FONTTYPE_UNSET, 0x0A0A0A)
|
||||
obj = self._buf(0x80)
|
||||
self._poke_u64(obj, OFF_HANDLE, 0x1234) # non-null handle.
|
||||
result = self._buf(8)
|
||||
frame = self._frame(vm=self._addr(vm), result=self._addr(result),
|
||||
this_slot=self._addr(self._this_slot(self._addr(obj))))
|
||||
self._call_frame("as3vm_Font_get_fontType", frame)
|
||||
self.assertEqual(self._peek_u64(result, 0), 0xF0F0F0)
|
||||
|
||||
obj2 = self._buf(0x80) # null handle.
|
||||
result2 = self._buf(8)
|
||||
frame2 = self._frame(
|
||||
vm=self._addr(vm), result=self._addr(result2),
|
||||
this_slot=self._addr(self._this_slot(self._addr(obj2))))
|
||||
self._call_frame("as3vm_Font_get_fontType", frame2)
|
||||
self.assertEqual(self._peek_u64(result2, 0), 0x0A0A0A)
|
||||
|
||||
def test_font_get_font_name_boxes_wide_string(self):
|
||||
# raw:106-110 make_string_wc(vm, *(handle+0x80), -1) -> *frame[1].
|
||||
vm = self._vm()
|
||||
handle = self._buf(0x100)
|
||||
self._poke_u64(handle, OFF_FONTNAME, 0xBEEF00)
|
||||
obj = self._buf(0x80)
|
||||
self._poke_u64(obj, OFF_HANDLE, self._addr(handle))
|
||||
result = self._buf(8)
|
||||
frame = self._frame(vm=self._addr(vm), result=self._addr(result),
|
||||
this_slot=self._addr(self._this_slot(self._addr(obj))))
|
||||
self._call_frame("as3vm_Font_get_fontName", frame)
|
||||
self.assertEqual(self._count("make_string_wc"), 1)
|
||||
self.lib.swf_as3_textfield_test_last_string_wc_ptr.restype = \
|
||||
ctypes.c_void_p
|
||||
self.assertEqual(
|
||||
self.lib.swf_as3_textfield_test_last_string_wc_ptr(), 0xBEEF00)
|
||||
self.lib.swf_as3_textfield_test_last_string_wc_len.restype = ctypes.c_int
|
||||
self.assertEqual(
|
||||
self.lib.swf_as3_textfield_test_last_string_wc_len(), -1)
|
||||
|
||||
def test_font_has_glyphs_bad_args_raise_0x78(self):
|
||||
# raw:167-171 a nonzero parse result short-circuits to exception 0x78.
|
||||
self._set_parse_ret(1)
|
||||
vm = self._vm()
|
||||
frame = self._frame(vm=self._addr(vm))
|
||||
self._call_frame("as3vm_Font_hasGlyphs", frame)
|
||||
self.assertEqual(self._count("exception"), 1)
|
||||
self.assertEqual(self._last_exc(), 0x78)
|
||||
|
||||
# ------------------------------------------------------------------ #
|
||||
# TextField integer getters -- direct stores, no boxing.
|
||||
# ------------------------------------------------------------------ #
|
||||
|
||||
def test_get_num_lines_writes_field_times_two(self):
|
||||
# raw:1240 numLines := (*(int*)(info+0xb4)) * 2 -> *frame[1].
|
||||
obj, _handle, info = self._textfield()
|
||||
ctypes.c_int32.from_buffer(info, OFF_NUMLINES).value = 7
|
||||
result = self._buf(8)
|
||||
frame = self._frame(result=self._addr(result),
|
||||
this_slot=self._addr(self._this_slot(self._addr(obj))))
|
||||
self._call_frame("as3vm_TextField_get_numLines", frame)
|
||||
self.assertEqual(self._peek_u64(result, 0), 14)
|
||||
|
||||
def test_get_length_sums_line_node_char_counts_times_two(self):
|
||||
# raw:1170-1180 walk info+0x60 list via node+0x68, sum node+0x60, *2.
|
||||
obj, _handle, info = self._textfield()
|
||||
node_a = self._buf(0x80)
|
||||
node_b = self._buf(0x80)
|
||||
ctypes.c_int32.from_buffer(node_a, OFF_NODE_COUNT).value = 5
|
||||
self._poke_u64(node_a, OFF_NODE_NEXT, self._addr(node_b))
|
||||
ctypes.c_int32.from_buffer(node_b, OFF_NODE_COUNT).value = 3
|
||||
self._poke_u64(node_b, OFF_NODE_NEXT, 0)
|
||||
self._poke_u64(info, OFF_LINEHEAD, self._addr(node_a))
|
||||
result = self._buf(8)
|
||||
frame = self._frame(result=self._addr(result),
|
||||
this_slot=self._addr(self._this_slot(self._addr(obj))))
|
||||
self._call_frame("as3vm_TextField_get_length", frame)
|
||||
self.assertEqual(self._peek_u64(result, 0), (5 + 3) * 2)
|
||||
|
||||
# ------------------------------------------------------------------ #
|
||||
# TextField color getters -- box the uint field via make_uint.
|
||||
# ------------------------------------------------------------------ #
|
||||
|
||||
def _color_getter(self, name, offset, value):
|
||||
self.lib.swf_as3_textfield_test_reset()
|
||||
obj, _handle, info = self._textfield()
|
||||
self._poke_u32(info, offset, value)
|
||||
result = self._buf(8)
|
||||
frame = self._frame(result=self._addr(result),
|
||||
this_slot=self._addr(self._this_slot(self._addr(obj))))
|
||||
self._call_frame(name, frame)
|
||||
self.assertEqual(self._count("make_uint"), 1, name)
|
||||
self.assertEqual(self._last_uint(), value, name)
|
||||
|
||||
def test_color_getters_box_the_uint_field(self):
|
||||
# raw:955/972/1437 make_uint of the uint at info+0x74 / +0x78 / +0x34.
|
||||
self._color_getter("as3vm_TextField_get_backgroundColor",
|
||||
OFF_BGCOLOR, 0x112233)
|
||||
self._color_getter("as3vm_TextField_get_borderColor",
|
||||
OFF_BORDERCOLOR, 0x445566)
|
||||
self._color_getter("as3vm_TextField_get_textColor",
|
||||
OFF_TEXTCOLOR, 0x778899)
|
||||
|
||||
# ------------------------------------------------------------------ #
|
||||
# TextField color setters -- parse "s_u" then write masked value.
|
||||
# ------------------------------------------------------------------ #
|
||||
|
||||
def _color_setter(self, name, offset):
|
||||
self.lib.swf_as3_textfield_test_reset()
|
||||
obj, _handle, info = self._textfield()
|
||||
self._set_parse_out(struct.pack("<I", 0xAABBCCDD))
|
||||
vm = self._vm()
|
||||
frame = self._frame(vm=self._addr(vm),
|
||||
this_slot=self._addr(self._this_slot(self._addr(obj))))
|
||||
self._call_frame(name, frame)
|
||||
self.assertEqual(self._peek_u32(info, offset), 0xBBCCDD, name)
|
||||
self.assertEqual(self._count("exception"), 0, name)
|
||||
|
||||
def test_color_setters_mask_and_write_the_field(self):
|
||||
# raw:1806/1826 info+0x74/+0x78 := parsed uint & 0xffffff.
|
||||
self._color_setter("as3vm_TextField_set_backgroundColor", OFF_BGCOLOR)
|
||||
self._color_setter("as3vm_TextField_set_borderColor", OFF_BORDERCOLOR)
|
||||
|
||||
def test_color_setter_bad_args_raise_0x78(self):
|
||||
# raw:1800 a nonzero parse result raises 0x78 and writes no field.
|
||||
self._set_parse_ret(1)
|
||||
obj, _handle, _info = self._textfield()
|
||||
vm = self._vm()
|
||||
frame = self._frame(vm=self._addr(vm),
|
||||
this_slot=self._addr(self._this_slot(self._addr(obj))))
|
||||
self._call_frame("as3vm_TextField_set_backgroundColor", frame)
|
||||
self.assertEqual(self._count("exception"), 1)
|
||||
self.assertEqual(self._last_exc(), 0x78)
|
||||
|
||||
# ------------------------------------------------------------------ #
|
||||
# Shared bool getter / setter -- descriptor-driven field access.
|
||||
# ------------------------------------------------------------------ #
|
||||
|
||||
def test_bool_getter_indexes_makebool_by_field_byte(self):
|
||||
# raw:3295-3305 result := as3vm_makebool[ *(byte*)(info+off) ], where
|
||||
# off == *(int*)(descriptor+0x18).
|
||||
obj, _handle, info = self._textfield()
|
||||
descriptor = self._buf(0x40)
|
||||
ctypes.c_int32.from_buffer(descriptor, OFF_DESC_FIELD).value = 0x7A
|
||||
self._set_makebool(0, 0xFA15E)
|
||||
self._set_makebool(1, 0x712)
|
||||
ctypes.c_uint8.from_buffer(info, 0x7A).value = 1 # -> makebool[1] (true).
|
||||
result = self._buf(8)
|
||||
frame = self._frame(result=self._addr(result),
|
||||
this_slot=self._addr(self._this_slot(self._addr(obj))),
|
||||
descriptor=self._addr(descriptor))
|
||||
self._call_frame("as3vm_textfield_bool_getter", frame)
|
||||
self.assertEqual(self._peek_u64(result, 0), 0x712)
|
||||
|
||||
self.lib.swf_as3_textfield_test_reset()
|
||||
obj, _handle, info = self._textfield()
|
||||
descriptor = self._buf(0x40)
|
||||
ctypes.c_int32.from_buffer(descriptor, OFF_DESC_FIELD).value = 0x7A
|
||||
self._set_makebool(0, 0xFA15E)
|
||||
ctypes.c_uint8.from_buffer(info, 0x7A).value = 0 # -> makebool[0] (false).
|
||||
result = self._buf(8)
|
||||
frame = self._frame(result=self._addr(result),
|
||||
this_slot=self._addr(self._this_slot(self._addr(obj))),
|
||||
descriptor=self._addr(descriptor))
|
||||
self._call_frame("as3vm_textfield_bool_getter", frame)
|
||||
self.assertEqual(self._peek_u64(result, 0), 0xFA15E)
|
||||
|
||||
def test_bool_setter_writes_field_byte(self):
|
||||
# raw:3320-3331 info + *(int*)(descriptor+0x18) := parsed bool byte.
|
||||
obj, _handle, info = self._textfield()
|
||||
descriptor = self._buf(0x40)
|
||||
ctypes.c_int32.from_buffer(descriptor, OFF_DESC_FIELD).value = 0x55
|
||||
self._set_parse_out(bytes([1]))
|
||||
vm = self._vm()
|
||||
frame = self._frame(vm=self._addr(vm),
|
||||
this_slot=self._addr(self._this_slot(self._addr(obj))),
|
||||
descriptor=self._addr(descriptor))
|
||||
self._call_frame("as3vm_textfield_bool_setter", frame)
|
||||
self.assertEqual(ctypes.c_uint8.from_buffer(info, 0x55).value, 1)
|
||||
self.assertEqual(self._count("exception"), 0)
|
||||
|
||||
def test_bool_setter_bad_args_raise_0x78(self):
|
||||
# raw:3316 a nonzero parse result raises 0x78.
|
||||
self._set_parse_ret(1)
|
||||
obj, _handle, _info = self._textfield()
|
||||
descriptor = self._buf(0x40)
|
||||
vm = self._vm()
|
||||
frame = self._frame(vm=self._addr(vm),
|
||||
this_slot=self._addr(self._this_slot(self._addr(obj))),
|
||||
descriptor=self._addr(descriptor))
|
||||
self._call_frame("as3vm_textfield_bool_setter", frame)
|
||||
self.assertEqual(self._count("exception"), 1)
|
||||
self.assertEqual(self._last_exc(), 0x78)
|
||||
|
||||
# ------------------------------------------------------------------ #
|
||||
# Text methods.
|
||||
# ------------------------------------------------------------------ #
|
||||
|
||||
def test_append_text_invokes_engine_on_info(self):
|
||||
# raw:224-236 parse "s" then iggy_set_textfield_text(vm, info, ...).
|
||||
obj, _handle, info = self._textfield()
|
||||
strdata = self._buf(0x40)
|
||||
cell = self._buf(0x40)
|
||||
self._poke_u64(cell, 0x07, self._addr(strdata))
|
||||
ctypes.c_int32.from_buffer(strdata, 0x07).value = 3
|
||||
self._set_parse_out(struct.pack("<Q", self._addr(cell)))
|
||||
vm = self._vm()
|
||||
frame = self._frame(vm=self._addr(vm),
|
||||
this_slot=self._addr(self._this_slot(self._addr(obj))))
|
||||
self._call_frame("as3vm_TextField_appendText", frame)
|
||||
self.assertEqual(self._count("set_text"), 1)
|
||||
self.lib.swf_as3_textfield_test_last_set_text_info.restype = \
|
||||
ctypes.c_void_p
|
||||
self.assertEqual(
|
||||
self.lib.swf_as3_textfield_test_last_set_text_info(),
|
||||
self._addr(info))
|
||||
self.assertEqual(self._count("exception"), 0)
|
||||
|
||||
def test_append_text_bad_args_raise_0x78(self):
|
||||
# raw:222 a nonzero parse result raises 0x78 and skips the engine.
|
||||
self._set_parse_ret(1)
|
||||
obj, _handle, _info = self._textfield()
|
||||
vm = self._vm()
|
||||
frame = self._frame(vm=self._addr(vm),
|
||||
this_slot=self._addr(self._this_slot(self._addr(obj))))
|
||||
self._call_frame("as3vm_TextField_appendText", frame)
|
||||
self.assertEqual(self._count("exception"), 1)
|
||||
self.assertEqual(self._last_exc(), 0x78)
|
||||
self.assertEqual(self._count("set_text"), 0)
|
||||
|
||||
def test_get_line_offset_rejects_negative_line(self):
|
||||
# raw:557-576 parse "s_d"; a negative line index raises 0x78.
|
||||
obj, _handle, _info = self._textfield()
|
||||
self._set_parse_out(struct.pack("<i", -1))
|
||||
vm = self._vm()
|
||||
frame = self._frame(vm=self._addr(vm),
|
||||
this_slot=self._addr(self._this_slot(self._addr(obj))))
|
||||
self._call_frame("as3vm_TextField_getLineOffset", frame)
|
||||
self.assertEqual(self._count("exception"), 1)
|
||||
self.assertEqual(self._last_exc(), 0x78)
|
||||
|
||||
def test_get_paragraph_length_bad_args_raise_0x78(self):
|
||||
# raw:682-701 parse failure raises 0x78.
|
||||
self._set_parse_ret(1)
|
||||
obj, _handle, _info = self._textfield()
|
||||
vm = self._vm()
|
||||
frame = self._frame(vm=self._addr(vm),
|
||||
this_slot=self._addr(self._this_slot(self._addr(obj))))
|
||||
self._call_frame("as3vm_TextField_getParagraphLength", frame)
|
||||
self.assertEqual(self._count("exception"), 1)
|
||||
self.assertEqual(self._last_exc(), 0x78)
|
||||
|
||||
# ------------------------------------------------------------------ #
|
||||
# Object factory.
|
||||
# ------------------------------------------------------------------ #
|
||||
|
||||
def test_make_font_builds_object_and_stores_handle(self):
|
||||
# raw:3254-3257 make_object(vm, *(vm+0x26e0)); obj+0x27 := handle.
|
||||
vm = self._vm()
|
||||
self._poke_u64(vm, OFF_FONTCLASS, 0xC1A55)
|
||||
self.lib.as3vm_make_font_GC.restype = None
|
||||
self.lib.as3vm_make_font_GC.argtypes = [ctypes.c_void_p, ctypes.c_void_p]
|
||||
self.lib.as3vm_make_font_GC(ctypes.c_void_p(self._addr(vm)),
|
||||
ctypes.c_void_p(0xF0417))
|
||||
self.assertEqual(self._count("make_object"), 1)
|
||||
self.assertEqual(self._ptr("last_object_class"), 0xC1A55)
|
||||
obj = self._ptr("last_object")
|
||||
self.assertEqual(
|
||||
ctypes.c_uint64.from_address(obj + OFF_HANDLE).value, 0xF0417)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
507
tests/test_reconstructed_swf_as3_textfield_cross.py
Normal file
507
tests/test_reconstructed_swf_as3_textfield_cross.py
Normal file
@@ -0,0 +1,507 @@
|
||||
"""Cross-platform contract tests for the reconstructed swf_as3_textfield module.
|
||||
|
||||
Mirrors tests/test_reconstructed_swf_as3_misc_cross.py (the direct analog in the
|
||||
same AS3 / AVM2 VM binding cluster). RED until swf_as3_textfield.c /
|
||||
swf_as3_textfield.h (and their CMake / modules.tsv rows) exist; the
|
||||
retail-evidence assertions (exports, no-owned-global, imports, provenance, and
|
||||
the inventory) run NOW against the four .obj and prove the nm / strings parsing.
|
||||
|
||||
swf_as3_textfield is Iggy's AS3 / AVM2 text-and-font binding layer: the
|
||||
flash.text.Font, TextField, TextFormat and TextLineMetrics classes plus the two
|
||||
object factories as3vm_make_font_GC / as3vm_make_textformat_GC and the two shared
|
||||
thin accessors as3vm_textfield_bool_getter / _bool_setter. It exports a fixed
|
||||
126 entry points on every platform. The durango decompile additionally recovers
|
||||
file-static helpers, so durango source_functions == 129 while orbis / ps3 / vita
|
||||
== 127; the exported ABI is 126 everywhere.
|
||||
|
||||
BODY CLASSIFICATION (the key finding): the 126 exports are MOSTLY REAL. There are
|
||||
70 as3vm_exception_GC calls -- NINE 0x74 and SIXTY-ONE 0x78. EIGHT of the 0x74
|
||||
are pure "unsupported" stubs (Font_registerFont + TextLineMetrics__construct + the
|
||||
six TextLineMetrics setters); the ninth 0x74 is the else branch of the REAL
|
||||
Font__construct. The 61 0x78 are the bad-args tails of REAL bodies. Every other
|
||||
export is a real property getter / setter / factory / text-layout body.
|
||||
|
||||
How EXPECTED_* were derived (all four .obj under
|
||||
work/iggy-native-decomp/<platform>-objects/swf_as3_textfield.obj, verified with
|
||||
/opt/homebrew/opt/llvm/bin/llvm-nm and `nm -g`):
|
||||
|
||||
EXPECTED_FUNCTIONS = `llvm-nm --extern-only --defined-only <obj>` T-tagged
|
||||
names, leading '.' stripped on ps3. IDENTICAL 126-name
|
||||
set on durango / orbis / ps3 / vita. The ps3 .opd
|
||||
descriptors surface each export a second time as 'D';
|
||||
those normalize to the exported names and are NOT globals.
|
||||
|
||||
EXPECTED_GLOBALS = EMPTY. This module owns NO externally named data global.
|
||||
The thirty durango 'R' COMDATs are twenty-four ??_C@ string
|
||||
literals (format specs "s"/"s_u"/... , font-style codes,
|
||||
"Times New Roman", the provenance path) and six __real@
|
||||
float / double constants -- MSVC read-only ARTIFACTS, local
|
||||
(.L.str / .LCPI) on the other three platforms. as3vm_makebool
|
||||
and the value-cell singletons are IMPORTS owned elsewhere.
|
||||
|
||||
EXPECTED_IMPORTS = the genuine non-scaffolding references present on ALL FOUR
|
||||
retail objects (INVARIANT -- 30 symbols). Satisfied by DONE
|
||||
modules except the eleven iggy_textfield_* / iggy_set_* /
|
||||
iggy_do_replace_text engine hooks (owned by swf_play /
|
||||
flash_display, GENUINELY UNBUILT) and iggy_get_unsafe_glyph
|
||||
(fontcache).
|
||||
|
||||
PLATFORM_IMPORTS = the per-platform libm / libc the retail optimizer emitted
|
||||
(get_width / get_height sqrt; a scroll ceil; struct copies):
|
||||
durango {ceil, sqrt, memcpy, memset},
|
||||
orbis {memcpy} (sqrt / ceil inlined),
|
||||
ps3 {ceilf, memcpy, memset} (sqrt inlined, ceil->ceilf),
|
||||
vita {ceil, sqrt, memcpy, memset}.
|
||||
|
||||
RUNTIME_ALLOWLISTS = pure toolchain scaffolding, verified against retail
|
||||
`llvm-nm --undefined-only`:
|
||||
durango {_fltused, __GSHandlerCheck,
|
||||
__security_check_cookie, __security_cookie
|
||||
(+ __ImageBase a fresh MSVC compile may emit)}
|
||||
orbis {_GLOBAL_OFFSET_TABLE_}
|
||||
ps3 {}
|
||||
vita {__aeabi_unwind_cpp_pr0/_pr1, __stack_chk_fail,
|
||||
__stack_chk_guard}
|
||||
|
||||
PROVENANCE = every platform embeds __FILE__ via iggy_malloc_fileline, so
|
||||
the canonical c:\\projects\\g\\src\\flash\\swf_as3_textfield.c
|
||||
is present on ALL FOUR; durango ALSO carries its build .obj
|
||||
path.
|
||||
|
||||
Run the full suite with python3.12 (`python3.12 -m unittest discover -s tests`):
|
||||
the machine python3 is 3.14, which SEGFAULTs at teardown on the full suite via an
|
||||
unrelated CPython ctypes-GC bug. This cross test's cross-compile / nm logic is
|
||||
python-version-independent.
|
||||
"""
|
||||
|
||||
from pathlib import Path
|
||||
import subprocess
|
||||
import tempfile
|
||||
import unittest
|
||||
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
RECONSTRUCTED = ROOT / "iggy-decompiled/src/reconstructed"
|
||||
SOURCE = RECONSTRUCTED / "swf_as3_textfield.c"
|
||||
HEADER = RECONSTRUCTED / "swf_as3_textfield.h"
|
||||
LLVM_NM = Path("/opt/homebrew/opt/llvm/bin/llvm-nm")
|
||||
VARIANTS = {
|
||||
"durango": ("clang", "x86_64-pc-windows-msvc"),
|
||||
"orbis": ("clang", "x86_64-unknown-freebsd"),
|
||||
"vita": ("clang", "armv7a-unknown-linux-gnueabihf"),
|
||||
}
|
||||
PS3_CLANG = Path("/opt/homebrew/opt/llvm/bin/clang")
|
||||
if PS3_CLANG.exists():
|
||||
VARIANTS["ps3"] = (str(PS3_CLANG), "powerpc-unknown-linux-gnu")
|
||||
|
||||
# Invariant 126-name exported ABI (leading '.' stripped on ps3).
|
||||
EXPECTED_FUNCTIONS = {
|
||||
"as3vm_Font__construct",
|
||||
"as3vm_Font_enumerateFonts",
|
||||
"as3vm_Font_get_fontName",
|
||||
"as3vm_Font_get_fontStyle",
|
||||
"as3vm_Font_get_fontType",
|
||||
"as3vm_Font_hasGlyphs",
|
||||
"as3vm_Font_registerFont",
|
||||
"as3vm_TextField__construct",
|
||||
"as3vm_TextField_appendText",
|
||||
"as3vm_TextField_getCharBoundaries",
|
||||
"as3vm_TextField_getCharIndexAtPoint",
|
||||
"as3vm_TextField_getFirstCharInParagraph",
|
||||
"as3vm_TextField_getLineIndexAtPoint",
|
||||
"as3vm_TextField_getLineIndexOfChar",
|
||||
"as3vm_TextField_getLineLength",
|
||||
"as3vm_TextField_getLineMetrics",
|
||||
"as3vm_TextField_getLineOffset",
|
||||
"as3vm_TextField_getLineText",
|
||||
"as3vm_TextField_getParagraphLength",
|
||||
"as3vm_TextField_getTextFormat",
|
||||
"as3vm_TextField_get_antiAliasType",
|
||||
"as3vm_TextField_get_autoSize",
|
||||
"as3vm_TextField_get_backgroundColor",
|
||||
"as3vm_TextField_get_borderColor",
|
||||
"as3vm_TextField_get_bottomScrollV",
|
||||
"as3vm_TextField_get_caretIndex",
|
||||
"as3vm_TextField_get_contextMenu",
|
||||
"as3vm_TextField_get_defaultTextFormat",
|
||||
"as3vm_TextField_get_gridFitType",
|
||||
"as3vm_TextField_get_height",
|
||||
"as3vm_TextField_get_htmlText",
|
||||
"as3vm_TextField_get_length",
|
||||
"as3vm_TextField_get_maxChars",
|
||||
"as3vm_TextField_get_maxScrollH",
|
||||
"as3vm_TextField_get_maxScrollV",
|
||||
"as3vm_TextField_get_numLines",
|
||||
"as3vm_TextField_get_restrict",
|
||||
"as3vm_TextField_get_scrollH",
|
||||
"as3vm_TextField_get_scrollV",
|
||||
"as3vm_TextField_get_selectedText",
|
||||
"as3vm_TextField_get_selectionBeginIndex",
|
||||
"as3vm_TextField_get_selectionEndIndex",
|
||||
"as3vm_TextField_get_sharpness",
|
||||
"as3vm_TextField_get_styleSheet",
|
||||
"as3vm_TextField_get_text",
|
||||
"as3vm_TextField_get_textColor",
|
||||
"as3vm_TextField_get_textHeight",
|
||||
"as3vm_TextField_get_textWidth",
|
||||
"as3vm_TextField_get_thickness",
|
||||
"as3vm_TextField_get_type",
|
||||
"as3vm_TextField_get_width",
|
||||
"as3vm_TextField_replaceSelectedText",
|
||||
"as3vm_TextField_replaceText",
|
||||
"as3vm_TextField_setSelection",
|
||||
"as3vm_TextField_setTextFormat",
|
||||
"as3vm_TextField_set_antiAliasType",
|
||||
"as3vm_TextField_set_autoSize",
|
||||
"as3vm_TextField_set_backgroundColor",
|
||||
"as3vm_TextField_set_borderColor",
|
||||
"as3vm_TextField_set_defaultTextFormat",
|
||||
"as3vm_TextField_set_gridFitType",
|
||||
"as3vm_TextField_set_height",
|
||||
"as3vm_TextField_set_htmlText",
|
||||
"as3vm_TextField_set_maxChars",
|
||||
"as3vm_TextField_set_multiline",
|
||||
"as3vm_TextField_set_restrict",
|
||||
"as3vm_TextField_set_scrollH",
|
||||
"as3vm_TextField_set_scrollV",
|
||||
"as3vm_TextField_set_sharpness",
|
||||
"as3vm_TextField_set_styleSheet",
|
||||
"as3vm_TextField_set_text",
|
||||
"as3vm_TextField_set_textColor",
|
||||
"as3vm_TextField_set_thickness",
|
||||
"as3vm_TextField_set_type",
|
||||
"as3vm_TextField_set_width",
|
||||
"as3vm_TextField_set_wordWrap",
|
||||
"as3vm_TextFormat__construct",
|
||||
"as3vm_TextFormat_get_align",
|
||||
"as3vm_TextFormat_get_blockIndent",
|
||||
"as3vm_TextFormat_get_bold",
|
||||
"as3vm_TextFormat_get_bullet",
|
||||
"as3vm_TextFormat_get_color",
|
||||
"as3vm_TextFormat_get_font",
|
||||
"as3vm_TextFormat_get_indent",
|
||||
"as3vm_TextFormat_get_italic",
|
||||
"as3vm_TextFormat_get_kerning",
|
||||
"as3vm_TextFormat_get_leading",
|
||||
"as3vm_TextFormat_get_leftMargin",
|
||||
"as3vm_TextFormat_get_letterSpacing",
|
||||
"as3vm_TextFormat_get_rightMargin",
|
||||
"as3vm_TextFormat_get_size",
|
||||
"as3vm_TextFormat_get_tabStops",
|
||||
"as3vm_TextFormat_get_underline",
|
||||
"as3vm_TextFormat_set_align",
|
||||
"as3vm_TextFormat_set_blockIndent",
|
||||
"as3vm_TextFormat_set_bold",
|
||||
"as3vm_TextFormat_set_bullet",
|
||||
"as3vm_TextFormat_set_color",
|
||||
"as3vm_TextFormat_set_font",
|
||||
"as3vm_TextFormat_set_indent",
|
||||
"as3vm_TextFormat_set_italic",
|
||||
"as3vm_TextFormat_set_kerning",
|
||||
"as3vm_TextFormat_set_leading",
|
||||
"as3vm_TextFormat_set_leftMargin",
|
||||
"as3vm_TextFormat_set_letterSpacing",
|
||||
"as3vm_TextFormat_set_rightMargin",
|
||||
"as3vm_TextFormat_set_size",
|
||||
"as3vm_TextFormat_set_tabStops",
|
||||
"as3vm_TextFormat_set_underline",
|
||||
"as3vm_TextLineMetrics__construct",
|
||||
"as3vm_TextLineMetrics_get_ascent",
|
||||
"as3vm_TextLineMetrics_get_descent",
|
||||
"as3vm_TextLineMetrics_get_height",
|
||||
"as3vm_TextLineMetrics_get_leading",
|
||||
"as3vm_TextLineMetrics_get_width",
|
||||
"as3vm_TextLineMetrics_get_x",
|
||||
"as3vm_TextLineMetrics_set_ascent",
|
||||
"as3vm_TextLineMetrics_set_descent",
|
||||
"as3vm_TextLineMetrics_set_height",
|
||||
"as3vm_TextLineMetrics_set_leading",
|
||||
"as3vm_TextLineMetrics_set_width",
|
||||
"as3vm_TextLineMetrics_set_x",
|
||||
"as3vm_make_font_GC",
|
||||
"as3vm_make_textformat_GC",
|
||||
"as3vm_textfield_bool_getter",
|
||||
"as3vm_textfield_bool_setter",
|
||||
}
|
||||
# swf_as3_textfield owns NO externally named data global.
|
||||
EXPECTED_GLOBALS = set()
|
||||
|
||||
# The eight pure "unsupported" stubs (0x74 only); the rest are real bodies.
|
||||
STUB_FUNCTIONS = {
|
||||
"as3vm_Font_registerFont",
|
||||
"as3vm_TextLineMetrics__construct",
|
||||
"as3vm_TextLineMetrics_set_ascent",
|
||||
"as3vm_TextLineMetrics_set_descent",
|
||||
"as3vm_TextLineMetrics_set_height",
|
||||
"as3vm_TextLineMetrics_set_leading",
|
||||
"as3vm_TextLineMetrics_set_width",
|
||||
"as3vm_TextLineMetrics_set_x",
|
||||
}
|
||||
|
||||
# Genuine non-scaffolding imports present on all four retail objects (invariant).
|
||||
EXPECTED_IMPORTS = {
|
||||
"as3vm_InteractiveObject__construct", # as3vm flash.display base (DONE).
|
||||
"as3vm_component_parse_arguments_GC", # as3_component_helpers (DONE).
|
||||
"as3vm_exception_GC", # as3vm_interpreter (DONE).
|
||||
"as3vm_make_array_GC", # as3vm_create (DONE).
|
||||
"as3vm_make_int_GC", # as3vm_interpreter (DONE).
|
||||
"as3vm_make_number_GC", # as3vm_interpreter (DONE).
|
||||
"as3vm_make_object_no_constructor_GC", # as3vm_create (DONE).
|
||||
"as3vm_make_rectangle_GC", # as3vm_create (DONE).
|
||||
"as3vm_make_string_GC", # as3vm_interpreter (DONE).
|
||||
"as3vm_make_string_c_GC", # as3vm_interpreter (DONE).
|
||||
"as3vm_make_string_wc_GC", # as3vm_interpreter (DONE).
|
||||
"as3vm_make_stringdata_GC", # as3vm_interpreter (DONE).
|
||||
"as3vm_make_uint_GC", # as3vm_interpreter (DONE).
|
||||
"as3vm_makebool", # as3vm_interpreter DATA table (DONE).
|
||||
"as3vm_NaNf", # as3vm_interpreter DATA (DONE).
|
||||
"as3vm_nullundef_storage", # as3vm_interpreter DATA (DONE).
|
||||
"as3vm_truefalse_storage", # as3vm_interpreter DATA (DONE).
|
||||
"as3vm_write_barrier_slowpath", # as3vm_interpreter (DONE).
|
||||
"rr_isnan", # rrmath (DONE).
|
||||
"iggy_free_alloc", # iggy arena (DONE).
|
||||
"iggy_malloc_fileline", # iggy arena (DONE).
|
||||
"iggy_get_unsafe_glyph_for_codepoint", # swf_fontcache (DONE).
|
||||
"iggy_do_replace_text", # text engine (GENUINELY UNBUILT).
|
||||
"iggy_set_textfield_text", # text engine (GENUINELY UNBUILT).
|
||||
"iggy_set_textfield_htmltext", # text engine (GENUINELY UNBUILT).
|
||||
"iggy_textfield_compute_info", # text engine (GENUINELY UNBUILT).
|
||||
"iggy_textfield_reflow", # text engine (GENUINELY UNBUILT).
|
||||
"iggy_textfield_set_height", # text engine (GENUINELY UNBUILT).
|
||||
"iggy_textfield_set_width", # text engine (GENUINELY UNBUILT).
|
||||
"iggy_textfield_update_styles", # text engine (GENUINELY UNBUILT).
|
||||
}
|
||||
# Per-platform libm / libc symbols the retail optimizer emitted. sqrt (get_width /
|
||||
# get_height) and ceil (a scroll clamp) are libcalls on durango / vita, inlined on
|
||||
# orbis / ps3 (ps3 lowers ceil to ceilf); memcpy / memset are struct copies.
|
||||
PLATFORM_IMPORTS = {
|
||||
"durango": {"ceil", "sqrt", "memcpy", "memset"},
|
||||
"orbis": {"memcpy"},
|
||||
"ps3": {"ceilf", "memcpy", "memset"},
|
||||
"vita": {"ceil", "sqrt", "memcpy", "memset"},
|
||||
}
|
||||
RUNTIME_ALLOWLISTS = {
|
||||
"durango": {"_fltused", "__ImageBase", "__GSHandlerCheck",
|
||||
"__security_check_cookie", "__security_cookie"},
|
||||
"orbis": {"_GLOBAL_OFFSET_TABLE_"},
|
||||
"ps3": set(),
|
||||
"vita": {"__aeabi_unwind_cpp_pr0", "__aeabi_unwind_cpp_pr1",
|
||||
"__stack_chk_fail", "__stack_chk_guard"},
|
||||
}
|
||||
# libm / libc the fresh cross-compile may emit or inline differently than retail;
|
||||
# not part of the cross-module ABI contract, so tolerated in the reconstruction
|
||||
# import check (the retail check pins the exact per-platform set instead).
|
||||
LIBM_LIBC = {"ceil", "ceilf", "sqrt", "sqrtf", "memcpy", "memset", "memmove"}
|
||||
|
||||
# Every platform embeds __FILE__ via iggy_malloc_fileline, so the canonical path
|
||||
# is present everywhere; durango additionally carries its build .obj path.
|
||||
CANONICAL_PROVENANCE = r"c:\projects\g\src\flash\swf_as3_textfield.c"
|
||||
DURANGO_OBJ_PROVENANCE = (
|
||||
r"c:\projects\g\build\release\temps\libdu\iggy_durango"
|
||||
r"\swf_as3_textfield.obj")
|
||||
# (source_functions, raw line count) per platform. Exports (126) are invariant;
|
||||
# durango's source_functions is 129 (extra file-static helpers) while the other
|
||||
# three are 127. From iggy_<platform>.modules.tsv column 3 and `wc -l` on raw.
|
||||
RETAIL_INVENTORY = {
|
||||
"durango": (129, 3487),
|
||||
"orbis": (127, 3567),
|
||||
"ps3": (127, 3379),
|
||||
"vita": (127, 3973),
|
||||
}
|
||||
|
||||
|
||||
def normalized_symbol(name):
|
||||
name = name.removeprefix(".")
|
||||
name = name.removeprefix("__imp_")
|
||||
if name == "_setjmp":
|
||||
return "setjmp"
|
||||
return name
|
||||
|
||||
|
||||
class ReconstructedSwfAs3TextfieldCrossTests(unittest.TestCase):
|
||||
def _obj(self, platform):
|
||||
return ROOT / (
|
||||
f"work/iggy-native-decomp/{platform}-objects/swf_as3_textfield.obj")
|
||||
|
||||
def test_body_classification_is_one_hundred_twenty_six_exports(self):
|
||||
# Documentary: 126 exports = 8 pure 0x74 stubs + 118 real bodies.
|
||||
self.assertEqual(len(EXPECTED_FUNCTIONS), 126)
|
||||
self.assertEqual(len(STUB_FUNCTIONS), 8)
|
||||
self.assertTrue(STUB_FUNCTIONS <= EXPECTED_FUNCTIONS)
|
||||
self.assertEqual(len(EXPECTED_FUNCTIONS - STUB_FUNCTIONS), 118)
|
||||
self.assertEqual(len(EXPECTED_IMPORTS), 30)
|
||||
|
||||
def test_native_provenance_counts_source_path_and_inventory(self):
|
||||
# Retail evidence -- runs NOW. Exports present in nm, source_functions /
|
||||
# line counts in the symbols inventory, and provenance string embedded.
|
||||
for platform, (functions, lines) in RETAIL_INVENTORY.items():
|
||||
modules = ROOT / (
|
||||
f"iggy-decompiled/symbols/iggy_{platform}.modules.tsv")
|
||||
row = next(
|
||||
line for line in modules.read_text(encoding="utf-8").splitlines()
|
||||
if line.startswith("swf_as3_textfield\t"))
|
||||
self.assertEqual(int(row.split("\t")[2]), functions, platform)
|
||||
raw = ROOT / f"iggy-decompiled/raw/{platform}/swf_as3_textfield.c"
|
||||
self.assertEqual(
|
||||
len(raw.read_text(encoding="utf-8").splitlines()),
|
||||
lines, platform)
|
||||
obj = self._obj(platform)
|
||||
symbols = subprocess.run(
|
||||
["nm", "-g", str(obj)], capture_output=True, text=True)
|
||||
self.assertEqual(symbols.returncode, 0, (platform, symbols.stderr))
|
||||
normalized = symbols.stdout.replace(" .", " ")
|
||||
for symbol in EXPECTED_FUNCTIONS:
|
||||
self.assertIn(symbol, normalized, (platform, symbol))
|
||||
strings = subprocess.run(
|
||||
["strings", str(obj)], capture_output=True, text=True)
|
||||
self.assertIn(CANONICAL_PROVENANCE, strings.stdout, platform)
|
||||
durango_strings = subprocess.run(
|
||||
["strings", str(self._obj("durango"))],
|
||||
capture_output=True, text=True)
|
||||
self.assertIn(DURANGO_OBJ_PROVENANCE, durango_strings.stdout)
|
||||
|
||||
if SOURCE.exists():
|
||||
cmake = (RECONSTRUCTED / "CMakeLists.txt").read_text(
|
||||
encoding="utf-8")
|
||||
self.assertIn(
|
||||
"iggy_reconstructed_swf_as3_textfield_${platform}", cmake)
|
||||
self.assertIn(
|
||||
"add_library(${target} STATIC swf_as3_textfield.c)", cmake)
|
||||
self.assertIn(
|
||||
"IGGY_RECONSTRUCT_SWF_AS3_TEXTFIELD_${platform_upper}", cmake)
|
||||
inventory = (RECONSTRUCTED / "modules.tsv").read_text(
|
||||
encoding="utf-8")
|
||||
# Exports (126) are invariant; source_functions is 129 on durango and
|
||||
# 127 on the others (per-platform rows, like as3vm_convert).
|
||||
for platform, (functions, _lines) in RETAIL_INVENTORY.items():
|
||||
self.assertIn(
|
||||
f"swf_as3_textfield\t{functions}\t126\t{platform}\tcomplete",
|
||||
inventory)
|
||||
|
||||
def test_retail_object_owns_no_data_global_and_classifies_comdats(self):
|
||||
# Retail evidence -- runs NOW. No B/C-tagged externally named data
|
||||
# global; the durango ??_C@ symbols are R rodata artifacts, not owned data.
|
||||
if not LLVM_NM.exists():
|
||||
self.skipTest("llvm-nm unavailable")
|
||||
for platform in ("durango", "orbis", "ps3", "vita"):
|
||||
defined = subprocess.run(
|
||||
[str(LLVM_NM), "--extern-only", "--defined-only",
|
||||
str(self._obj(platform))],
|
||||
capture_output=True, text=True)
|
||||
self.assertEqual(defined.returncode, 0, platform)
|
||||
owned_data = set()
|
||||
for line in defined.stdout.splitlines():
|
||||
parts = line.split()
|
||||
if len(parts) < 2:
|
||||
continue
|
||||
tag, name = parts[-2].upper(), normalized_symbol(parts[-1])
|
||||
# A genuinely-owned data global would be B/C AND not just a ps3
|
||||
# .opd descriptor of an exported function.
|
||||
if tag in {"B", "C"} and name not in EXPECTED_FUNCTIONS:
|
||||
owned_data.add(name)
|
||||
# ??_C@ format literals must never surface as extern data.
|
||||
if name.startswith("??_C@"):
|
||||
self.assertEqual(tag, "R", (platform, name))
|
||||
self.assertEqual(owned_data, EXPECTED_GLOBALS, platform)
|
||||
|
||||
def test_retail_object_import_contract(self):
|
||||
# Retail evidence -- runs NOW. The genuine 30-symbol import set is
|
||||
# present and, after subtracting the toolchain allowlist, only the
|
||||
# per-platform libm / libc symbols remain.
|
||||
if not LLVM_NM.exists():
|
||||
self.skipTest("llvm-nm unavailable")
|
||||
for platform in ("durango", "orbis", "ps3", "vita"):
|
||||
undefined = subprocess.run(
|
||||
[str(LLVM_NM), "--undefined-only", str(self._obj(platform))],
|
||||
capture_output=True, text=True)
|
||||
self.assertEqual(undefined.returncode, 0, platform)
|
||||
imports = {normalized_symbol(line.split()[-1])
|
||||
for line in undefined.stdout.splitlines()
|
||||
if line.split()}
|
||||
self.assertTrue(
|
||||
EXPECTED_IMPORTS <= imports,
|
||||
(platform, EXPECTED_IMPORTS - imports))
|
||||
self.assertEqual(
|
||||
imports - EXPECTED_IMPORTS - RUNTIME_ALLOWLISTS[platform],
|
||||
PLATFORM_IMPORTS[platform], (platform, sorted(imports)))
|
||||
|
||||
def test_exact_exports_globals_normalized_imports_and_c_cpp_abi(self):
|
||||
# RED until the reconstruction exists; then the fresh cross-compile must
|
||||
# reproduce the exact export set, no owned global, and the invariant
|
||||
# cross-module import set on all four targets.
|
||||
self.assertTrue(SOURCE.exists(), f"missing {SOURCE}")
|
||||
self.assertTrue(HEADER.exists(), f"missing {HEADER}")
|
||||
self.assertIn(r"c:\\projects\\g\\src\\flash\\swf_as3_textfield.c",
|
||||
SOURCE.read_text(encoding="utf-8"))
|
||||
|
||||
function_pointers = "".join(
|
||||
f" (GenericFn)&{name},\n" for name in sorted(EXPECTED_FUNCTIONS))
|
||||
probe_text = (
|
||||
'#include <stdint.h>\n#include "swf_as3_textfield.h"\n'
|
||||
'typedef void (*GenericFn)(void);\n'
|
||||
'static GenericFn textfield_abis[] = {\n' + function_pointers + '};\n'
|
||||
'int use_abis(void) {\n'
|
||||
' for (unsigned i = 0; '
|
||||
'i < sizeof(textfield_abis) / sizeof(textfield_abis[0]); ++i) {\n'
|
||||
' if (!textfield_abis[i]) return 0;\n'
|
||||
' }\n'
|
||||
' return 1;\n'
|
||||
'}\n')
|
||||
|
||||
with tempfile.TemporaryDirectory() as directory:
|
||||
temporary = Path(directory)
|
||||
for platform, (compiler, target) in VARIANTS.items():
|
||||
extra = ["-mthumb"] if platform == "vita" else []
|
||||
output = temporary / f"swf_as3_textfield_{platform}.o"
|
||||
build = subprocess.run([
|
||||
compiler, "-target", target, "-ffreestanding",
|
||||
"-fno-builtin",
|
||||
"-c", "-std=c11", "-O2", "-Wall", "-Wextra", "-Werror",
|
||||
*extra,
|
||||
f"-DIGGY_RECONSTRUCT_SWF_AS3_TEXTFIELD_{platform.upper()}=1",
|
||||
"-I", str(RECONSTRUCTED), str(SOURCE), "-o", str(output),
|
||||
], capture_output=True, text=True)
|
||||
self.assertEqual(build.returncode, 0, (platform, build.stderr))
|
||||
if LLVM_NM.exists():
|
||||
defined = subprocess.run([
|
||||
str(LLVM_NM), "--extern-only", "--defined-only",
|
||||
str(output),
|
||||
], capture_output=True, text=True)
|
||||
undefined = subprocess.run([
|
||||
str(LLVM_NM), "--undefined-only", str(output),
|
||||
], capture_output=True, text=True)
|
||||
names = {normalized_symbol(parts[-1])
|
||||
for line in defined.stdout.splitlines()
|
||||
if len(parts := line.split()) >= 2 and
|
||||
parts[-2].upper() in {"T", "D", "B", "C"}}
|
||||
imports = {normalized_symbol(line.split()[-1])
|
||||
for line in undefined.stdout.splitlines()
|
||||
if line.split()}
|
||||
self.assertEqual(
|
||||
names, EXPECTED_FUNCTIONS | EXPECTED_GLOBALS, platform)
|
||||
# The cross-module import contract is exactly EXPECTED_IMPORTS
|
||||
# once toolchain scaffolding and optimizer-chosen libm / libc
|
||||
# are removed.
|
||||
residual = (imports - RUNTIME_ALLOWLISTS[platform]
|
||||
- LIBM_LIBC)
|
||||
self.assertEqual(residual, EXPECTED_IMPORTS,
|
||||
(platform, sorted(imports)))
|
||||
|
||||
for language, standard in (("c", "c11"), ("c++", "c++17")):
|
||||
suffix = "c" if language == "c" else "cpp"
|
||||
probe = temporary / f"swf_as3_textfield_abi_{platform}.{suffix}"
|
||||
probe.write_text(probe_text, encoding="utf-8")
|
||||
syntax = subprocess.run([
|
||||
compiler, "-target", target, "-ffreestanding",
|
||||
"-fsyntax-only", f"-std={standard}",
|
||||
"-Wall", "-Wextra", "-Werror", *extra,
|
||||
f"-DIGGY_RECONSTRUCT_SWF_AS3_TEXTFIELD_"
|
||||
f"{platform.upper()}=1",
|
||||
"-I", str(RECONSTRUCTED), str(probe),
|
||||
], capture_output=True, text=True)
|
||||
self.assertEqual(syntax.returncode, 0,
|
||||
(platform, language, syntax.stderr))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
Reference in New Issue
Block a user