@futpib/parser 1.0.2 → 1.0.4

package/src/dalvikExecutableUnparser/annotationUnparsers.ts

@@ -0,0 +1,135 @@
+import { type Unparser } from '../unparser.js';
+
+async function* yieldAndCapture<T>(gen: AsyncIterable<T, T>): AsyncIterable<T, T> {
+	let value: T | undefined;
+	for await (value of gen) {
+		yield value;
+	}
+	return value!;
+}
+import {
+	type DalvikExecutableAnnotation,
+	type DalvikExecutableClassAnnotations,
+	type DalvikExecutableEncodedValue,
+	type DalvikExecutableField,
+	type DalvikExecutableMethod,
+} from '../dalvikExecutable.js';
+import { ubyteUnparser, uintUnparser } from '../dalvikBytecodeUnparser/formatUnparsers.js';
+import { alignmentUnparser, uleb128Unparser } from './utils.js';
+import { WriteLater } from '../unparserContext.js';
+
+export function createAnnotationUnparsers(
+	getStringIndex: (str: string | undefined) => number,
+	getTypeIndex: (typeDescriptor: string | undefined) => number,
+	getFieldIndex: (field: DalvikExecutableField) => number,
+	getMethodIndex: (method: DalvikExecutableMethod) => number,
+	encodedValueUnparser: Unparser<DalvikExecutableEncodedValue, Uint8Array>,
+) {
+	const annotationItemUnparser: Unparser<DalvikExecutableAnnotation, Uint8Array> = 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: Array<WriteLater<Uint8Array, number>>): Unparser<DalvikExecutableAnnotation[], Uint8Array> => {
+		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: Array<WriteLater<Uint8Array, number> | null>): Unparser<DalvikExecutableAnnotation[][], Uint8Array> => {
+		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: {
+		classAnnotationsOffsetWriteLater?: WriteLater<Uint8Array, number>;
+		fieldAnnotationsOffsetWriteLaters?: Array<WriteLater<Uint8Array, number> | null>;
+		methodAnnotationsOffsetWriteLaters?: Array<WriteLater<Uint8Array, number>>;
+		parameterAnnotationsOffsetWriteLaters?: Array<WriteLater<Uint8Array, number>>;
+	}): Unparser<DalvikExecutableClassAnnotations, Uint8Array> => {
+		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/src/dalvikExecutableUnparser/poolBuilders.ts

@@ -0,0 +1,189 @@
+import {
+	type DalvikExecutableField,
+	type DalvikExecutableMethod,
+	type DalvikExecutablePrototype,
+	dalvikExecutableFieldEquals,
+	dalvikExecutableMethodEquals,
+} from '../dalvikExecutable.js';
+
+export class StringPoolBuilder {
+	private strings: string[] = [];
+	private stringToIndex = new Map<string, number>();
+
+	add(str: string): number {
+		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: string): number | undefined {
+		return this.stringToIndex.get(str);
+	}
+
+	getStrings(): string[] {
+		return this.strings;
+	}
+
+	size(): number {
+		return this.strings.length;
+	}
+}
+
+export class TypePoolBuilder {
+	private types: string[] = [];
+	private typeToIndex = new Map<string, number>();
+
+	add(typeDescriptor: string): number {
+		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: string): number | undefined {
+		return this.typeToIndex.get(typeDescriptor);
+	}
+
+	getTypes(): string[] {
+		return this.types;
+	}
+
+	size(): number {
+		return this.types.length;
+	}
+}
+
+function prototypeKey(proto: DalvikExecutablePrototype): string {
+	return `${proto.shorty}:${proto.returnType}:(${proto.parameters.join(',')})`;
+}
+
+export class ProtoPoolBuilder {
+	private protos: DalvikExecutablePrototype[] = [];
+	private protoToIndex = new Map<string, number>();
+
+	add(proto: DalvikExecutablePrototype): number {
+		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: DalvikExecutablePrototype): number | undefined {
+		const key = prototypeKey(proto);
+		return this.protoToIndex.get(key);
+	}
+
+	getProtos(): DalvikExecutablePrototype[] {
+		return this.protos;
+	}
+
+	size(): number {
+		return this.protos.length;
+	}
+}
+
+function fieldKey(field: DalvikExecutableField): string {
+	return `${field.class}:${field.type}:${field.name}`;
+}
+
+export class FieldPoolBuilder {
+	private fields: DalvikExecutableField[] = [];
+	private fieldToIndex = new Map<string, number>();
+
+	add(field: DalvikExecutableField): number {
+		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: DalvikExecutableField): number | undefined {
+		const key = fieldKey(field);
+		return this.fieldToIndex.get(key);
+	}
+
+	getFields(): DalvikExecutableField[] {
+		return this.fields;
+	}
+
+	size(): number {
+		return this.fields.length;
+	}
+}
+
+function methodKey(method: DalvikExecutableMethod): string {
+	const protoKey = prototypeKey(method.prototype);
+	return `${method.class}:${protoKey}:${method.name}`;
+}
+
+export class MethodPoolBuilder {
+	private methods: DalvikExecutableMethod[] = [];
+	private methodToIndex = new Map<string, number>();
+
+	add(method: DalvikExecutableMethod): number {
+		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: DalvikExecutableMethod): number | undefined {
+		const key = methodKey(method);
+		return this.methodToIndex.get(key);
+	}
+
+	getMethods(): DalvikExecutableMethod[] {
+		return this.methods;
+	}
+
+	size(): number {
+		return this.methods.length;
+	}
+}
+
+export interface PoolBuilders {
+	stringPool: StringPoolBuilder;
+	typePool: TypePoolBuilder;
+	protoPool: ProtoPoolBuilder;
+	fieldPool: FieldPoolBuilder;
+	methodPool: MethodPoolBuilder;
+}
+
+export function createPoolBuilders(): PoolBuilders {
+	return {
+		stringPool: new StringPoolBuilder(),
+		typePool: new TypePoolBuilder(),
+		protoPool: new ProtoPoolBuilder(),
+		fieldPool: new FieldPoolBuilder(),
+		methodPool: new MethodPoolBuilder(),
+	};
+}

package/src/dalvikExecutableUnparser/poolScanners.ts

@@ -0,0 +1,297 @@
+import {
+	type DalvikExecutable,
+	type DalvikExecutableAnnotation,
+	type DalvikExecutableClassAnnotations,
+	type DalvikExecutableClassData,
+	type DalvikExecutableClassDefinition,
+	type DalvikExecutableCode,
+	type DalvikExecutableDebugInfo,
+	type DalvikExecutableEncodedValue,
+	type DalvikExecutableField,
+	type DalvikExecutableMethod,
+	type DalvikExecutableMethodWithAccess,
+	type DalvikExecutablePrototype,
+	isDalvikExecutableField,
+	isDalvikExecutableMethod,
+} from '../dalvikExecutable.js';
+import { type DalvikBytecode } from '../dalvikBytecodeParser.js';
+import { type PoolBuilders } from './poolBuilders.js';
+
+export function scanForPoolReferences(
+	dalvikExecutable: DalvikExecutable<DalvikBytecode>,
+	poolBuilders: PoolBuilders,
+): void {
+	const { stringPool, typePool, protoPool, fieldPool, methodPool } = poolBuilders;
+
+	for (const classDef of dalvikExecutable.classDefinitions) {
+		scanClassDefinition(classDef);
+	}
+
+	function addString(str: string | undefined): void {
+		if (str !== undefined) {
+			stringPool.add(str);
+		}
+	}
+
+	function addType(typeDescriptor: string | undefined): void {
+		if (typeDescriptor !== undefined) {
+			typePool.add(typeDescriptor);
+			stringPool.add(typeDescriptor);
+		}
+	}
+
+	function addPrototype(proto: DalvikExecutablePrototype): void {
+		protoPool.add(proto);
+
+		addString(proto.shorty);
+		addType(proto.returnType);
+
+		for (const param of proto.parameters) {
+			addType(param);
+		}
+	}
+
+	function addField(field: DalvikExecutableField): void {
+		fieldPool.add(field);
+
+		addType(field.class);
+		addType(field.type);
+		addString(field.name);
+	}
+
+	function addMethod(method: DalvikExecutableMethod): void {
+		methodPool.add(method);
+
+		addType(method.class);
+		addPrototype(method.prototype);
+		addString(method.name);
+	}
+
+	function scanEncodedValue(value: DalvikExecutableEncodedValue): void {
+		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: DalvikExecutableAnnotation): void {
+		addType(annotation.type);
+
+		for (const element of annotation.elements) {
+			addString(element.name);
+			scanEncodedValue(element.value);
+		}
+	}
+
+	function scanAnnotations(annotations: undefined | DalvikExecutableClassAnnotations): void {
+		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: undefined | DalvikExecutableDebugInfo): void {
+		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: undefined | DalvikExecutableCode<DalvikBytecode>): void {
+		if (!code) {
+			return;
+		}
+
+		scanDebugInfo(code.debugInfo);
+
+		for (const operation of code.instructions) {
+			if ('methodIndex' in operation) {
+				const methodIndex = operation.methodIndex as unknown;
+				if (isDalvikExecutableMethod(methodIndex)) {
+					addMethod(methodIndex);
+				}
+			}
+
+			if ('fieldIndex' in operation) {
+				const fieldIndex = operation.fieldIndex as unknown;
+				if (isDalvikExecutableField(fieldIndex)) {
+					addField(fieldIndex);
+				}
+			}
+
+			if ('typeIndex' in operation) {
+				const typeIndex = operation.typeIndex as unknown;
+				if (typeof typeIndex === 'string') {
+					addType(typeIndex);
+				}
+			}
+
+			if ('stringIndex' in operation) {
+				const stringIndex = operation.stringIndex as unknown;
+				if (typeof stringIndex === 'string') {
+					addString(stringIndex);
+				}
+			}
+
+			if ('protoIndex' in operation) {
+				const protoIndex = operation.protoIndex as unknown;
+				if (typeof protoIndex === 'object' && protoIndex !== null && 'returnType' in protoIndex) {
+					addPrototype(protoIndex as DalvikExecutablePrototype);
+				}
+			}
+		}
+
+		for (const tryBlock of code.tries) {
+			for (const handler of tryBlock.handler.handlers) {
+				addType(handler.type);
+			}
+		}
+	}
+
+	function scanMethod(method: DalvikExecutableMethodWithAccess<DalvikBytecode>): void {
+		addMethod(method.method);
+		scanCode(method.code);
+	}
+
+	function scanClassData(classData: undefined | DalvikExecutableClassData<DalvikBytecode>): void {
+		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: DalvikExecutableClassDefinition<DalvikBytecode>): void {
+		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);
+	}
+}