@futpib/parser 1.0.0 → 1.0.2

package/src/sequenceBuffer.test.ts

@@ -1,50 +1,120 @@
 import test from 'ava';
 import { SequenceBufferImplementation } from './sequenceBuffer.js';
-import { stringInputCompanion } from './inputCompanion.js';
+import { stringParserInputCompanion } from './parserInputCompanion.js';
 
 test('sequenceBuffer', t => {
-	const sequenceBuffer = new SequenceBufferImplementation(stringInputCompanion);
+	const sequenceBuffer = new SequenceBufferImplementation(stringParserInputCompanion);
 
+	t.is(sequenceBuffer.length, 0);
 	t.is(sequenceBuffer.peek(0), undefined);
 
+	t.deepEqual(sequenceBuffer.toSequenceBufferState(), {
+		consumedBufferedSequences: [],
+		unconsumedBufferedSequences: [],
+	});
+
 	sequenceBuffer.push('');
 
+	t.is(sequenceBuffer.length, 0);
 	t.is(sequenceBuffer.peek(0), undefined);
 
+	t.deepEqual(sequenceBuffer.toSequenceBufferState(), {
+		consumedBufferedSequences: [],
+		unconsumedBufferedSequences: [],
+	});
+
 	sequenceBuffer.push('abc');
 
+	t.is(sequenceBuffer.length, 3);
 	t.is(sequenceBuffer.peek(0), 'a');
 	t.is(sequenceBuffer.peek(1), 'b');
 	t.is(sequenceBuffer.peek(2), 'c');
 	t.is(sequenceBuffer.peek(3), undefined);
 
+	t.deepEqual(sequenceBuffer.toSequenceBufferState(), {
+		consumedBufferedSequences: [],
+		unconsumedBufferedSequences: ['abc'],
+	});
+
 	sequenceBuffer.push('def');
 
+	t.is(sequenceBuffer.length, 6);
 	t.is(sequenceBuffer.peek(0), 'a');
 	t.is(sequenceBuffer.peek(3), 'd');
 	t.is(sequenceBuffer.peek(6), undefined);
 
+	t.is(sequenceBuffer.peekSequence(1, 4), 'abcdef'.slice(1, 4), 'bcd');
+	t.is(sequenceBuffer.peekSequence(1, 5), 'abcdef'.slice(1, 5), 'bcde');
+	t.is(sequenceBuffer.peekSequence(1, 6), 'abcdef'.slice(1, 6), 'bcdef');
+	t.is(sequenceBuffer.peekSequence(1, 7), undefined, 'bcdef?');
+
+	t.deepEqual(sequenceBuffer.toSequenceBufferState(), {
+		consumedBufferedSequences: [],
+		unconsumedBufferedSequences: ['abc', 'def'],
+	});
+
 	sequenceBuffer.push('');
 
+	t.is(sequenceBuffer.length, 6);
 	t.is(sequenceBuffer.peek(0), 'a');
 	t.is(sequenceBuffer.peek(3), 'd');
 	t.is(sequenceBuffer.peek(6), undefined);
 
+	t.deepEqual(sequenceBuffer.toSequenceBufferState(), {
+		consumedBufferedSequences: [],
+		unconsumedBufferedSequences: ['abc', 'def', ''],
+	});
+
 	sequenceBuffer.skip(1);
 
+	t.is(sequenceBuffer.length, 5);
 	t.is(sequenceBuffer.peek(0), 'b');
 	t.is(sequenceBuffer.peek(3), 'e');
 	t.is(sequenceBuffer.peek(5), undefined);
 
+	t.deepEqual(sequenceBuffer.toSequenceBufferState(), {
+		consumedBufferedSequences: ['a'],
+		unconsumedBufferedSequences: ['bc', 'def', ''],
+	});
+
 	sequenceBuffer.skip(3);
 
+	t.is(sequenceBuffer.length, 2);
 	t.is(sequenceBuffer.peek(0), 'e');
 	t.is(sequenceBuffer.peek(2), undefined);
 
+	t.deepEqual(sequenceBuffer.toSequenceBufferState(), {
+		consumedBufferedSequences: ['d'],
+		unconsumedBufferedSequences: ['ef', ''],
+	});
+
 	sequenceBuffer.push('gh');
 
+	t.is(sequenceBuffer.length, 4);
 	t.is(sequenceBuffer.peek(0), 'e');
 	t.is(sequenceBuffer.peek(2), 'g');
 	t.is(sequenceBuffer.peek(3), 'h');
 	t.is(sequenceBuffer.peek(4), undefined);
+
+	t.is(sequenceBuffer.peekSequence(1, 3), 'efgh'.slice(1, 3), 'fg');
+	t.is(sequenceBuffer.peekSequence(1, 4), 'efgh'.slice(1, 4), 'fgh');
+	t.is(sequenceBuffer.peekSequence(1, 5), undefined, 'fgh?');
+
+	t.deepEqual(sequenceBuffer.toSequenceBufferState(), {
+		consumedBufferedSequences: ['d'],
+		unconsumedBufferedSequences: ['ef', '', 'gh'],
+	});
+});
+
+test('skip more then first sequence length', t => {
+	const sequenceBuffer = new SequenceBufferImplementation(stringParserInputCompanion);
+
+	sequenceBuffer.push('a');
+	sequenceBuffer.push('b');
+	sequenceBuffer.skip(2);
+
+	t.deepEqual(sequenceBuffer.toSequenceBufferState(), {
+		consumedBufferedSequences: [],
+		unconsumedBufferedSequences: [],
+	});
 });

package/src/sequenceBuffer.ts

@@ -1,24 +1,37 @@
 import invariant from 'invariant';
-import { type InputCompanion } from './inputCompanion.js';
+import { type ParserInputCompanion } from './parserInputCompanion.js';
+
+export type SequenceBufferState<Sequence> = {
+	consumedBufferedSequences: Sequence[];
+	unconsumedBufferedSequences: Sequence[];
+};
 
 export type SequenceBuffer<Sequence, Element> = {
 	push(sequence: Sequence): void;
 	peek(offset: number): Element | undefined;
+	peekSequence(start: number, end: number): Sequence | undefined;
 	skip(offset: number): void;
+
+	toSequenceBufferState(): SequenceBufferState<Sequence>;
 };
 
 export class SequenceBufferImplementation<Sequence, Element> implements SequenceBuffer<Sequence, Element> {
 	private readonly _sequences: Sequence[] = [];
 	private _indexInFirstSequence = 0;
 
-	constructor(private readonly _inputCompanion: InputCompanion<Sequence, Element>) {}
+	constructor(private readonly _parserInputCompanion: ParserInputCompanion<Sequence, Element>) {}
 
-	push(sequence: Sequence) {
-		this._sequences.push(sequence);
+	get length() {
+		return this._sequences.reduce(
+			(sequenceLength, sequence) => sequenceLength + this._parserInputCompanion.length(sequence),
+			0 - this._indexInFirstSequence,
+		);
+	}
 
+	private _shift() {
 		while (this._sequences.length > 0) {
 			const firstSequence = this._sequences[0];
-			const firstSequenceLength = this._inputCompanion.length(firstSequence);
+			const firstSequenceLength = this._parserInputCompanion.length(firstSequence);
 
 			if (firstSequenceLength === 0) {
 				this._sequences.shift();
@@ -34,16 +47,22 @@ export class SequenceBufferImplementation<Sequence, Element> implements Sequence
 		}
 	}
 
+	push(sequence: Sequence) {
+		this._sequences.push(sequence);
+
+		this._shift();
+	}
+
 	peek(offset: number): Element | undefined {
 		invariant(offset >= 0, 'Offset must be non-negative.');
 
 		let index = this._indexInFirstSequence + offset;
 
 		for (const sequence of this._sequences) {
-			const sequenceLength = this._inputCompanion.length(sequence);
+			const sequenceLength = this._parserInputCompanion.length(sequence);
 
 			if (index < sequenceLength) {
-				return this._inputCompanion.at(sequence, index);
+				return this._parserInputCompanion.at(sequence, index);
 			}
 
 			index -= sequenceLength;
@@ -52,7 +71,74 @@ export class SequenceBufferImplementation<Sequence, Element> implements Sequence
 		return undefined;
 	}
 
+	peekSequence(start: number, end: number): Sequence | undefined {
+		invariant(start >= 0, 'Start must be non-negative.');
+		invariant(end >= start, 'End must be greater than or equal to start.');
+
+		let startIndex = this._indexInFirstSequence + start;
+		let endIndex = this._indexInFirstSequence + end;
+
+		const sequences: Sequence[] = [];
+
+		for (const sequence of this._sequences) {
+			const sequenceLength = this._parserInputCompanion.length(sequence);
+
+			if (startIndex < sequenceLength) {
+				const subsequence = this._parserInputCompanion.subsequence(
+					sequence,
+					Math.max(0, startIndex),
+					Math.min(sequenceLength, endIndex),
+				)
+				sequences.push(subsequence);
+			}
+
+			startIndex -= sequenceLength;
+			endIndex -= sequenceLength;
+
+			if (endIndex <= 0) {
+				break;
+			}
+		}
+
+		return endIndex > 0 ? undefined : this._parserInputCompanion.concat(sequences);
+	}
+
 	skip(offset: number) {
 		this._indexInFirstSequence += offset;
+
+		this._shift();
+	}
+
+	toSequenceBufferState(): SequenceBufferState<Sequence> {
+		if (this._sequences.length === 0) {
+			return {
+				consumedBufferedSequences: [],
+				unconsumedBufferedSequences: [],
+			};
+		}
+
+		if (this._indexInFirstSequence === 0) {
+			return {
+				consumedBufferedSequences: [],
+				unconsumedBufferedSequences: this._sequences.slice(),
+			};
+		}
+
+		const firstSequence = this._sequences[0];
+		const firstSequenceLength = this._parserInputCompanion.length(firstSequence);
+
+		const consumedFirstSequence = this._parserInputCompanion.subsequence(firstSequence, 0, this._indexInFirstSequence);
+		const unconsumedFirstSequence = this._parserInputCompanion.subsequence(firstSequence, this._indexInFirstSequence, firstSequenceLength);
+
+		const unconsumedFirstSequenceLength = this._parserInputCompanion.length(unconsumedFirstSequence);
+
+		return {
+			consumedBufferedSequences: [consumedFirstSequence],
+			unconsumedBufferedSequences: (
+				unconsumedFirstSequenceLength === 0
+					? this._sequences.slice(1)
+					: [unconsumedFirstSequence, ...this._sequences.slice(1)]
+			),
+		};
 	}
 }

package/src/sequenceTerminatedSequenceParser.test.ts

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

package/src/sequenceTerminatedSequenceParser.ts

@@ -0,0 +1,62 @@
+import { inspect } from "./inspect.js";
+import { Parser, setParserName } from "./parser.js";
+import { DeriveSequenceElement } from "./sequence.js";
+
+function clamp(x: number, min: number, max: number) {
+	return Math.max(min, Math.min(x, max));
+}
+
+export const createSequenceTerminatedSequenceParser = <Sequence, Element = DeriveSequenceElement<Sequence>>(
+	terminatorSequence: Sequence,
+	{
+		consumeTerminator = true,
+	}: {
+		consumeTerminator?: boolean;
+	} = {},
+): Parser<Sequence, Sequence, Element> => {
+	const elementTerminatedSequenceParser: Parser<Sequence, Sequence, Element> = async parserContext => {
+		let window = 1;
+		let nonEndOfInputWindow = 0;
+
+		while (true) {
+			const sequence = await parserContext.peekSequence(0, window);
+
+			if (sequence === undefined) {
+				window = clamp(
+					Math.floor(window * 0.75),
+					nonEndOfInputWindow + 1,
+					window - 1,
+				);
+
+				parserContext.invariant(
+					window !== nonEndOfInputWindow,
+					'Unexpected end of input without terminated sequence',
+				);
+
+				continue;
+			}
+
+			nonEndOfInputWindow = Math.max(window, nonEndOfInputWindow);
+
+			const terminatorIndex = parserContext.indexOfSubsequence(sequence, terminatorSequence);
+
+			if (terminatorIndex === -1) {
+				window = window * 2;
+
+				continue;
+			}
+
+			const sequence_ = await parserContext.readSequence(0, terminatorIndex);
+
+			if (consumeTerminator) {
+				parserContext.skip(parserContext.length(terminatorSequence));
+			}
+
+			return sequence_;
+		}
+	};
+
+	setParserName(elementTerminatedSequenceParser, `.*?${inspect(terminatorSequence)}`);
+
+	return elementTerminatedSequenceParser;
+};

package/src/sequenceUnparser.ts

@@ -0,0 +1,9 @@
+import { Unparser } from "./unparser.js";
+
+export const createSequenceUnparser = <Sequence>(): Unparser<Sequence, Sequence> => {
+	const sequenceUnparser: Unparser<Sequence, Sequence> = async function * (input) {
+		yield input;
+	};
+
+	return sequenceUnparser;
+}

package/src/skipParser.ts

@@ -1,12 +1,14 @@
-import { type Parser } from './parser.js';
+import { setParserName, type Parser } from './parser.js';
 import { parserImplementationInvariant } from './parserImplementationInvariant.js';
 
-export const createSkipParser = <Sequence>(length: number): Parser<undefined, Sequence, unknown> => {
+export const createSkipParser = <Sequence>(length: number): Parser<void, Sequence, unknown> => {
 	parserImplementationInvariant(length > 0, 'Length must be positive.');
 
-	return async parserContext => {
+	const skipParser: Parser<void, Sequence, unknown> = parserContext => {
 		parserContext.skip(length);
-
-		return undefined;
 	};
+
+	setParserName(skipParser, `createSkipParser(${length})`);
+
+	return skipParser;
 };

package/src/skipToParser.ts

@@ -0,0 +1,16 @@
+import { Parser, setParserName } from "./parser.js";
+import { parserImplementationInvariant } from './parserImplementationInvariant.js';
+
+export const createSkipToParser = (offset: number): Parser<void, Uint8Array> => {
+	const skipToParser: Parser<void, Uint8Array> = (parserContext) => {
+		const length = offset - parserContext.position;
+
+		parserImplementationInvariant(length >= 0, 'Skip length must be positive, got %s (position: %s)', length, parserContext.position);
+
+		parserContext.skip(length);
+	};
+
+	setParserName(skipToParser, `createSkipToParser(${offset})`);
+
+	return skipToParser;
+};

package/src/sliceBoundedParser.test.ts

@@ -3,8 +3,19 @@ import { createArrayParser } from './arrayParser.js';
 import { createElementParser } from './elementParser.js';
 import { createTupleParser } from './tupleParser.js';
 import { createSliceBoundedParser } from './sliceBoundedParser.js';
-import { runParser } from './parser.js';
-import { stringInputCompanion } from './inputCompanion.js';
+import { runParser, runParserWithRemainingInput } from './parser.js';
+import { stringParserInputCompanion } from './parserInputCompanion.js';
+import { createExactElementParser } from './exactElementParser.js';
+
+async function stringFromAsyncIterable(asyncIterable: AsyncIterable<string>) {
+	let string = '';
+
+	for await (const chunk of asyncIterable) {
+		string += chunk;
+	}
+
+	return string;
+}
 
 const anythingParser = createArrayParser(createElementParser<string>());
 
@@ -15,7 +26,7 @@ test('sliceBoundedParser', async t => {
 		createElementParser(),
 	]);
 
-	const result = await runParser(parser, 'abba', stringInputCompanion);
+	const result = await runParser(parser, 'abba', stringParserInputCompanion);
 
 	t.deepEqual(result, [
 		'a',
@@ -26,3 +37,34 @@ test('sliceBoundedParser', async t => {
 		'a',
 	]);
 });
+
+test('sliceBoundedParser mustConsumeAll: true fail to cosume all', async t => {
+	const parser = createTupleParser([
+		createElementParser<string>(),
+		createSliceBoundedParser(createArrayParser(createExactElementParser('b' as string)), 2),
+		createElementParser(),
+	]);
+
+	await t.throwsAsync(() => runParser(parser, 'abcd', stringParserInputCompanion), {
+		message: /child parser must consume all input in the slice/,
+	});
+});
+
+test('sliceBoundedParser mustConsumeAll: false', async t => {
+	const parser = createTupleParser([
+		createElementParser<string>(),
+		createSliceBoundedParser(createArrayParser(createExactElementParser('b' as string)), 2, false),
+		createElementParser(),
+	]);
+
+	const { output, remainingInput } = await runParserWithRemainingInput(parser, 'abcd', stringParserInputCompanion);
+
+	t.deepEqual(output, [
+		'a',
+		[
+			'b',
+		],
+		'c',
+	]);
+	t.deepEqual(await stringFromAsyncIterable(remainingInput!), 'd');
+});

package/src/sliceBoundedParser.ts

@@ -1,16 +1,32 @@
-import { getParserName, Parser, setParserName } from "./parser.js";
+import { getParserName, type Parser, setParserName } from './parser.js';
 
 export const createSliceBoundedParser = <Output, Sequence>(
 	childParser: Parser<Output, Sequence>,
 	sliceEnd: number,
+	mustConsumeAll: boolean = true,
 ): Parser<Output, Sequence> => {
 	const sliceBoundedParser: typeof childParser = async parserContext => {
+		const absoluteSliceEnd = parserContext.position + sliceEnd;
+
 		const childParserContext = parserContext.lookahead({
-			sliceEnd: parserContext.position + sliceEnd,
+			sliceEnd: absoluteSliceEnd,
 		});
 
 		try {
 			const value = await childParser(childParserContext);
+
+			childParserContext.invariant(
+				(
+					!mustConsumeAll
+						|| childParserContext.position === absoluteSliceEnd
+				),
+				'child parser must consume all input in the slice (%s in total, up to position %s), instead consumed %s up to position %s',
+				sliceEnd,
+				absoluteSliceEnd,
+				childParserContext.position - parserContext.position,
+				childParserContext.position,
+			);
+
 			childParserContext.unlookahead();
 			return value;
 		} finally {
@@ -23,8 +39,10 @@ export const createSliceBoundedParser = <Output, Sequence>(
 		getParserName(childParser, 'anonymousSliceBoundedChild'),
 		',',
 		sliceEnd,
+		',',
+		mustConsumeAll,
 		')',
 	].join(''));
 
 	return sliceBoundedParser;
-}
+};

package/src/smali.ts

@@ -0,0 +1,24 @@
+import fs from 'node:fs/promises';
+import { execa } from 'execa';
+import { temporaryFile } from 'tempy';
+
+export async function smaliClass(smaliStream: AsyncIterable<string>) {
+	const inputFilePath = temporaryFile();
+	const outputFilePath = temporaryFile();
+
+	await fs.writeFile(inputFilePath, smaliStream);
+
+	await execa('smali', [
+		'assemble',
+		'--output', outputFilePath,
+		inputFilePath,
+	]);
+
+	await fs.unlink(inputFilePath);
+
+	const dex = await fs.readFile(outputFilePath);
+
+	await fs.unlink(outputFilePath);
+
+	return dex;
+}