@futpib/parser 1.0.1 → 1.0.3

package/build/dalvikBytecodeUnparser/formatUnparsers.d.ts

@@ -0,0 +1,152 @@
+import { type Unparser } from '../unparser.js';
+export declare const ubyteUnparser: Unparser<number, Uint8Array>;
+export declare const byteUnparser: Unparser<number, Uint8Array>;
+export declare const shortUnparser: Unparser<number, Uint8Array>;
+export declare const ushortUnparser: Unparser<number, Uint8Array>;
+export declare const intUnparser: Unparser<number, Uint8Array>;
+export declare const uintUnparser: Unparser<number, Uint8Array>;
+export declare const longUnparser: Unparser<bigint, Uint8Array>;
+export declare const ulongUnparser: Unparser<bigint, Uint8Array>;
+export declare const nibblesUnparser: Unparser<[number, number], Uint8Array>;
+type DalvikBytecodeFormat10t = {
+    branchOffset: number;
+};
+export declare const dalvikBytecodeFormat10tUnparser: Unparser<DalvikBytecodeFormat10t, Uint8Array>;
+type DalvikBytecodeFormat10x = void;
+export declare const dalvikBytecodeFormat10xUnparser: Unparser<DalvikBytecodeFormat10x, Uint8Array>;
+type DalvikBytecodeFormat11x = {
+    registers: number[];
+};
+export declare const dalvikBytecodeFormat11xUnparser: Unparser<DalvikBytecodeFormat11x, Uint8Array>;
+type DalvikBytecodeFormat11n = {
+    value: number;
+    registers: number[];
+};
+export declare const dalvikBytecodeFormat11nUnparser: Unparser<DalvikBytecodeFormat11n, Uint8Array>;
+type DalvikBytecodeFormat12x = {
+    registers: number[];
+};
+export declare const dalvikBytecodeFormat12xUnparser: Unparser<DalvikBytecodeFormat12x, Uint8Array>;
+export declare const dalvikBytecodeFormat12xReversedUnparser: Unparser<DalvikBytecodeFormat12x, Uint8Array>;
+type DalvikBytecodeFormat20t = {
+    branchOffset: number;
+};
+export declare const dalvikBytecodeFormat20tUnparser: Unparser<DalvikBytecodeFormat20t, Uint8Array>;
+type DalvikBytecodeFormat21c = {
+    index: number;
+    registers: number[];
+};
+export declare const dalvikBytecodeFormat21cUnparser: Unparser<DalvikBytecodeFormat21c, Uint8Array>;
+type DalvikBytecodeFormat21h = {
+    value: number;
+    registers: number[];
+};
+export declare const dalvikBytecodeFormat21hUnparser: Unparser<DalvikBytecodeFormat21h, Uint8Array>;
+type DalvikBytecodeFormat21t = {
+    branchOffset: number;
+    registers: number[];
+};
+export declare const dalvikBytecodeFormat21tUnparser: Unparser<DalvikBytecodeFormat21t, Uint8Array>;
+type DalvikBytecodeFormat21s = {
+    registers: number[];
+    value: number;
+};
+export declare const dalvikBytecodeFormat21sUnparser: Unparser<DalvikBytecodeFormat21s, Uint8Array>;
+type DalvikBytecodeFormat22b = {
+    registers: number[];
+    value: number;
+};
+export declare const dalvikBytecodeFormat22bUnparser: Unparser<DalvikBytecodeFormat22b, Uint8Array>;
+type DalvikBytecodeFormat22c = {
+    registers: number[];
+    index: number;
+};
+export declare const dalvikBytecodeFormat22cUnparser: Unparser<DalvikBytecodeFormat22c, Uint8Array>;
+type DalvikBytecodeFormat22s = {
+    value: number;
+    registers: number[];
+};
+export declare const dalvikBytecodeFormat22sUnparser: Unparser<DalvikBytecodeFormat22s, Uint8Array>;
+type DalvikBytecodeFormat22t = {
+    branchOffset: number;
+    registers: number[];
+};
+export declare const dalvikBytecodeFormat22tUnparser: Unparser<DalvikBytecodeFormat22t, Uint8Array>;
+export declare const dalvikBytecodeFormat22tCommutativeUnparser: Unparser<DalvikBytecodeFormat22t, Uint8Array>;
+type DalvikBytecodeFormat22x = {
+    registers: number[];
+};
+export declare const dalvikBytecodeFormat22xUnparser: Unparser<DalvikBytecodeFormat22x, Uint8Array>;
+type DalvikBytecodeFormat23x = {
+    registers: number[];
+};
+export declare const dalvikBytecodeFormat23xUnparser: Unparser<DalvikBytecodeFormat23x, Uint8Array>;
+type DalvikBytecodeFormat30t = {
+    branchOffset: number;
+};
+export declare const dalvikBytecodeFormat30tUnparser: Unparser<DalvikBytecodeFormat30t, Uint8Array>;
+type DalvikBytecodeFormat31i = {
+    value: number;
+    registers: number[];
+};
+export declare const dalvikBytecodeFormat31iUnparser: Unparser<DalvikBytecodeFormat31i, Uint8Array>;
+type DalvikBytecodeFormat31c = {
+    index: number;
+    registers: number[];
+};
+export declare const dalvikBytecodeFormat31cUnparser: Unparser<DalvikBytecodeFormat31c, Uint8Array>;
+type DalvikBytecodeFormat31t = {
+    branchOffset: number;
+    registers: number[];
+};
+export declare const dalvikBytecodeFormat31tUnparser: Unparser<DalvikBytecodeFormat31t, Uint8Array>;
+type DalvikBytecodeFormat32x = {
+    registers: number[];
+};
+export declare const dalvikBytecodeFormat32xUnparser: Unparser<DalvikBytecodeFormat32x, Uint8Array>;
+type DalvikBytecodeFormat35c = {
+    index: number;
+    registers: number[];
+};
+export declare const dalvikBytecodeFormat35cUnparser: Unparser<DalvikBytecodeFormat35c, Uint8Array>;
+type DalvikBytecodeFormat3rc = {
+    index: number;
+    registers: number[];
+};
+export declare const dalvikBytecodeFormat3rcUnparser: Unparser<DalvikBytecodeFormat3rc, Uint8Array>;
+type DalvikBytecodeFormat51l = {
+    value: bigint;
+    registers: number[];
+};
+export declare const dalvikBytecodeFormat51lUnparser: Unparser<DalvikBytecodeFormat51l, Uint8Array>;
+type DalvikBytecodeFormat45cc = {
+    methodIndex: number;
+    protoIndex: number;
+    registers: number[];
+};
+export declare const dalvikBytecodeFormat45ccUnparser: Unparser<DalvikBytecodeFormat45cc, Uint8Array>;
+type DalvikBytecodeFormat4rcc = {
+    methodIndex: number;
+    protoIndex: number;
+    registers: number[];
+};
+export declare const dalvikBytecodeFormat4rccUnparser: Unparser<DalvikBytecodeFormat4rcc, Uint8Array>;
+type DalvikBytecodeOperationPackedSwitchPayload = {
+    operation: 'packed-switch-payload';
+    value: number;
+    branchOffsets: number[];
+};
+export declare const dalvikBytecodeOperationPackedSwitchPayloadUnparser: Unparser<DalvikBytecodeOperationPackedSwitchPayload, Uint8Array>;
+type DalvikBytecodeOperationSparseSwitchPayload = {
+    operation: 'sparse-switch-payload';
+    keys: number[];
+    branchOffsets: number[];
+};
+export declare const dalvikBytecodeOperationSparseSwitchPayloadUnparser: Unparser<DalvikBytecodeOperationSparseSwitchPayload, Uint8Array>;
+type DalvikBytecodeOperationFillArrayDataPayload = {
+    operation: 'fill-array-data-payload';
+    elementWidth: number;
+    data: number[];
+};
+export declare const dalvikBytecodeOperationFillArrayDataPayloadUnparser: Unparser<DalvikBytecodeOperationFillArrayDataPayload, Uint8Array>;
+export {};

package/build/dalvikBytecodeUnparser/formatUnparsers.js

@@ -0,0 +1,225 @@
+// Basic type unparsers
+export const ubyteUnparser = async function* (input) {
+    const buffer = Buffer.alloc(1);
+    buffer.writeUInt8(input);
+    yield buffer;
+};
+export const byteUnparser = async function* (input) {
+    const buffer = Buffer.alloc(1);
+    buffer.writeInt8(input);
+    yield buffer;
+};
+export const shortUnparser = async function* (input) {
+    const buffer = Buffer.alloc(2);
+    buffer.writeInt16LE(input);
+    yield buffer;
+};
+export const ushortUnparser = async function* (input) {
+    const buffer = Buffer.alloc(2);
+    buffer.writeUInt16LE(input);
+    yield buffer;
+};
+export const intUnparser = async function* (input) {
+    const buffer = Buffer.alloc(4);
+    buffer.writeInt32LE(input);
+    yield buffer;
+};
+export const uintUnparser = async function* (input) {
+    const buffer = Buffer.alloc(4);
+    buffer.writeUInt32LE(input);
+    yield buffer;
+};
+export const longUnparser = async function* (input) {
+    const buffer = Buffer.alloc(8);
+    buffer.writeBigInt64LE(input);
+    yield buffer;
+};
+export const ulongUnparser = async function* (input) {
+    const buffer = Buffer.alloc(8);
+    buffer.writeBigUInt64LE(input);
+    yield buffer;
+};
+// Nibbles unparser (two 4-bit values in one byte)
+export const nibblesUnparser = async function* ([high, low], unparserContext) {
+    const byte = (high << 4) | (low & 0b1111);
+    yield* ubyteUnparser(byte, unparserContext);
+};
+export const dalvikBytecodeFormat10tUnparser = async function* (input, unparserContext) {
+    yield* byteUnparser(input.branchOffset, unparserContext);
+};
+export const dalvikBytecodeFormat10xUnparser = async function* (_input, unparserContext) {
+    yield* ubyteUnparser(0, unparserContext); // Zero byte
+};
+export const dalvikBytecodeFormat11xUnparser = async function* (input, unparserContext) {
+    yield* ubyteUnparser(input.registers[0], unparserContext);
+};
+export const dalvikBytecodeFormat11nUnparser = async function* (input, unparserContext) {
+    yield* nibblesUnparser([input.value & 0b1111, input.registers[0]], unparserContext);
+};
+export const dalvikBytecodeFormat12xUnparser = async function* (input, unparserContext) {
+    yield* nibblesUnparser([input.registers[0], input.registers[1]], unparserContext);
+};
+// Format 12x with reversed registers (for operations like array-length that reverse in parser)
+export const dalvikBytecodeFormat12xReversedUnparser = async function* (input, unparserContext) {
+    yield* nibblesUnparser([input.registers[1], input.registers[0]], unparserContext);
+};
+export const dalvikBytecodeFormat20tUnparser = async function* (input, unparserContext) {
+    yield* ubyteUnparser(0, unparserContext);
+    yield* shortUnparser(input.branchOffset, unparserContext);
+};
+export const dalvikBytecodeFormat21cUnparser = async function* (input, unparserContext) {
+    yield* ubyteUnparser(input.registers[0], unparserContext);
+    yield* ushortUnparser(input.index, unparserContext);
+};
+export const dalvikBytecodeFormat21hUnparser = async function* (input, unparserContext) {
+    yield* ubyteUnparser(input.registers[0], unparserContext);
+    yield* ushortUnparser(input.value, unparserContext);
+};
+export const dalvikBytecodeFormat21tUnparser = async function* (input, unparserContext) {
+    yield* ubyteUnparser(input.registers[0], unparserContext);
+    yield* shortUnparser(input.branchOffset, unparserContext);
+};
+export const dalvikBytecodeFormat21sUnparser = async function* (input, unparserContext) {
+    yield* ubyteUnparser(input.registers[0], unparserContext);
+    yield* shortUnparser(input.value, unparserContext);
+};
+export const dalvikBytecodeFormat22bUnparser = async function* (input, unparserContext) {
+    yield* ubyteUnparser(input.registers[0], unparserContext);
+    yield* ubyteUnparser(input.registers[1], unparserContext);
+    yield* byteUnparser(input.value, unparserContext);
+};
+export const dalvikBytecodeFormat22cUnparser = async function* (input, unparserContext) {
+    yield* nibblesUnparser([input.registers[1], input.registers[0]], unparserContext);
+    yield* ushortUnparser(input.index, unparserContext);
+};
+export const dalvikBytecodeFormat22sUnparser = async function* (input, unparserContext) {
+    yield* nibblesUnparser([input.registers[1], input.registers[0]], unparserContext);
+    yield* shortUnparser(input.value, unparserContext);
+};
+export const dalvikBytecodeFormat22tUnparser = async function* (input, unparserContext) {
+    yield* nibblesUnparser([input.registers[1], input.registers[0]], unparserContext);
+    yield* shortUnparser(input.branchOffset, unparserContext);
+};
+// Format 22t for commutative operations (if-eq, if-ne): registers are already in sorted/canonical order
+// so we don't reverse them
+export const dalvikBytecodeFormat22tCommutativeUnparser = async function* (input, unparserContext) {
+    yield* nibblesUnparser([input.registers[0], input.registers[1]], unparserContext);
+    yield* shortUnparser(input.branchOffset, unparserContext);
+};
+export const dalvikBytecodeFormat22xUnparser = async function* (input, unparserContext) {
+    yield* ubyteUnparser(input.registers[0], unparserContext);
+    yield* ushortUnparser(input.registers[1], unparserContext);
+};
+export const dalvikBytecodeFormat23xUnparser = async function* (input, unparserContext) {
+    yield* ubyteUnparser(input.registers[0], unparserContext);
+    yield* ubyteUnparser(input.registers[1], unparserContext);
+    yield* ubyteUnparser(input.registers[2], unparserContext);
+};
+export const dalvikBytecodeFormat30tUnparser = async function* (input, unparserContext) {
+    yield* intUnparser(input.branchOffset, unparserContext);
+};
+export const dalvikBytecodeFormat31iUnparser = async function* (input, unparserContext) {
+    yield* ubyteUnparser(input.registers[0], unparserContext);
+    yield* intUnparser(input.value, unparserContext);
+};
+export const dalvikBytecodeFormat31cUnparser = async function* (input, unparserContext) {
+    yield* ubyteUnparser(input.registers[0], unparserContext);
+    yield* uintUnparser(input.index, unparserContext);
+};
+export const dalvikBytecodeFormat31tUnparser = async function* (input, unparserContext) {
+    yield* ubyteUnparser(input.registers[0], unparserContext);
+    yield* intUnparser(input.branchOffset, unparserContext);
+};
+export const dalvikBytecodeFormat32xUnparser = async function* (input, unparserContext) {
+    yield* ushortUnparser(input.registers[0], unparserContext);
+    yield* ushortUnparser(input.registers[1], unparserContext);
+};
+export const dalvikBytecodeFormat35cUnparser = async function* (input, unparserContext) {
+    const registerCount = input.registers.length;
+    const register4 = input.registers[4] ?? 0;
+    const register3 = input.registers[3] ?? 0;
+    const register2 = input.registers[2] ?? 0;
+    const register1 = input.registers[1] ?? 0;
+    const register0 = input.registers[0] ?? 0;
+    yield* nibblesUnparser([registerCount, register4], unparserContext);
+    yield* ushortUnparser(input.index, unparserContext);
+    yield* nibblesUnparser([register1, register0], unparserContext);
+    yield* nibblesUnparser([register3, register2], unparserContext);
+};
+export const dalvikBytecodeFormat3rcUnparser = async function* (input, unparserContext) {
+    const registerCount = input.registers.length;
+    const firstRegister = input.registers[0] ?? 0;
+    yield* ubyteUnparser(registerCount, unparserContext);
+    yield* ushortUnparser(input.index, unparserContext);
+    yield* ushortUnparser(firstRegister, unparserContext);
+};
+export const dalvikBytecodeFormat51lUnparser = async function* (input, unparserContext) {
+    yield* ubyteUnparser(input.registers[0], unparserContext);
+    yield* longUnparser(input.value, unparserContext);
+};
+export const dalvikBytecodeFormat45ccUnparser = async function* (input, unparserContext) {
+    const registerCount = input.registers.length;
+    const register4 = input.registers[4] ?? 0;
+    const register3 = input.registers[3] ?? 0;
+    const register2 = input.registers[2] ?? 0;
+    const register1 = input.registers[1] ?? 0;
+    const register0 = input.registers[0] ?? 0;
+    yield* nibblesUnparser([registerCount, register4], unparserContext);
+    yield* ushortUnparser(input.methodIndex, unparserContext);
+    yield* nibblesUnparser([register1, register0], unparserContext);
+    yield* nibblesUnparser([register3, register2], unparserContext);
+    yield* ushortUnparser(input.protoIndex, unparserContext);
+};
+export const dalvikBytecodeFormat4rccUnparser = async function* (input, unparserContext) {
+    const registerCount = input.registers.length;
+    const firstRegister = input.registers[0] ?? 0;
+    yield* ubyteUnparser(registerCount, unparserContext);
+    yield* ushortUnparser(input.methodIndex, unparserContext);
+    yield* ushortUnparser(firstRegister, unparserContext);
+    yield* ushortUnparser(input.protoIndex, unparserContext);
+};
+export const dalvikBytecodeOperationPackedSwitchPayloadUnparser = async function* (input, unparserContext) {
+    // Ident (0x0100) - little-endian
+    yield* ushortUnparser(0x01_00, unparserContext);
+    // Size
+    yield* ushortUnparser(input.branchOffsets.length, unparserContext);
+    // First key value
+    yield* intUnparser(input.value, unparserContext);
+    // Branch offsets
+    for (const offset of input.branchOffsets) {
+        yield* intUnparser(offset, unparserContext);
+    }
+};
+export const dalvikBytecodeOperationSparseSwitchPayloadUnparser = async function* (input, unparserContext) {
+    // Ident (0x0200) - little-endian
+    yield* ushortUnparser(0x02_00, unparserContext);
+    // Size
+    yield* ushortUnparser(input.keys.length, unparserContext);
+    // Keys
+    for (const key of input.keys) {
+        yield* intUnparser(key, unparserContext);
+    }
+    // Branch offsets
+    for (const offset of input.branchOffsets) {
+        yield* intUnparser(offset, unparserContext);
+    }
+};
+export const dalvikBytecodeOperationFillArrayDataPayloadUnparser = async function* (input, unparserContext) {
+    // Ident (0x0300) - little-endian
+    yield* ushortUnparser(0x03_00, unparserContext);
+    // Element width
+    yield* ushortUnparser(input.elementWidth, unparserContext);
+    // Size (number of elements) - data array contains bytes, so divide by elementWidth
+    const numElements = Math.floor(input.data.length / input.elementWidth);
+    yield* uintUnparser(numElements, unparserContext);
+    // Data (each byte from the data array)
+    for (const byte of input.data) {
+        yield* ubyteUnparser(byte, unparserContext);
+    }
+    // Padding if needed (align to 2-byte boundary)
+    const dataSize = input.data.length;
+    const paddingSize = dataSize % 2;
+    if (paddingSize === 1) {
+        yield* ubyteUnparser(0, unparserContext);
+    }
+};

package/build/dalvikBytecodeUnparser.d.ts

@@ -0,0 +1,3 @@
+import { type Unparser } from './unparser.js';
+import { type DalvikBytecode } from './dalvikBytecodeParser.js';
+export declare const dalvikBytecodeUnparser: Unparser<DalvikBytecode, Uint8Array>;