@futpib/parser 1.0.1 → 1.0.2

package/build/dalvikBytecodeParser/formatParsers.d.ts

@@ -0,0 +1,97 @@
+import { Iso } from "monocle-ts";
+import { Parser } from "../parser.js";
+export declare const nibblesParser: Parser<[number, number], Uint8Array>;
+type DalvikBytecodeFormat10t = {
+    branchOffset: number;
+};
+export declare const dalvikBytecodeFormat10tParser: Parser<DalvikBytecodeFormat10t, Uint8Array>;
+type DalvikBytecodeFormat10x = void;
+export declare const dalvikBytecodeFormat10xParser: Parser<DalvikBytecodeFormat10x, Uint8Array>;
+type DalvikBytecodeFormat11x = {
+    registers: number[];
+};
+export declare const dalvikBytecodeFormat11xParser: Parser<DalvikBytecodeFormat11x, Uint8Array>;
+type DalvikBytecodeFormat12x = {
+    registers: number[];
+};
+export declare const dalvikBytecodeFormat12xParser: Parser<DalvikBytecodeFormat12x, Uint8Array>;
+type DalvikBytecodeFormat20t = {
+    branchOffset: number;
+};
+export declare const dalvikBytecodeFormat20tParser: Parser<DalvikBytecodeFormat20t, Uint8Array>;
+type DalvikBytecodeFormat21c<Index> = {
+    index: Index;
+    registers: number[];
+};
+export declare const createDalvikBytecodeFormat21cParser: <Index>({ isoIndex, }: {
+    isoIndex: Iso<Index, number>;
+}) => Parser<DalvikBytecodeFormat21c<Index>, Uint8Array>;
+type DalvikBytecodeFormat21h = {
+    value: number;
+    registers: number[];
+};
+export declare const dalvikBytecodeFormat21hParser: Parser<DalvikBytecodeFormat21h, Uint8Array>;
+type DalvikBytecodeFormat21t = {
+    branchOffset: number;
+    registers: number[];
+};
+export declare const createDalvikBytecodeFormat21tParser: () => Parser<DalvikBytecodeFormat21t, Uint8Array>;
+type DalvikBytecodeFormat21s = {
+    registers: number[];
+    value: number;
+};
+export declare const createDalvikBytecodeFormat21sParser: () => Parser<DalvikBytecodeFormat21s, Uint8Array>;
+type DalvikBytecodeFormat22b = {
+    registers: number[];
+    value: number;
+};
+export declare const createDalvikBytecodeFormat22bParser: () => Parser<DalvikBytecodeFormat22b, Uint8Array>;
+type DalvikBytecodeFormat22c<Index> = {
+    registers: number[];
+    index: Index;
+};
+export declare const createDalvikBytecodeFormat22cParser: <Index>({ isoIndex, }: {
+    isoIndex: Iso<Index, number>;
+}) => Parser<DalvikBytecodeFormat22c<Index>, Uint8Array>;
+type DalvikBytecodeFormat22s = {
+    value: number;
+    registers: number[];
+};
+export declare const createDalvikBytecodeFormat22sParser: () => Parser<DalvikBytecodeFormat22s, Uint8Array>;
+type DalvikBytecodeFormat22t = {
+    branchOffset: number;
+    registers: number[];
+};
+export declare const createDalvikBytecodeFormat22tParser: () => Parser<DalvikBytecodeFormat22t, Uint8Array>;
+type DalvikBytecodeFormat22x = {
+    registers: number[];
+};
+export declare const dalvikBytecodeFormat22xParser: Parser<DalvikBytecodeFormat22x, Uint8Array>;
+type DalvikBytecodeFormat23x = {
+    registers: number[];
+};
+export declare const dalvikBytecodeFormat23xParser: Parser<DalvikBytecodeFormat23x, Uint8Array>;
+type DalvikBytecodeFormat31i = {
+    value: number;
+    registers: number[];
+};
+export declare const dalvikBytecodeFormat31iParser: Parser<DalvikBytecodeFormat31i, Uint8Array>;
+type DalvikBytecodeFormat32x = {
+    registers: number[];
+};
+export declare const dalvikBytecodeFormat32xParser: Parser<DalvikBytecodeFormat32x, Uint8Array>;
+type DalvikBytecodeFormat35c<Index> = {
+    index: Index;
+    registers: number[];
+};
+export declare const createDalvikBytecodeFormat35cParser: <Index>({ isoIndex, }: {
+    isoIndex: Iso<Index, number>;
+}) => Parser<DalvikBytecodeFormat35c<Index>, Uint8Array>;
+type DalvikBytecodeFormat3rc<Index> = {
+    index: Index;
+    registers: number[];
+};
+export declare const createDalvikBytecodeFormat3rcParser: <Index>({ isoIndex, }: {
+    isoIndex: Iso<Index, number>;
+}) => Parser<DalvikBytecodeFormat3rc<Index>, Uint8Array>;
+export {};

package/build/dalvikBytecodeParser/formatParsers.js

@@ -0,0 +1,169 @@
+import { byteParser, intParser, shortParser, ubyteParser, ushortParser } from "../dalvikExecutableParser/typeParsers.js";
+import { createElementParser } from "../elementParser.js";
+import { 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 = promiseCompose(createElementParser(), (byte) => [
+    byte >> 4,
+    byte & 0b1111,
+]);
+setParserName(nibblesParser, 'nibblesParser');
+export const dalvikBytecodeFormat10tParser = promiseCompose(byteParser, (branchOffset) => ({
+    branchOffset,
+}));
+export const dalvikBytecodeFormat10xParser = promiseCompose(createElementParser(), () => undefined);
+export const dalvikBytecodeFormat11xParser = promiseCompose(ubyteParser, register0 => ({
+    registers: [
+        register0,
+    ],
+}));
+export const dalvikBytecodeFormat12xParser = promiseCompose(nibblesParser, ([register0, register1,]) => ({
+    registers: [
+        register0,
+        register1,
+    ],
+}));
+export const dalvikBytecodeFormat20tParser = promiseCompose(shortParser, (branchOffset) => ({
+    branchOffset,
+}));
+export const createDalvikBytecodeFormat21cParser = ({ isoIndex, }) => promiseCompose(createTupleParser([
+    ubyteParser,
+    ushortParser,
+]), ([register0, index,]) => ({
+    index: isoIndex.wrap(index),
+    registers: [
+        register0,
+    ],
+}));
+export const dalvikBytecodeFormat21hParser = promiseCompose(createTupleParser([
+    ubyteParser,
+    ushortParser,
+]), ([register0, value,]) => ({
+    value,
+    registers: [
+        register0,
+    ],
+}));
+export const createDalvikBytecodeFormat21tParser = () => promiseCompose(createTupleParser([
+    ubyteParser,
+    shortParser,
+]), ([register0, branchOffset,]) => ({
+    branchOffset,
+    registers: [
+        register0,
+    ],
+}));
+export const createDalvikBytecodeFormat21sParser = () => promiseCompose(createTupleParser([
+    ubyteParser,
+    shortParser,
+]), ([register0, value,]) => ({
+    value,
+    registers: [
+        register0,
+    ],
+}));
+export const createDalvikBytecodeFormat22bParser = () => promiseCompose(createTupleParser([
+    ubyteParser,
+    ubyteParser,
+    byteParser,
+]), ([register0, register1, value,]) => ({
+    value,
+    registers: [
+        register0,
+        register1,
+    ],
+}));
+export const createDalvikBytecodeFormat22cParser = ({ isoIndex, }) => promiseCompose(createTupleParser([
+    nibblesParser,
+    ushortParser,
+]), ([[register0, register1,], index,]) => ({
+    index: isoIndex.wrap(index),
+    registers: [
+        register0,
+        register1,
+    ],
+}));
+export const createDalvikBytecodeFormat22sParser = () => promiseCompose(createTupleParser([
+    nibblesParser,
+    shortParser,
+]), ([[register0, register1,], value,]) => ({
+    value,
+    registers: [
+        register0,
+        register1,
+    ],
+}));
+export const createDalvikBytecodeFormat22tParser = () => promiseCompose(createTupleParser([
+    nibblesParser,
+    shortParser,
+]), ([[register0, register1,], branchOffset,]) => ({
+    branchOffset,
+    registers: [
+        register0,
+        register1,
+    ],
+}));
+export const dalvikBytecodeFormat22xParser = promiseCompose(createTupleParser([
+    ubyteParser,
+    ushortParser,
+]), ([register0, register1,]) => ({
+    registers: [
+        register0,
+        register1,
+    ],
+}));
+export const dalvikBytecodeFormat23xParser = promiseCompose(createTupleParser([
+    ubyteParser,
+    ubyteParser,
+    ubyteParser,
+]), ([register0, register1, register2,]) => ({
+    registers: [
+        register0,
+        register1,
+        register2,
+    ],
+}));
+export const dalvikBytecodeFormat31iParser = promiseCompose(createTupleParser([
+    ubyteParser,
+    intParser,
+]), ([register0, value,]) => ({
+    value,
+    registers: [
+        register0,
+    ],
+}));
+export const dalvikBytecodeFormat32xParser = promiseCompose(createTupleParser([
+    ushortParser,
+    ushortParser,
+]), ([register0, register1,]) => ({
+    registers: [
+        register0,
+        register1,
+    ],
+}));
+export const createDalvikBytecodeFormat35cParser = ({ isoIndex, }) => promiseCompose(createTupleParser([
+    nibblesParser,
+    ushortParser,
+    nibblesParser,
+    nibblesParser,
+]), ([[registerCount, register4,], index, [register0, register1,], [register2, register3,],]) => ({
+    index: isoIndex.wrap(index),
+    registers: Object.assign([
+        register0,
+        register1,
+        register2,
+        register3,
+        register4,
+    ], {
+        length: registerCount,
+    }),
+}));
+export const createDalvikBytecodeFormat3rcParser = ({ isoIndex, }) => promiseCompose(createTupleParser([
+    ubyteParser,
+    ushortParser,
+    ushortParser,
+]), ([registerCount, index, firstRegister,]) => ({
+    index: isoIndex.wrap(index),
+    registers: Array.from({ length: registerCount }, (_, index) => firstRegister + index),
+}));

package/build/dalvikBytecodeParser.d.ts

@@ -0,0 +1,107 @@
+import { DalvikExecutableField, DalvikExecutableMethod } from "./dalvikExecutable.js";
+import { IndexIntoFieldIds, IndexIntoMethodIds, IndexIntoStringIds, IndexIntoTypeIds } from "./dalvikExecutableParser/typedNumbers.js";
+import { Parser } from "./parser.js";
+type DalvikBytecodeOperationNoOperation = {
+    operation: 'no-operation';
+};
+declare const dalvikBytecodeOperationInvokeVirtualParser: Parser<{
+    operation: "invoke-virtual";
+    methodIndex: IndexIntoMethodIds;
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationInvokeVirtual = Awaited<ReturnType<typeof dalvikBytecodeOperationInvokeVirtualParser>>;
+declare const dalvikBytecodeOperationInvokeSuperParser: Parser<{
+    operation: "invoke-super";
+    methodIndex: IndexIntoMethodIds;
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationInvokeSuper = Awaited<ReturnType<typeof dalvikBytecodeOperationInvokeSuperParser>>;
+declare const dalvikBytecodeOperationInvokeDirectParser: Parser<{
+    operation: "invoke-direct";
+    methodIndex: IndexIntoMethodIds;
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationInvokeDirect = Awaited<ReturnType<typeof dalvikBytecodeOperationInvokeDirectParser>>;
+declare const dalvikBytecodeOperationInvokeStaticParser: Parser<{
+    operation: "invoke-static";
+    methodIndex: IndexIntoMethodIds;
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationInvokeStatic = Awaited<ReturnType<typeof dalvikBytecodeOperationInvokeStaticParser>>;
+declare const dalvikBytecodeOperationInvokeInterfaceParser: Parser<{
+    operation: "invoke-interface";
+    methodIndex: IndexIntoMethodIds;
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationInvokeInterface = Awaited<ReturnType<typeof dalvikBytecodeOperationInvokeInterfaceParser>>;
+type DalvikBytecodeOperationInvoke = DalvikBytecodeOperationInvokeVirtual | DalvikBytecodeOperationInvokeSuper | DalvikBytecodeOperationInvokeDirect | DalvikBytecodeOperationInvokeStatic | DalvikBytecodeOperationInvokeInterface;
+type DalvikBytecodeOperationInstanceOf = {
+    operation: 'instance-of';
+    registers: number[];
+    typeIndex: IndexIntoTypeIds;
+};
+type DalvikBytecodeOperationNewInstance = {
+    operation: 'new-instance';
+    typeIndex: IndexIntoTypeIds;
+    registers: number[];
+};
+type DalvikBytecodeOperationCheckCast = {
+    operation: 'check-cast';
+    typeIndex: IndexIntoTypeIds;
+    registers: number[];
+};
+type DalvikBytecodeOperationReturnVoid = {
+    operation: 'return-void';
+};
+declare const dalvikBytecodeMoveResultParser: Parser<{
+    operation: "move-result";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationMoveResult = Awaited<ReturnType<typeof dalvikBytecodeMoveResultParser>>;
+declare const dalvikBytecodeMoveResultWideParser: Parser<{
+    operation: "move-result-wide";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationMoveResultWide = Awaited<ReturnType<typeof dalvikBytecodeMoveResultWideParser>>;
+declare const dalvikBytecodeMoveResultObjectParser: Parser<{
+    operation: "move-result-object";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationMoveResultObject = Awaited<ReturnType<typeof dalvikBytecodeMoveResultObjectParser>>;
+declare const dalvikBytecodeMoveExceptionParser: Parser<{
+    operation: "move-exception";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationMoveException = Awaited<ReturnType<typeof dalvikBytecodeMoveExceptionParser>>;
+type DalvikBytecodeOperationMoveResult1 = DalvikBytecodeOperationMoveResult | DalvikBytecodeOperationMoveResultWide | DalvikBytecodeOperationMoveResultObject | DalvikBytecodeOperationMoveException;
+export type DalvikBytecodeOperation = DalvikBytecodeOperationNoOperation | DalvikBytecodeOperationInvoke | DalvikBytecodeOperationNewInstance | DalvikBytecodeOperationCheckCast | DalvikBytecodeOperationInstanceOf | DalvikBytecodeOperationReturnVoid | DalvikBytecodeOperationMoveResult1;
+export declare const dalvikBytecodeOperationCompanion: {
+    getRegisters(operation: DalvikBytecodeOperation): number[];
+};
+export type DalvikBytecode = DalvikBytecodeOperation[];
+export declare const createDalvikBytecodeParser: (size: number) => Parser<DalvikBytecode, Uint8Array>;
+type ResolvedDalvikBytecodeOperation<T extends DalvikBytecodeOperation> = T extends {
+    stringIndex: IndexIntoFieldIds;
+} ? Omit<T, 'stringIndex'> & {
+    string: string;
+} : T extends {
+    typeIndex: IndexIntoTypeIds;
+} ? Omit<T, 'typeIndex'> & {
+    type: string;
+} : T extends {
+    methodIndex: IndexIntoMethodIds;
+} ? Omit<T, 'methodIndex'> & {
+    method: DalvikExecutableMethod;
+} : T extends {
+    fieldIndex: IndexIntoFieldIds;
+} ? Omit<T, 'fieldIndex'> & {
+    field: DalvikExecutableField;
+} : T;
+export type DalvikBytecodeOperationResolvers = {
+    resolveIndexIntoStringIds: (index: IndexIntoStringIds) => string;
+    resolveIndexIntoTypeIds: (index: IndexIntoTypeIds) => string;
+    resolveIndexIntoMethodIds: (index: IndexIntoMethodIds) => DalvikExecutableMethod;
+    resolveIndexIntoFieldIds: (index: IndexIntoFieldIds) => DalvikExecutableField;
+};
+export declare function resolveDalvikBytecodeOperation<T extends DalvikBytecodeOperation>(operation: T, { resolveIndexIntoStringIds, resolveIndexIntoTypeIds, resolveIndexIntoMethodIds, resolveIndexIntoFieldIds, }: DalvikBytecodeOperationResolvers): ResolvedDalvikBytecodeOperation<T>;
+export {};