@futpib/parser 1.0.0 → 1.0.2

package/src/dalvikExecutableParserAgainstSmaliParser.test.ts

@@ -0,0 +1,346 @@
+import test from 'ava';
+import { runParser } from './parser.js';
+import { stringParserInputCompanion, uint8ArrayParserInputCompanion } from './parserInputCompanion.js';
+import { dalvikExecutableParser } from './dalvikExecutableParser.js';
+import { fetchCid } from './fetchCid.js';
+import { hasExecutable } from './hasExecutable.js';
+import { baksmaliClass } from './backsmali.js';
+import { smaliParser } from './smaliParser.js';
+import { smaliClass } from './smali.js';
+
+const hasBaksmaliPromise = hasExecutable('baksmali');
+const hasSmaliPromise = hasExecutable('smali');
+
+type ObjectPath = (string | symbol | number)[];
+
+function objectWalk(object: unknown, f: (path: ObjectPath, value: unknown) => void, initialPath: ObjectPath = []) {
+	f(initialPath, object);
+
+	if (
+		!object
+			|| typeof object !== 'object'
+	) {
+		return;
+	}
+
+	if (Array.isArray(object)) {
+		for (const [ index, value ] of object.entries()) {
+			objectWalk(value, f, [ ...initialPath, index ]);
+		}
+	} else {
+		for (const [ key, value ] of Object.entries(object)) {
+			objectWalk(value, f, [ ...initialPath, key ]);
+		}
+	}
+}
+
+for (const [ dexCid, smaliFilePaths ] of [
+	[
+		'bafkreibb4gsprc3fvmnyqx6obswvm7e7wngnfj64gz65ey72r7xgyzymt4',
+		[
+			'pl/czak/minimal/MainActivity',
+		],
+	],
+	// [
+	// 	'bafybeiebe27ylo53trgitu6fqfbmba43c4ivxj3nt4kumsilkucpbdxtqq',
+	// 	[
+	// 		'd/m',
+	// 	],
+	// ],
+	// [ 'bafybeiebe27ylo53trgitu6fqfbmba43c4ivxj3nt4kumsilkucpbdxtqq' ],
+	// [
+	// 	'bafybeibbupm7uzhuq4pa674rb2amxsenbdaoijigmaf4onaodaql4mh7yy',
+	// 	[
+	// 		'com/journeyapps/barcodescanner/CaptureActivity',
+	// 	],
+	// ],
+	// [ 'bafybeicb3qajmwy6li7hche2nkucvytaxcyxhwhphmi73tgydjzmyoqoda' ],
+] as const) {
+	for (const smaliFilePath of smaliFilePaths) {
+		test.serial(
+			'parse(dex) against parse(smali(dex))' + dexCid + ' ' + smaliFilePath,
+			async t => {
+				const hasBaksmali = await hasBaksmaliPromise;
+
+				if (!hasBaksmali) {
+					t.pass('skipping test because baksmali is not available');
+
+					return;
+				}
+
+				const dexStream = await fetchCid(dexCid);
+
+				const smali = await baksmaliClass(dexStream, smaliFilePath);
+
+				const classDefinitionFromSmali = await runParser(smaliParser, smali, stringParserInputCompanion, {
+					errorJoinMode: 'all',
+				});
+
+				const dexStream2 = await fetchCid(dexCid);
+
+				const executableFromDex = await runParser(dalvikExecutableParser, dexStream2, uint8ArrayParserInputCompanion, {
+					errorJoinMode: 'all',
+				});
+
+				const classDefinitionFromDex = executableFromDex.classDefinitions.find(classDefinition => classDefinition.class === classDefinitionFromSmali.class);
+
+				// console.log(smali);
+
+				// console.dir({
+				// 	classDefinitionFromDex,
+				// 	classDefinitionFromSmali,
+				// }, {
+				// 	depth: null,
+				// });
+
+				objectWalk(classDefinitionFromDex, (_path, value) => {
+					if (
+						value
+							&& typeof value === 'object'
+							&& 'debugInfo' in value
+					) {
+						value.debugInfo = undefined;
+					}
+				});
+
+				t.deepEqual(
+					classDefinitionFromDex,
+					classDefinitionFromSmali,
+				);
+			},
+		);
+	}
+}
+
+const smali = `
+.class public Lcom/journeyapps/barcodescanner/CaptureActivity;
+.super Landroid/app/Activity;
+.source "CaptureActivity.java"
+
+
+# instance fields
+.field private barcodeScannerView:Lcom/journeyapps/barcodescanner/DecoratedBarcodeView;
+
+.field private capture:Lcom/journeyapps/barcodescanner/CaptureManager;
+
+
+# direct methods
+.method public constructor <init>()V
+    .registers 1
+
+    .line 13
+    invoke-direct {p0}, Landroid/app/Activity;-><init>()V
+
+    return-void
+.end method
+
+
+# virtual methods
+.method protected initializeContent()Lcom/journeyapps/barcodescanner/DecoratedBarcodeView;
+    .registers 2
+
+    sget v0, Lcom/google/zxing/client/android/R$layout;->zxing_capture:I
+
+    .line 34
+    invoke-virtual {p0, v0}, Landroid/app/Activity;->setContentView(I)V
+
+    sget v0, Lcom/google/zxing/client/android/R$id;->zxing_barcode_scanner:I
+
+    .line 35
+    invoke-virtual {p0, v0}, Landroid/app/Activity;->findViewById(I)Landroid/view/View;
+
+    move-result-object v0
+
+    check-cast v0, Lcom/journeyapps/barcodescanner/DecoratedBarcodeView;
+
+    return-object v0
+.end method
+
+.method protected onCreate(Landroid/os/Bundle;)V
+    .registers 4
+
+    .line 19
+    invoke-super {p0, p1}, Landroid/app/Activity;->onCreate(Landroid/os/Bundle;)V
+
+    .line 21
+    invoke-virtual {p0}, Lcom/journeyapps/barcodescanner/CaptureActivity;->initializeContent()Lcom/journeyapps/barcodescanner/DecoratedBarcodeView;
+
+    move-result-object v0
+
+    iput-object v0, p0, Lcom/journeyapps/barcodescanner/CaptureActivity;->barcodeScannerView:Lcom/journeyapps/barcodescanner/DecoratedBarcodeView;
+
+    .line 23
+    new-instance v0, Lcom/journeyapps/barcodescanner/CaptureManager;
+
+    iget-object v1, p0, Lcom/journeyapps/barcodescanner/CaptureActivity;->barcodeScannerView:Lcom/journeyapps/barcodescanner/DecoratedBarcodeView;
+
+    invoke-direct {v0, p0, v1}, Lcom/journeyapps/barcodescanner/CaptureManager;-><init>(Landroid/app/Activity;Lcom/journeyapps/barcodescanner/DecoratedBarcodeView;)V
+
+    iput-object v0, p0, Lcom/journeyapps/barcodescanner/CaptureActivity;->capture:Lcom/journeyapps/barcodescanner/CaptureManager;
+
+    .line 24
+    invoke-virtual {p0}, Landroid/app/Activity;->getIntent()Landroid/content/Intent;
+
+    move-result-object v1
+
+    invoke-virtual {v0, v1, p1}, Lcom/journeyapps/barcodescanner/CaptureManager;->initializeFromIntent(Landroid/content/Intent;Landroid/os/Bundle;)V
+
+    iget-object p1, p0, Lcom/journeyapps/barcodescanner/CaptureActivity;->capture:Lcom/journeyapps/barcodescanner/CaptureManager;
+
+    .line 25
+    invoke-virtual {p1}, Lcom/journeyapps/barcodescanner/CaptureManager;->decode()V
+
+    return-void
+.end method
+
+.method protected onDestroy()V
+    .registers 2
+
+    .line 52
+    invoke-super {p0}, Landroid/app/Activity;->onDestroy()V
+
+    iget-object v0, p0, Lcom/journeyapps/barcodescanner/CaptureActivity;->capture:Lcom/journeyapps/barcodescanner/CaptureManager;
+
+    .line 53
+    invoke-virtual {v0}, Lcom/journeyapps/barcodescanner/CaptureManager;->onDestroy()V
+
+    return-void
+.end method
+
+.method public onKeyDown(ILandroid/view/KeyEvent;)Z
+    .registers 4
+
+    iget-object v0, p0, Lcom/journeyapps/barcodescanner/CaptureActivity;->barcodeScannerView:Lcom/journeyapps/barcodescanner/DecoratedBarcodeView;
+
+    .line 69
+    invoke-virtual {v0, p1, p2}, Lcom/journeyapps/barcodescanner/DecoratedBarcodeView;->onKeyDown(ILandroid/view/KeyEvent;)Z
+
+    move-result v0
+
+    if-nez v0, :cond_11
+
+    invoke-super {p0, p1, p2}, Landroid/app/Activity;->onKeyDown(ILandroid/view/KeyEvent;)Z
+
+    move-result p1
+
+    if-eqz p1, :cond_f
+
+    goto :goto_11
+
+    :cond_f
+    const/4 p1, 0x0
+
+    goto :goto_12
+
+    :cond_11
+    :goto_11
+    const/4 p1, 0x1
+
+    :goto_12
+    return p1
+.end method
+
+.method protected onPause()V
+    .registers 2
+
+    .line 46
+    invoke-super {p0}, Landroid/app/Activity;->onPause()V
+
+    iget-object v0, p0, Lcom/journeyapps/barcodescanner/CaptureActivity;->capture:Lcom/journeyapps/barcodescanner/CaptureManager;
+
+    .line 47
+    invoke-virtual {v0}, Lcom/journeyapps/barcodescanner/CaptureManager;->onPause()V
+
+    return-void
+.end method
+
+.method public onRequestPermissionsResult(I[Ljava/lang/String;[I)V
+    .registers 5
+
+    iget-object v0, p0, Lcom/journeyapps/barcodescanner/CaptureActivity;->capture:Lcom/journeyapps/barcodescanner/CaptureManager;
+
+    .line 64
+    invoke-virtual {v0, p1, p2, p3}, Lcom/journeyapps/barcodescanner/CaptureManager;->onRequestPermissionsResult(I[Ljava/lang/String;[I)V
+
+    return-void
+.end method
+
+.method protected onResume()V
+    .registers 2
+
+    .line 40
+    invoke-super {p0}, Landroid/app/Activity;->onResume()V
+
+    iget-object v0, p0, Lcom/journeyapps/barcodescanner/CaptureActivity;->capture:Lcom/journeyapps/barcodescanner/CaptureManager;
+
+    .line 41
+    invoke-virtual {v0}, Lcom/journeyapps/barcodescanner/CaptureManager;->onResume()V
+
+    return-void
+.end method
+
+.method protected onSaveInstanceState(Landroid/os/Bundle;)V
+    .registers 3
+
+    .line 58
+    invoke-super {p0, p1}, Landroid/app/Activity;->onSaveInstanceState(Landroid/os/Bundle;)V
+
+    iget-object v0, p0, Lcom/journeyapps/barcodescanner/CaptureActivity;->capture:Lcom/journeyapps/barcodescanner/CaptureManager;
+
+    .line 59
+    invoke-virtual {v0, p1}, Lcom/journeyapps/barcodescanner/CaptureManager;->onSaveInstanceState(Landroid/os/Bundle;)V
+
+    return-void
+.end method
+`;
+
+test.serial.skip(
+	'parse(dex(smali)) againts parse(smali)',
+	async t => {
+		const hasSmali = await hasSmaliPromise;
+
+		if (!hasSmali) {
+			t.pass('skipping test because smali is not available');
+
+			return;
+		}
+
+		const dexBuffer = await smaliClass(async function* () {
+			yield smali;
+		}());
+
+		const classDefinitionFromSmali = await runParser(smaliParser, smali, stringParserInputCompanion, {
+			errorJoinMode: 'all',
+		});
+
+		const executableFromDex = await runParser(dalvikExecutableParser, dexBuffer, uint8ArrayParserInputCompanion, {
+			errorJoinMode: 'all',
+		});
+
+		const classDefinitionFromDex = executableFromDex.classDefinitions.find(classDefinition => classDefinition.class === classDefinitionFromSmali.class);
+
+		// console.log(smali);
+
+		console.dir({
+			classDefinitionFromDex,
+			classDefinitionFromSmali,
+		}, {
+			depth: null,
+		});
+
+		objectWalk(classDefinitionFromDex, (_path, value) => {
+			if (
+				value
+					&& typeof value === 'object'
+					&& 'debugInfo' in value
+			) {
+				value.debugInfo = undefined;
+			}
+		});
+
+		t.deepEqual(
+			classDefinitionFromDex,
+			classDefinitionFromSmali,
+		);
+	},
+);

package/src/debugLogInputParser.ts

@@ -0,0 +1,28 @@
+import { type Parser } from './parser.js';
+
+export const createDebugLogInputParser = <Sequence>({
+	maxLookahead = 8,
+}: {
+	maxLookahead?: number;
+} = {}): Parser<void, Sequence> => async parserContext => {
+	let lookahead = maxLookahead;
+
+	while (lookahead > 0) {
+		const sequence = await parserContext.peekSequence(0, lookahead);
+
+		if (!sequence) {
+			lookahead = lookahead - 1;
+			continue;
+		}
+
+		let prettySequence: unknown = sequence;
+
+		if (prettySequence instanceof Uint8Array) {
+			prettySequence = Buffer.from(prettySequence).toString('hex');
+		}
+
+		console.log('debugLogInput (position: %s): %s', parserContext.position, prettySequence);
+
+		break;
+	}
+};

package/src/debugLogParser.ts

@@ -1,17 +1,33 @@
-import { getParserName, Parser, setParserName } from "./parser.js";
+import { getParserName, type Parser, setParserName } from './parser.js';
 
 export const createDebugLogParser = <Output, Sequence>(
 	childParser: Parser<Output, Sequence>,
 ): Parser<Output, Sequence> => {
 	let idCounter = 0;
 
+	function getLogParserName() {
+		const childParserName = getParserName(childParser);
+
+		if (childParserName !== 'anonymous') {
+			return childParserName;
+		}
+
+		const debugLogParserName = getParserName(debugLogParser);
+
+		if (!debugLogParserName.startsWith('debugLog(')) {
+			return debugLogParserName;
+		}
+
+		return 'anonymousDebugLogChild';
+	}
+
 	const debugLogParser: typeof childParser = async parserContext => {
 		const id = idCounter++;
 		const initialPosition = parserContext.position;
 
 		console.debug(
 			'%s %s: started (position: %s)',
-			getParserName(childParser),
+			getLogParserName(),
 			id,
 			initialPosition,
 		);
@@ -21,7 +37,7 @@ export const createDebugLogParser = <Output, Sequence>(
 
 			console.debug(
 				'%s %s: finished (position: %s, consumed: %s): %o',
-				getParserName(childParser),
+				getLogParserName(),
 				id,
 				parserContext.position,
 				parserContext.position - initialPosition,
@@ -32,7 +48,7 @@ export const createDebugLogParser = <Output, Sequence>(
 		} catch (error) {
 			console.debug(
 				'%s %s: failed (position: %s, consumed: %s): %o',
-				getParserName(childParser),
+				getLogParserName(),
 				id,
 				parserContext.position,
 				parserContext.position - initialPosition,

package/src/disjunctionParser.ts

@@ -1,16 +1,19 @@
 import { getParserName, setParserName, type Parser } from './parser.js';
 import { ParserParsingFailedError } from './parserError.js';
 import { parserImplementationInvariant } from './parserImplementationInvariant.js';
+import { promiseSettled } from './promiseSettled.js';
+import { DeriveSequenceElement } from './sequence.js';
 
 export const createDisjunctionParser = <
 	Output,
 	Sequence,
+	Element = DeriveSequenceElement<Sequence>,
 >(
-	childParsers: Array<Parser<any, Sequence, any>>,
-): Parser<Output, Sequence, unknown> => {
+	childParsers: Array<Parser<any, Sequence, Element>>,
+): Parser<Output, Sequence, Element> => {
 	parserImplementationInvariant(childParsers.length > 0, 'Disjunction parser must have at least one child parser.');
 
-	const disjunctionParser: Parser<Output, Sequence, unknown> = async parserContext => {
+	const disjunctionParser: Parser<Output, Sequence, Element> = async parserContext => {
 		const parserParsingFailedErrors: ParserParsingFailedError[] = [];
 
 		for (const childParser of childParsers) {
@@ -18,7 +21,7 @@ export const createDisjunctionParser = <
 				debugName: getParserName(childParser, 'anonymousDisjunctionChild'),
 			});
 
-			const [ childParserResult ] = await Promise.allSettled([ childParser(childParserContext) ]);
+			const childParserResult = await promiseSettled<Output>(childParser(childParserContext));
 
 			if (childParserResult.status === 'fulfilled') {
 				const successfulParserOutput = childParserResult.value;
@@ -29,6 +32,8 @@ export const createDisjunctionParser = <
 				return successfulParserOutput;
 			}
 
+			childParserContext.dispose();
+
 			const error = childParserResult.reason;
 
 			if (error instanceof ParserParsingFailedError) {
@@ -38,7 +43,7 @@ export const createDisjunctionParser = <
 			}
 		}
 
-		parserContext.invariantJoin(
+		return parserContext.invariantJoin(
 			false,
 			parserParsingFailedErrors,
 			'No disjunction child parser succeeded.',

package/src/elementParser.ts

@@ -1,4 +1,4 @@
-import { Parser } from "./parser.js";
-import { DeriveSequenceElement } from "./sequence.js";
+import { type Parser } from './parser.js';
+import { type DeriveSequenceElement } from './sequence.js';
 
-export const createElementParser = <Sequence, Element = DeriveSequenceElement<Sequence>>(): Parser<Element, Sequence, Element> => parserContext => parserContext.read(0);
+export const createElementParser = <Sequence, Element = DeriveSequenceElement<Sequence>>(): Parser<Element, Sequence, Element> => async parserContext => parserContext.read(0);

package/src/elementTerminatedArrayParser.test.ts

@@ -0,0 +1,99 @@
+import test from 'ava';
+import * as fc from 'fast-check';
+import { testProp } from '@fast-check/ava';
+import { createTerminatedArrayParserNaive } from './terminatedArrayParser.js';
+import { Parser, runParser } from './parser.js';
+import { stringParserInputCompanion } from './parserInputCompanion.js';
+import { HighResolutionTotalTimer } from './highResolutionTimer.js';
+import { createElementParser } from './elementParser.js';
+import { createExactSequenceParser } from './exactSequenceParser.js';
+import { createTupleParser } from './tupleParser.js';
+import { createNegativeLookaheadParser } from './negativeLookaheadParser.js';
+import { promiseCompose } from './promiseCompose.js';
+import { createElementTerminatedArrayParserUnsafe } from './elementTerminatedArrayParser.js';
+
+const naiveTotalTimer = new HighResolutionTotalTimer();
+const elementTotalTimer = new HighResolutionTotalTimer();
+
+testProp.serial(
+	'elementTerminatedArrayParserUnsafe',
+	[
+		fc
+			.string({
+				minLength: 1,
+			})
+			.map(string => ({
+				string,
+				terminator: string.slice(-1)
+			}))
+			.filter(({ string, terminator }) => string.split(terminator).length === 2)
+	],
+	async (t, { string, terminator }) => {
+		const terminatedArrayParserNaive = promiseCompose(
+			createTerminatedArrayParserNaive(
+				promiseCompose(
+					createTupleParser([
+						createNegativeLookaheadParser(createExactSequenceParser(terminator)),
+						createElementParser<string>(),
+					]),
+					([ _, element ]) => element,
+				),
+				createExactSequenceParser(terminator),
+			),
+			([ characters ]) => characters,
+		);
+
+		const elementTerminatedArrayParserUnsafe = createElementTerminatedArrayParserUnsafe(
+			promiseCompose(
+				createTupleParser([
+					createNegativeLookaheadParser(createExactSequenceParser(terminator)),
+					createElementParser<string>(),
+				]),
+				([ _, element ]) => element,
+			),
+			terminator,
+		);
+
+		const createTestWrapperParser = (innerParser: typeof elementTerminatedArrayParserUnsafe): Parser<{
+			string: string;
+			position: number;
+		}, string> => async parserContext => {
+			const characters = await innerParser(parserContext);
+
+			return {
+				string: characters.join(''),
+				nextPeek: await parserContext.peek(0),
+				position: parserContext.position,
+			};
+		};
+
+		const actualNaive = await naiveTotalTimer.measureAsync(() => runParser(
+			createTestWrapperParser(terminatedArrayParserNaive),
+			string,
+			stringParserInputCompanion,
+		));
+
+		t.is(actualNaive.string.length, string.split(terminator)[0].length)
+
+		const actual = await elementTotalTimer.measureAsync(() => runParser(
+			createTestWrapperParser(elementTerminatedArrayParserUnsafe),
+			string,
+			stringParserInputCompanion,
+		));
+
+		t.deepEqual(actual, actualNaive);
+	},
+	{
+		verbose: true,
+	},
+);
+
+test.serial(
+	'elementTerminatedArrayParserUnsafe performance',
+	t => {
+		t.true(
+			elementTotalTimer.time * 4n < naiveTotalTimer.time,
+			`Naive: ${naiveTotalTimer.time / 1000000n}ms, Unsafe: ${elementTotalTimer.time / 1000000n}ms`,
+		);
+	},
+);

package/src/elementTerminatedArrayParser.ts

@@ -0,0 +1,31 @@
+import { getParserName, Parser, setParserName } from "./parser.js";
+import { DeriveSequenceElement } from "./sequence.js";
+
+export const createElementTerminatedArrayParserUnsafe = <ElementOutput, Sequence, Element = DeriveSequenceElement<Sequence>>(
+	elementParser: Parser<ElementOutput, Sequence>,
+	terminatorElement: Element,
+): Parser<ElementOutput[], Sequence> => {
+	const elementTerminatedArrayParserUnsafe: Parser<ElementOutput[], Sequence> = async parserContext => {
+		const elements: ElementOutput[] = [];
+
+		while (true) {
+			const inputElement = await parserContext.peek(0);
+
+			if (inputElement === terminatorElement) {
+				parserContext.skip(1);
+
+				break;
+			}
+
+			const element = await elementParser(parserContext);
+
+			elements.push(element);
+		}
+
+		return elements;
+	};
+
+	setParserName(elementTerminatedArrayParserUnsafe, `${getParserName(elementParser, 'anonymousElement')}*?${JSON.stringify(terminatorElement)}`);
+
+	return elementTerminatedArrayParserUnsafe;
+};

package/src/elementTerminatedSequenceArrayParser.test.ts

@@ -0,0 +1,54 @@
+import * as fc from 'fast-check';
+import { testProp } from '@fast-check/ava';
+import { Parser, runParser } from './parser.js';
+import { stringParserInputCompanion } from './parserInputCompanion.js';
+import { createElementTerminatedSequenceArrayParser } from './elementTerminatedSequenceArrayParser.js';
+
+testProp.serial(
+	'elementTerminatedSequenceArrayParser',
+	[
+		fc
+			.string({
+				minLength: 1,
+			})
+			.map(string => ({
+				string,
+				terminator: string.slice(-1)
+			}))
+			.filter(({ string, terminator }) => string.split(terminator).length === 2)
+	],
+	async (t, { string, terminator }) => {
+		const elementTerminatedSequenceArrayParser = createElementTerminatedSequenceArrayParser<string>(
+			terminator,
+		);
+
+		const createTestWrapperParser = (innerParser: typeof elementTerminatedSequenceArrayParser): Parser<{
+			strings: string[];
+			nextPeek: string | undefined;
+			position: number;
+		}, string> => async parserContext => {
+			const strings = await innerParser(parserContext);
+
+			return {
+				strings,
+				nextPeek: await parserContext.peek(0),
+				position: parserContext.position,
+			};
+		};
+
+		const actual = await runParser(
+			createTestWrapperParser(elementTerminatedSequenceArrayParser),
+			string,
+			stringParserInputCompanion,
+		);
+
+		t.deepEqual(actual, {
+			strings: [ string.split(terminator)[0] ],
+			nextPeek: undefined,
+			position: string.length,
+		});
+	},
+	{
+		verbose: true,
+	},
+);