@futpib/parser 1.0.2 → 1.0.3

package/build/dalvikExecutableUnparser/annotationUnparsers.js

@@ -0,0 +1,97 @@
+async function* yieldAndCapture(gen) {
+    let value;
+    for await (value of gen) {
+        yield value;
+    }
+    return value;
+}
+import { ubyteUnparser, uintUnparser } from '../dalvikBytecodeUnparser/formatUnparsers.js';
+import { alignmentUnparser, uleb128Unparser } from './utils.js';
+export function createAnnotationUnparsers(getStringIndex, getTypeIndex, getFieldIndex, getMethodIndex, encodedValueUnparser) {
+    const annotationItemUnparser = async function* (input, unparserContext) {
+        const visibilityByte = input.visibility === 'build' ? 0x00 : input.visibility === 'runtime' ? 0x01 : 0x02;
+        yield* ubyteUnparser(visibilityByte, unparserContext);
+        const typeIndex = getTypeIndex(input.type);
+        yield* uleb128Unparser(typeIndex, unparserContext);
+        yield* uleb128Unparser(input.elements.length, unparserContext);
+        for (const element of input.elements) {
+            const nameIndex = getStringIndex(element.name);
+            yield* uleb128Unparser(nameIndex, unparserContext);
+            yield* encodedValueUnparser(element.value, unparserContext);
+        }
+    };
+    const annotationSetItemUnparser = (annotationItemOffsetWriteLaters) => {
+        return async function* (input, unparserContext) {
+            yield* alignmentUnparser(4)(undefined, unparserContext);
+            yield* uintUnparser(input.length, unparserContext);
+            for (const annotation of input) {
+                const annotationOffsetWriteLater = yield* yieldAndCapture(unparserContext.writeLater(4));
+                annotationItemOffsetWriteLaters.push(annotationOffsetWriteLater);
+            }
+        };
+    };
+    const annotationSetRefListUnparser = (annotationSetOffsetWriteLaters) => {
+        return async function* (input, unparserContext) {
+            yield* alignmentUnparser(4)(undefined, unparserContext);
+            yield* uintUnparser(input.length, unparserContext);
+            for (const annotationSet of input) {
+                if (annotationSet.length > 0) {
+                    const annotationSetOffsetWriteLater = yield* yieldAndCapture(unparserContext.writeLater(4));
+                    annotationSetOffsetWriteLaters.push(annotationSetOffsetWriteLater);
+                }
+                else {
+                    annotationSetOffsetWriteLaters.push(null);
+                    yield* uintUnparser(0, unparserContext);
+                }
+            }
+        };
+    };
+    const annotationsDirectoryItemUnparser = (annotationOffsetWriteLaters) => {
+        return async function* (input, unparserContext) {
+            yield* alignmentUnparser(4)(undefined, unparserContext);
+            if (input.classAnnotations.length > 0) {
+                const classAnnotationsOffsetWriteLater = yield* yieldAndCapture(unparserContext.writeLater(4));
+                annotationOffsetWriteLaters.classAnnotationsOffsetWriteLater = classAnnotationsOffsetWriteLater;
+            }
+            else {
+                yield* uintUnparser(0, unparserContext);
+            }
+            yield* uintUnparser(input.fieldAnnotations.length, unparserContext);
+            yield* uintUnparser(input.methodAnnotations.length, unparserContext);
+            yield* uintUnparser(input.parameterAnnotations.length, unparserContext);
+            annotationOffsetWriteLaters.fieldAnnotationsOffsetWriteLaters = [];
+            for (const fieldAnnotation of input.fieldAnnotations) {
+                const fieldIndex = getFieldIndex(fieldAnnotation.field);
+                yield* uintUnparser(fieldIndex, unparserContext);
+                if (fieldAnnotation.annotations && fieldAnnotation.annotations.length > 0) {
+                    const annotationsOffsetWriteLater = yield* yieldAndCapture(unparserContext.writeLater(4));
+                    annotationOffsetWriteLaters.fieldAnnotationsOffsetWriteLaters.push(annotationsOffsetWriteLater);
+                }
+                else {
+                    annotationOffsetWriteLaters.fieldAnnotationsOffsetWriteLaters.push(null);
+                    yield* uintUnparser(0, unparserContext);
+                }
+            }
+            annotationOffsetWriteLaters.methodAnnotationsOffsetWriteLaters = [];
+            for (const methodAnnotation of input.methodAnnotations) {
+                const methodIndex = getMethodIndex(methodAnnotation.method);
+                yield* uintUnparser(methodIndex, unparserContext);
+                const annotationsOffsetWriteLater = yield* yieldAndCapture(unparserContext.writeLater(4));
+                annotationOffsetWriteLaters.methodAnnotationsOffsetWriteLaters.push(annotationsOffsetWriteLater);
+            }
+            annotationOffsetWriteLaters.parameterAnnotationsOffsetWriteLaters = [];
+            for (const paramAnnotation of input.parameterAnnotations) {
+                const methodIndex = getMethodIndex(paramAnnotation.method);
+                yield* uintUnparser(methodIndex, unparserContext);
+                const annotationsOffsetWriteLater = yield* yieldAndCapture(unparserContext.writeLater(4));
+                annotationOffsetWriteLaters.parameterAnnotationsOffsetWriteLaters.push(annotationsOffsetWriteLater);
+            }
+        };
+    };
+    return {
+        annotationItemUnparser,
+        annotationSetItemUnparser,
+        annotationSetRefListUnparser,
+        annotationsDirectoryItemUnparser,
+    };
+}

package/build/dalvikExecutableUnparser/poolBuilders.d.ts

@@ -0,0 +1,49 @@
+import { type DalvikExecutableField, type DalvikExecutableMethod, type DalvikExecutablePrototype } from '../dalvikExecutable.js';
+export declare class StringPoolBuilder {
+    private strings;
+    private stringToIndex;
+    add(str: string): number;
+    getIndex(str: string): number | undefined;
+    getStrings(): string[];
+    size(): number;
+}
+export declare class TypePoolBuilder {
+    private types;
+    private typeToIndex;
+    add(typeDescriptor: string): number;
+    getIndex(typeDescriptor: string): number | undefined;
+    getTypes(): string[];
+    size(): number;
+}
+export declare class ProtoPoolBuilder {
+    private protos;
+    private protoToIndex;
+    add(proto: DalvikExecutablePrototype): number;
+    getIndex(proto: DalvikExecutablePrototype): number | undefined;
+    getProtos(): DalvikExecutablePrototype[];
+    size(): number;
+}
+export declare class FieldPoolBuilder {
+    private fields;
+    private fieldToIndex;
+    add(field: DalvikExecutableField): number;
+    getIndex(field: DalvikExecutableField): number | undefined;
+    getFields(): DalvikExecutableField[];
+    size(): number;
+}
+export declare class MethodPoolBuilder {
+    private methods;
+    private methodToIndex;
+    add(method: DalvikExecutableMethod): number;
+    getIndex(method: DalvikExecutableMethod): number | undefined;
+    getMethods(): DalvikExecutableMethod[];
+    size(): number;
+}
+export interface PoolBuilders {
+    stringPool: StringPoolBuilder;
+    typePool: TypePoolBuilder;
+    protoPool: ProtoPoolBuilder;
+    fieldPool: FieldPoolBuilder;
+    methodPool: MethodPoolBuilder;
+}
+export declare function createPoolBuilders(): PoolBuilders;

package/build/dalvikExecutableUnparser/poolBuilders.js

@@ -0,0 +1,140 @@
+export class StringPoolBuilder {
+    strings = [];
+    stringToIndex = new Map();
+    add(str) {
+        const existing = this.stringToIndex.get(str);
+        if (existing !== undefined) {
+            return existing;
+        }
+        const index = this.strings.length;
+        this.strings.push(str);
+        this.stringToIndex.set(str, index);
+        return index;
+    }
+    getIndex(str) {
+        return this.stringToIndex.get(str);
+    }
+    getStrings() {
+        return this.strings;
+    }
+    size() {
+        return this.strings.length;
+    }
+}
+export class TypePoolBuilder {
+    types = [];
+    typeToIndex = new Map();
+    add(typeDescriptor) {
+        const existing = this.typeToIndex.get(typeDescriptor);
+        if (existing !== undefined) {
+            return existing;
+        }
+        const index = this.types.length;
+        this.types.push(typeDescriptor);
+        this.typeToIndex.set(typeDescriptor, index);
+        return index;
+    }
+    getIndex(typeDescriptor) {
+        return this.typeToIndex.get(typeDescriptor);
+    }
+    getTypes() {
+        return this.types;
+    }
+    size() {
+        return this.types.length;
+    }
+}
+function prototypeKey(proto) {
+    return `${proto.shorty}:${proto.returnType}:(${proto.parameters.join(',')})`;
+}
+export class ProtoPoolBuilder {
+    protos = [];
+    protoToIndex = new Map();
+    add(proto) {
+        const key = prototypeKey(proto);
+        const existing = this.protoToIndex.get(key);
+        if (existing !== undefined) {
+            return existing;
+        }
+        const index = this.protos.length;
+        this.protos.push(proto);
+        this.protoToIndex.set(key, index);
+        return index;
+    }
+    getIndex(proto) {
+        const key = prototypeKey(proto);
+        return this.protoToIndex.get(key);
+    }
+    getProtos() {
+        return this.protos;
+    }
+    size() {
+        return this.protos.length;
+    }
+}
+function fieldKey(field) {
+    return `${field.class}:${field.type}:${field.name}`;
+}
+export class FieldPoolBuilder {
+    fields = [];
+    fieldToIndex = new Map();
+    add(field) {
+        const key = fieldKey(field);
+        const existing = this.fieldToIndex.get(key);
+        if (existing !== undefined) {
+            return existing;
+        }
+        const index = this.fields.length;
+        this.fields.push(field);
+        this.fieldToIndex.set(key, index);
+        return index;
+    }
+    getIndex(field) {
+        const key = fieldKey(field);
+        return this.fieldToIndex.get(key);
+    }
+    getFields() {
+        return this.fields;
+    }
+    size() {
+        return this.fields.length;
+    }
+}
+function methodKey(method) {
+    const protoKey = prototypeKey(method.prototype);
+    return `${method.class}:${protoKey}:${method.name}`;
+}
+export class MethodPoolBuilder {
+    methods = [];
+    methodToIndex = new Map();
+    add(method) {
+        const key = methodKey(method);
+        const existing = this.methodToIndex.get(key);
+        if (existing !== undefined) {
+            return existing;
+        }
+        const index = this.methods.length;
+        this.methods.push(method);
+        this.methodToIndex.set(key, index);
+        return index;
+    }
+    getIndex(method) {
+        const key = methodKey(method);
+        return this.methodToIndex.get(key);
+    }
+    getMethods() {
+        return this.methods;
+    }
+    size() {
+        return this.methods.length;
+    }
+}
+export function createPoolBuilders() {
+    return {
+        stringPool: new StringPoolBuilder(),
+        typePool: new TypePoolBuilder(),
+        protoPool: new ProtoPoolBuilder(),
+        fieldPool: new FieldPoolBuilder(),
+        methodPool: new MethodPoolBuilder(),
+    };
+}

package/build/dalvikExecutableUnparser/poolScanners.d.ts

@@ -0,0 +1,4 @@
+import { type DalvikExecutable } from '../dalvikExecutable.js';
+import { type DalvikBytecode } from '../dalvikBytecodeParser.js';
+import { type PoolBuilders } from './poolBuilders.js';
+export declare function scanForPoolReferences(dalvikExecutable: DalvikExecutable<DalvikBytecode>, poolBuilders: PoolBuilders): void;

package/build/dalvikExecutableUnparser/poolScanners.js

@@ -0,0 +1,220 @@
+import { isDalvikExecutableField, isDalvikExecutableMethod, } from '../dalvikExecutable.js';
+export function scanForPoolReferences(dalvikExecutable, poolBuilders) {
+    const { stringPool, typePool, protoPool, fieldPool, methodPool } = poolBuilders;
+    for (const classDef of dalvikExecutable.classDefinitions) {
+        scanClassDefinition(classDef);
+    }
+    function addString(str) {
+        if (str !== undefined) {
+            stringPool.add(str);
+        }
+    }
+    function addType(typeDescriptor) {
+        if (typeDescriptor !== undefined) {
+            typePool.add(typeDescriptor);
+            stringPool.add(typeDescriptor);
+        }
+    }
+    function addPrototype(proto) {
+        protoPool.add(proto);
+        addString(proto.shorty);
+        addType(proto.returnType);
+        for (const param of proto.parameters) {
+            addType(param);
+        }
+    }
+    function addField(field) {
+        fieldPool.add(field);
+        addType(field.class);
+        addType(field.type);
+        addString(field.name);
+    }
+    function addMethod(method) {
+        methodPool.add(method);
+        addType(method.class);
+        addPrototype(method.prototype);
+        addString(method.name);
+    }
+    function scanEncodedValue(value) {
+        const { type, value: innerValue } = value;
+        // Handle primitive types - they don't need pool entries
+        if (type === 'byte'
+            || type === 'short'
+            || type === 'char'
+            || type === 'int'
+            || type === 'long'
+            || type === 'float'
+            || type === 'double'
+            || type === 'boolean'
+            || type === 'null'
+            || type === 'methodHandle') {
+            return;
+        }
+        // Handle types that need pool entries
+        if (type === 'string') {
+            addString(innerValue);
+            return;
+        }
+        if (type === 'type') {
+            addType(innerValue);
+            return;
+        }
+        if (type === 'field' || type === 'enum') {
+            addField(innerValue);
+            return;
+        }
+        if (type === 'method') {
+            addMethod(innerValue);
+            return;
+        }
+        if (type === 'methodType') {
+            addPrototype(innerValue);
+            return;
+        }
+        // Handle arrays recursively
+        if (type === 'array') {
+            for (const element of innerValue) {
+                scanEncodedValue(element);
+            }
+            return;
+        }
+        // Handle annotations
+        if (type === 'annotation') {
+            scanAnnotation(innerValue);
+        }
+    }
+    function scanAnnotation(annotation) {
+        addType(annotation.type);
+        for (const element of annotation.elements) {
+            addString(element.name);
+            scanEncodedValue(element.value);
+        }
+    }
+    function scanAnnotations(annotations) {
+        if (!annotations) {
+            return;
+        }
+        for (const annotation of annotations.classAnnotations) {
+            scanAnnotation(annotation);
+        }
+        for (const fieldAnnotation of annotations.fieldAnnotations) {
+            addField(fieldAnnotation.field);
+            if (fieldAnnotation.annotations) {
+                for (const annotation of fieldAnnotation.annotations) {
+                    scanAnnotation(annotation);
+                }
+            }
+        }
+        for (const methodAnnotation of annotations.methodAnnotations) {
+            addMethod(methodAnnotation.method);
+            for (const annotation of methodAnnotation.annotations) {
+                scanAnnotation(annotation);
+            }
+        }
+        for (const paramAnnotation of annotations.parameterAnnotations) {
+            addMethod(paramAnnotation.method);
+            for (const paramAnnotations of paramAnnotation.annotations) {
+                for (const annotation of paramAnnotations) {
+                    scanAnnotation(annotation);
+                }
+            }
+        }
+    }
+    function scanDebugInfo(debugInfo) {
+        if (!debugInfo) {
+            return;
+        }
+        for (const paramName of debugInfo.parameterNames) {
+            addString(paramName);
+        }
+        for (const bytecode of debugInfo.bytecode) {
+            if (bytecode.type === 'startLocal' || bytecode.type === 'startLocalExtended') {
+                addString(bytecode.name);
+                addType(bytecode.type_);
+            }
+            if (bytecode.type === 'startLocalExtended') {
+                addString(bytecode.signature);
+            }
+            if (bytecode.type === 'setFile') {
+                addString(bytecode.name);
+            }
+        }
+    }
+    function scanCode(code) {
+        if (!code) {
+            return;
+        }
+        scanDebugInfo(code.debugInfo);
+        for (const operation of code.instructions) {
+            if ('methodIndex' in operation) {
+                const methodIndex = operation.methodIndex;
+                if (isDalvikExecutableMethod(methodIndex)) {
+                    addMethod(methodIndex);
+                }
+            }
+            if ('fieldIndex' in operation) {
+                const fieldIndex = operation.fieldIndex;
+                if (isDalvikExecutableField(fieldIndex)) {
+                    addField(fieldIndex);
+                }
+            }
+            if ('typeIndex' in operation) {
+                const typeIndex = operation.typeIndex;
+                if (typeof typeIndex === 'string') {
+                    addType(typeIndex);
+                }
+            }
+            if ('stringIndex' in operation) {
+                const stringIndex = operation.stringIndex;
+                if (typeof stringIndex === 'string') {
+                    addString(stringIndex);
+                }
+            }
+            if ('protoIndex' in operation) {
+                const protoIndex = operation.protoIndex;
+                if (typeof protoIndex === 'object' && protoIndex !== null && 'returnType' in protoIndex) {
+                    addPrototype(protoIndex);
+                }
+            }
+        }
+        for (const tryBlock of code.tries) {
+            for (const handler of tryBlock.handler.handlers) {
+                addType(handler.type);
+            }
+        }
+    }
+    function scanMethod(method) {
+        addMethod(method.method);
+        scanCode(method.code);
+    }
+    function scanClassData(classData) {
+        if (!classData) {
+            return;
+        }
+        for (const field of classData.staticFields) {
+            addField(field.field);
+        }
+        for (const field of classData.instanceFields) {
+            addField(field.field);
+        }
+        for (const method of classData.directMethods) {
+            scanMethod(method);
+        }
+        for (const method of classData.virtualMethods) {
+            scanMethod(method);
+        }
+    }
+    function scanClassDefinition(classDef) {
+        addType(classDef.class);
+        addType(classDef.superclass);
+        for (const iface of classDef.interfaces) {
+            addType(iface);
+        }
+        addString(classDef.sourceFile);
+        scanAnnotations(classDef.annotations);
+        for (const value of classDef.staticValues) {
+            scanEncodedValue(value);
+        }
+        scanClassData(classDef.classData);
+    }
+}

package/build/dalvikExecutableUnparser/sectionUnparsers.d.ts

@@ -0,0 +1,25 @@
+import { type Unparser } from '../unparser.js';
+import { type DalvikExecutableAccessFlags, type DalvikExecutableClassData, type DalvikExecutableCode, type DalvikExecutableDebugInfo, type DalvikExecutableEncodedValue, type DalvikExecutableField, type DalvikExecutableMethod, type DalvikExecutablePrototype } from '../dalvikExecutable.js';
+import { type DalvikBytecode } from '../dalvikBytecodeParser.js';
+import { type PoolBuilders } from './poolBuilders.js';
+import { WriteLater } from '../unparserContext.js';
+export declare function createSectionUnparsers(poolBuilders: PoolBuilders): {
+    stringDataUnparser: Unparser<string, Uint8Array<ArrayBufferLike>>;
+    typeListUnparser: Unparser<string[], Uint8Array<ArrayBufferLike>>;
+    protoDataUnparser: Unparser<DalvikExecutablePrototype, Uint8Array<ArrayBufferLike>>;
+    fieldIdUnparser: Unparser<DalvikExecutableField, Uint8Array<ArrayBufferLike>>;
+    methodIdUnparser: Unparser<DalvikExecutableMethod, Uint8Array<ArrayBufferLike>>;
+    encodedValueUnparser: Unparser<DalvikExecutableEncodedValue, Uint8Array<ArrayBufferLike>>;
+    encodedArrayUnparser: Unparser<DalvikExecutableEncodedValue[], Uint8Array<ArrayBufferLike>>;
+    debugInfoUnparser: Unparser<DalvikExecutableDebugInfo, Uint8Array<ArrayBufferLike>>;
+    codeItemUnparser: (callback?: (result: {
+        debugInfoOffsetWriteLater?: WriteLater<Uint8Array, number>;
+    }) => void) => Unparser<DalvikExecutableCode<DalvikBytecode>, Uint8Array>;
+    classDataUnparser: (codeOffsetMap: Map<DalvikExecutableCode<DalvikBytecode>, number>) => Unparser<DalvikExecutableClassData<DalvikBytecode>, Uint8Array>;
+    accessFlagsToNumber: (accessFlags: DalvikExecutableAccessFlags) => number;
+    getStringIndex: (str: string | undefined) => number;
+    getTypeIndex: (typeDescriptor: string | undefined) => number;
+    getProtoIndex: (proto: DalvikExecutablePrototype) => number;
+    getFieldIndex: (field: DalvikExecutableField) => number;
+    getMethodIndex: (method: DalvikExecutableMethod) => number;
+};