@futpib/parser 1.0.2 → 1.0.3

package/src/dalvikBytecodeParser/formatParsers.ts

@@ -1,15 +1,17 @@
-import { Iso } from "monocle-ts";
-import { byteParser, intParser, shortParser, ubyteParser, ushortParser } from "../dalvikExecutableParser/typeParsers.js";
-import { createElementParser } from "../elementParser.js";
-import { Parser, setParserName } from "../parser.js";
-import { promiseCompose } from "../promiseCompose.js";
-import { createTupleParser } from "../tupleParser.js";
+import { type Iso } from 'monocle-ts';
+import {
+	byteParser, intParser, longParser, shortParser, ubyteParser, uintParser, ushortParser,
+} from '../dalvikExecutableParser/typeParsers.js';
+import { createElementParser } from '../elementParser.js';
+import { type Parser, setParserName } from '../parser.js';
+import { promiseCompose } from '../promiseCompose.js';
+import { createTupleParser } from '../tupleParser.js';
 
 // https://source.android.com/docs/core/runtime/instruction-formats
 
 export const nibblesParser: Parser<[ number, number ], Uint8Array> = promiseCompose(
 	createElementParser(),
-	(byte) => [
+	byte => [
 		byte >> 4,
 		byte & 0b1111,
 	],
@@ -23,7 +25,7 @@ type DalvikBytecodeFormat10t = {
 
 export const dalvikBytecodeFormat10tParser: Parser<DalvikBytecodeFormat10t, Uint8Array> = promiseCompose(
 	byteParser,
-	(branchOffset) => ({
+	branchOffset => ({
 		branchOffset,
 	}),
 );
@@ -48,6 +50,24 @@ export const dalvikBytecodeFormat11xParser: Parser<DalvikBytecodeFormat11x, Uint
 	}),
 );
 
+type DalvikBytecodeFormat11n = {
+	value: number;
+	registers: number[];
+};
+
+export const dalvikBytecodeFormat11nParser: Parser<DalvikBytecodeFormat11n, Uint8Array> = promiseCompose(
+	nibblesParser,
+	([
+		value,
+		register0,
+	]) => ({
+		value: value << 28 >> 28, // Sign extend 4-bit value
+		registers: [
+			register0,
+		],
+	}),
+);
+
 type DalvikBytecodeFormat12x = {
 	registers: number[];
 };
@@ -70,8 +90,14 @@ type DalvikBytecodeFormat20t = {
 };
 
 export const dalvikBytecodeFormat20tParser: Parser<DalvikBytecodeFormat20t, Uint8Array> = promiseCompose(
-	shortParser,
-	(branchOffset) => ({
+	createTupleParser([
+		ubyteParser,
+		shortParser,
+	]),
+	([
+		_zero,
+		branchOffset,
+	]) => ({
 		branchOffset,
 	}),
 );
@@ -122,7 +148,7 @@ export const dalvikBytecodeFormat21hParser: Parser<DalvikBytecodeFormat21h, Uint
 	}),
 );
 
-type DalvikBytecodeFormat21t= {
+type DalvikBytecodeFormat21t = {
 	branchOffset: number;
 	registers: number[];
 };
@@ -143,7 +169,7 @@ export const createDalvikBytecodeFormat21tParser = (): Parser<DalvikBytecodeForm
 	}),
 );
 
-type DalvikBytecodeFormat21s= {
+type DalvikBytecodeFormat21s = {
 	registers: number[];
 	value: number;
 };
@@ -204,8 +230,8 @@ export const createDalvikBytecodeFormat22cParser = <Index>({
 	]),
 	([
 		[
-			register0,
 			register1,
+			register0,
 		],
 		index,
 	]) => ({
@@ -236,8 +262,8 @@ export const createDalvikBytecodeFormat22sParser = (): Parser<DalvikBytecodeForm
 	]) => ({
 		value,
 		registers: [
-			register0,
 			register1,
+			register0,
 		],
 	}),
 );
@@ -289,7 +315,7 @@ export const dalvikBytecodeFormat22xParser: Parser<DalvikBytecodeFormat22x, Uint
 
 type DalvikBytecodeFormat23x = {
 	registers: number[];
-}
+};
 
 export const dalvikBytecodeFormat23xParser: Parser<DalvikBytecodeFormat23x, Uint8Array> = promiseCompose(
 	createTupleParser([
@@ -310,6 +336,17 @@ export const dalvikBytecodeFormat23xParser: Parser<DalvikBytecodeFormat23x, Uint
 	}),
 );
 
+type DalvikBytecodeFormat30t = {
+	branchOffset: number;
+};
+
+export const dalvikBytecodeFormat30tParser: Parser<DalvikBytecodeFormat30t, Uint8Array> = promiseCompose(
+	intParser,
+	branchOffset => ({
+		branchOffset,
+	}),
+);
+
 type DalvikBytecodeFormat31i = {
 	value: number;
 	registers: number[];
@@ -331,6 +368,52 @@ export const dalvikBytecodeFormat31iParser: Parser<DalvikBytecodeFormat31i, Uint
 	}),
 );
 
+type DalvikBytecodeFormat31c<Index> = {
+	index: Index;
+	registers: number[];
+};
+
+export const createDalvikBytecodeFormat31cParser = <Index>({
+	isoIndex,
+}: {
+	isoIndex: Iso<Index, number>;
+}): Parser<DalvikBytecodeFormat31c<Index>, Uint8Array> => promiseCompose(
+	createTupleParser([
+		ubyteParser,
+		uintParser,
+	]),
+	([
+		register0,
+		index,
+	]) => ({
+		index: isoIndex.wrap(index),
+		registers: [
+			register0,
+		],
+	}),
+);
+
+type DalvikBytecodeFormat31t = {
+	branchOffset: number;
+	registers: number[];
+};
+
+export const dalvikBytecodeFormat31tParser: Parser<DalvikBytecodeFormat31t, Uint8Array> = promiseCompose(
+	createTupleParser([
+		ubyteParser,
+		intParser,
+	]),
+	([
+		register0,
+		branchOffset,
+	]) => ({
+		branchOffset,
+		registers: [
+			register0,
+		],
+	}),
+);
+
 type DalvikBytecodeFormat32x = {
 	registers: number[];
 };
@@ -374,12 +457,12 @@ export const createDalvikBytecodeFormat35cParser = <Index>({
 		],
 		index,
 		[
-			register0,
 			register1,
+			register0,
 		],
 		[
-			register2,
 			register3,
+			register2,
 		],
 	]) => ({
 		index: isoIndex.wrap(index),
@@ -419,3 +502,279 @@ export const createDalvikBytecodeFormat3rcParser = <Index>({
 		registers: Array.from({ length: registerCount }, (_, index) => firstRegister + index),
 	}),
 );
+
+type DalvikBytecodeFormat51l = {
+	value: bigint;
+	registers: number[];
+};
+
+export const dalvikBytecodeFormat51lParser: Parser<DalvikBytecodeFormat51l, Uint8Array> = promiseCompose(
+	createTupleParser([
+		ubyteParser,
+		longParser,
+	]),
+	([
+		register0,
+		value,
+	]) => ({
+		value,
+		registers: [
+			register0,
+		],
+	}),
+);
+
+// Format 20bc: throw-verification-error
+type DalvikBytecodeFormat20bc = {
+	kind: number;
+	index: number;
+};
+
+export const dalvikBytecodeFormat20bcParser: Parser<DalvikBytecodeFormat20bc, Uint8Array> = promiseCompose(
+	createTupleParser([
+		ubyteParser,
+		ushortParser,
+	]),
+	([
+		kind,
+		index,
+	]) => ({
+		kind,
+		index,
+	}),
+);
+
+// Format 22cs: field access quick (deprecated)
+type DalvikBytecodeFormat22cs = {
+	registers: number[];
+	fieldOffset: number;
+};
+
+export const dalvikBytecodeFormat22csParser: Parser<DalvikBytecodeFormat22cs, Uint8Array> = promiseCompose(
+	createTupleParser([
+		nibblesParser,
+		ushortParser,
+	]),
+	([
+		[
+			register0,
+			register1,
+		],
+		fieldOffset,
+	]) => ({
+		fieldOffset,
+		registers: [
+			register0,
+			register1,
+		],
+	}),
+);
+
+// Format 35mi: invoke-*/inline (deprecated)
+type DalvikBytecodeFormat35mi = {
+	inlineIndex: number;
+	registers: number[];
+};
+
+export const dalvikBytecodeFormat35miParser: Parser<DalvikBytecodeFormat35mi, Uint8Array> = promiseCompose(
+	createTupleParser([
+		nibblesParser,
+		ushortParser,
+		nibblesParser,
+		nibblesParser,
+	]),
+	([
+		[
+			registerCount,
+			register4,
+		],
+		inlineIndex,
+		[
+			register1,
+			register0,
+		],
+		[
+			register3,
+			register2,
+		],
+	]) => ({
+		inlineIndex,
+		registers: Object.assign([
+			register0,
+			register1,
+			register2,
+			register3,
+			register4,
+		], {
+			length: registerCount,
+		}),
+	}),
+);
+
+// Format 35ms: invoke-*/quick (deprecated)
+type DalvikBytecodeFormat35ms = {
+	vtableOffset: number;
+	registers: number[];
+};
+
+export const dalvikBytecodeFormat35msParser: Parser<DalvikBytecodeFormat35ms, Uint8Array> = promiseCompose(
+	createTupleParser([
+		nibblesParser,
+		ushortParser,
+		nibblesParser,
+		nibblesParser,
+	]),
+	([
+		[
+			registerCount,
+			register4,
+		],
+		vtableOffset,
+		[
+			register1,
+			register0,
+		],
+		[
+			register3,
+			register2,
+		],
+	]) => ({
+		vtableOffset,
+		registers: Object.assign([
+			register0,
+			register1,
+			register2,
+			register3,
+			register4,
+		], {
+			length: registerCount,
+		}),
+	}),
+);
+
+// Format 3rmi: invoke-*/inline/range (deprecated)
+type DalvikBytecodeFormat3rmi = {
+	inlineIndex: number;
+	registers: number[];
+};
+
+export const dalvikBytecodeFormat3rmiParser: Parser<DalvikBytecodeFormat3rmi, Uint8Array> = promiseCompose(
+	createTupleParser([
+		ubyteParser,
+		ushortParser,
+		ushortParser,
+	]),
+	([
+		registerCount,
+		inlineIndex,
+		firstRegister,
+	]) => ({
+		inlineIndex,
+		registers: Array.from({ length: registerCount }, (_, index) => firstRegister + index),
+	}),
+);
+
+// Format 3rms: invoke-*/quick/range (deprecated)
+type DalvikBytecodeFormat3rms = {
+	vtableOffset: number;
+	registers: number[];
+};
+
+export const dalvikBytecodeFormat3rmsParser: Parser<DalvikBytecodeFormat3rms, Uint8Array> = promiseCompose(
+	createTupleParser([
+		ubyteParser,
+		ushortParser,
+		ushortParser,
+	]),
+	([
+		registerCount,
+		vtableOffset,
+		firstRegister,
+	]) => ({
+		vtableOffset,
+		registers: Array.from({ length: registerCount }, (_, index) => firstRegister + index),
+	}),
+);
+
+// Format 45cc: invoke-polymorphic
+type DalvikBytecodeFormat45cc<MethodIndex, ProtoIndex> = {
+	methodIndex: MethodIndex;
+	protoIndex: ProtoIndex;
+	registers: number[];
+};
+
+export const createDalvikBytecodeFormat45ccParser = <MethodIndex, ProtoIndex>({
+	isoMethodIndex,
+	isoProtoIndex,
+}: {
+	isoMethodIndex: Iso<MethodIndex, number>;
+	isoProtoIndex: Iso<ProtoIndex, number>;
+}): Parser<DalvikBytecodeFormat45cc<MethodIndex, ProtoIndex>, Uint8Array> => promiseCompose(
+	createTupleParser([
+		nibblesParser,
+		ushortParser,
+		nibblesParser,
+		nibblesParser,
+		ushortParser,
+	]),
+	([
+		[
+			registerCount,
+			register4,
+		],
+		methodIndex,
+		[
+			register1,
+			register0,
+		],
+		[
+			register3,
+			register2,
+		],
+		protoIndex,
+	]) => ({
+		methodIndex: isoMethodIndex.wrap(methodIndex),
+		protoIndex: isoProtoIndex.wrap(protoIndex),
+		registers: Object.assign([
+			register0,
+			register1,
+			register2,
+			register3,
+			register4,
+		], {
+			length: registerCount,
+		}),
+	}),
+);
+
+// Format 4rcc: invoke-polymorphic/range
+type DalvikBytecodeFormat4rcc<MethodIndex, ProtoIndex> = {
+	methodIndex: MethodIndex;
+	protoIndex: ProtoIndex;
+	registers: number[];
+};
+
+export const createDalvikBytecodeFormat4rccParser = <MethodIndex, ProtoIndex>({
+	isoMethodIndex,
+	isoProtoIndex,
+}: {
+	isoMethodIndex: Iso<MethodIndex, number>;
+	isoProtoIndex: Iso<ProtoIndex, number>;
+}): Parser<DalvikBytecodeFormat4rcc<MethodIndex, ProtoIndex>, Uint8Array> => promiseCompose(
+	createTupleParser([
+		ubyteParser,
+		ushortParser,
+		ushortParser,
+		ushortParser,
+	]),
+	([
+		registerCount,
+		methodIndex,
+		firstRegister,
+		protoIndex,
+	]) => ({
+		methodIndex: isoMethodIndex.wrap(methodIndex),
+		protoIndex: isoProtoIndex.wrap(protoIndex),
+		registers: Array.from({ length: registerCount }, (_, index) => firstRegister + index),
+	}),
+);

package/src/dalvikBytecodeParser/formatSizes.ts

@@ -0,0 +1,35 @@
+
+export const formatSizes = {
+	'10x': 1,
+	'11x': 1,
+	'11n': 1,
+	'12x': 1,
+	'10t': 1,
+	'20t': 2,
+	'20bc': 2,
+	'22x': 2,
+	'21t': 2,
+	'21s': 2,
+	'21h': 2,
+	'21c': 2,
+	'23x': 2,
+	'22b': 2,
+	'22t': 2,
+	'22s': 2,
+	'22c': 2,
+	'22cs': 2,
+	'30t': 3,
+	'32x': 3,
+	'31i': 3,
+	'31t': 3,
+	'31c': 3,
+	'35c': 3,
+	'35ms': 3,
+	'35mi': 3,
+	'3rc': 3,
+	'3rms': 3,
+	'3rmi': 3,
+	'45cc': 4,
+	'4rcc': 4,
+	'51l': 5,
+} as const;