@futpib/parser 1.0.1 → 1.0.3

package/build/dalvikBytecodeParser/formatParsers.js

@@ -0,0 +1,304 @@
+import { byteParser, intParser, longParser, shortParser, ubyteParser, uintParser, 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 dalvikBytecodeFormat11nParser = promiseCompose(nibblesParser, ([value, register0,]) => ({
+    value: value << 28 >> 28, // Sign extend 4-bit value
+    registers: [
+        register0,
+    ],
+}));
+export const dalvikBytecodeFormat12xParser = promiseCompose(nibblesParser, ([register0, register1,]) => ({
+    registers: [
+        register0,
+        register1,
+    ],
+}));
+export const dalvikBytecodeFormat20tParser = promiseCompose(createTupleParser([
+    ubyteParser,
+    shortParser,
+]), ([_zero, 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,
+]), ([[register1, register0,], index,]) => ({
+    index: isoIndex.wrap(index),
+    registers: [
+        register0,
+        register1,
+    ],
+}));
+export const createDalvikBytecodeFormat22sParser = () => promiseCompose(createTupleParser([
+    nibblesParser,
+    shortParser,
+]), ([[register0, register1,], value,]) => ({
+    value,
+    registers: [
+        register1,
+        register0,
+    ],
+}));
+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 dalvikBytecodeFormat30tParser = promiseCompose(intParser, branchOffset => ({
+    branchOffset,
+}));
+export const dalvikBytecodeFormat31iParser = promiseCompose(createTupleParser([
+    ubyteParser,
+    intParser,
+]), ([register0, value,]) => ({
+    value,
+    registers: [
+        register0,
+    ],
+}));
+export const createDalvikBytecodeFormat31cParser = ({ isoIndex, }) => promiseCompose(createTupleParser([
+    ubyteParser,
+    uintParser,
+]), ([register0, index,]) => ({
+    index: isoIndex.wrap(index),
+    registers: [
+        register0,
+    ],
+}));
+export const dalvikBytecodeFormat31tParser = promiseCompose(createTupleParser([
+    ubyteParser,
+    intParser,
+]), ([register0, branchOffset,]) => ({
+    branchOffset,
+    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, [register1, register0,], [register3, register2,],]) => ({
+    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),
+}));
+export const dalvikBytecodeFormat51lParser = promiseCompose(createTupleParser([
+    ubyteParser,
+    longParser,
+]), ([register0, value,]) => ({
+    value,
+    registers: [
+        register0,
+    ],
+}));
+export const dalvikBytecodeFormat20bcParser = promiseCompose(createTupleParser([
+    ubyteParser,
+    ushortParser,
+]), ([kind, index,]) => ({
+    kind,
+    index,
+}));
+export const dalvikBytecodeFormat22csParser = promiseCompose(createTupleParser([
+    nibblesParser,
+    ushortParser,
+]), ([[register0, register1,], fieldOffset,]) => ({
+    fieldOffset,
+    registers: [
+        register0,
+        register1,
+    ],
+}));
+export const dalvikBytecodeFormat35miParser = promiseCompose(createTupleParser([
+    nibblesParser,
+    ushortParser,
+    nibblesParser,
+    nibblesParser,
+]), ([[registerCount, register4,], inlineIndex, [register1, register0,], [register3, register2,],]) => ({
+    inlineIndex,
+    registers: Object.assign([
+        register0,
+        register1,
+        register2,
+        register3,
+        register4,
+    ], {
+        length: registerCount,
+    }),
+}));
+export const dalvikBytecodeFormat35msParser = promiseCompose(createTupleParser([
+    nibblesParser,
+    ushortParser,
+    nibblesParser,
+    nibblesParser,
+]), ([[registerCount, register4,], vtableOffset, [register1, register0,], [register3, register2,],]) => ({
+    vtableOffset,
+    registers: Object.assign([
+        register0,
+        register1,
+        register2,
+        register3,
+        register4,
+    ], {
+        length: registerCount,
+    }),
+}));
+export const dalvikBytecodeFormat3rmiParser = promiseCompose(createTupleParser([
+    ubyteParser,
+    ushortParser,
+    ushortParser,
+]), ([registerCount, inlineIndex, firstRegister,]) => ({
+    inlineIndex,
+    registers: Array.from({ length: registerCount }, (_, index) => firstRegister + index),
+}));
+export const dalvikBytecodeFormat3rmsParser = promiseCompose(createTupleParser([
+    ubyteParser,
+    ushortParser,
+    ushortParser,
+]), ([registerCount, vtableOffset, firstRegister,]) => ({
+    vtableOffset,
+    registers: Array.from({ length: registerCount }, (_, index) => firstRegister + index),
+}));
+export const createDalvikBytecodeFormat45ccParser = ({ isoMethodIndex, isoProtoIndex, }) => 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,
+    }),
+}));
+export const createDalvikBytecodeFormat4rccParser = ({ isoMethodIndex, isoProtoIndex, }) => 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/build/dalvikBytecodeParser/formatSizes.d.ts

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

package/build/dalvikBytecodeParser/formatSizes.js

@@ -0,0 +1,34 @@
+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,
+};

package/build/dalvikBytecodeParser/operationFormats.d.ts

@@ -0,0 +1,225 @@
+export declare const operationFormats: {
+    readonly nop: "10x";
+    readonly move: "12x";
+    readonly 'move/from16': "22x";
+    readonly 'move/16': "32x";
+    readonly 'move-wide': "12x";
+    readonly 'move-wide/from16': "22x";
+    readonly 'move-wide/16': "32x";
+    readonly 'move-object': "12x";
+    readonly 'move-object/from16': "22x";
+    readonly 'move-object/16': "32x";
+    readonly 'move-result': "11x";
+    readonly 'move-result-wide': "11x";
+    readonly 'move-result-object': "11x";
+    readonly 'move-exception': "11x";
+    readonly 'return-void': "10x";
+    readonly return: "11x";
+    readonly 'return-wide': "11x";
+    readonly 'return-object': "11x";
+    readonly 'const/4': "11n";
+    readonly 'const/16': "21s";
+    readonly const: "31i";
+    readonly 'const/high16': "21h";
+    readonly 'const-wide/16': "21s";
+    readonly 'const-wide/32': "31i";
+    readonly 'const-wide': "51l";
+    readonly 'const-wide/high16': "21h";
+    readonly 'const-string': "21c";
+    readonly 'const-string/jumbo': "31c";
+    readonly 'const-class': "21c";
+    readonly 'monitor-enter': "11x";
+    readonly 'monitor-exit': "11x";
+    readonly 'check-cast': "21c";
+    readonly 'instance-of': "22c";
+    readonly 'array-length': "12x";
+    readonly 'new-instance': "21c";
+    readonly 'new-array': "22c";
+    readonly 'filled-new-array': "35c";
+    readonly 'filled-new-array/range': "3rc";
+    readonly 'fill-array-data': "31t";
+    readonly throw: "11x";
+    readonly goto: "10t";
+    readonly 'goto/16': "20t";
+    readonly 'goto/32': "30t";
+    readonly 'packed-switch': "31t";
+    readonly 'sparse-switch': "31t";
+    readonly 'cmpl-float': "23x";
+    readonly 'cmpg-float': "23x";
+    readonly 'cmpl-double': "23x";
+    readonly 'cmpg-double': "23x";
+    readonly 'cmp-long': "23x";
+    readonly 'if-eq': "22t";
+    readonly 'if-ne': "22t";
+    readonly 'if-lt': "22t";
+    readonly 'if-ge': "22t";
+    readonly 'if-gt': "22t";
+    readonly 'if-le': "22t";
+    readonly 'if-eqz': "21t";
+    readonly 'if-nez': "21t";
+    readonly 'if-ltz': "21t";
+    readonly 'if-gez': "21t";
+    readonly 'if-gtz': "21t";
+    readonly 'if-lez': "21t";
+    readonly aget: "23x";
+    readonly 'aget-wide': "23x";
+    readonly 'aget-object': "23x";
+    readonly 'aget-boolean': "23x";
+    readonly 'aget-byte': "23x";
+    readonly 'aget-char': "23x";
+    readonly 'aget-short': "23x";
+    readonly aput: "23x";
+    readonly 'aput-wide': "23x";
+    readonly 'aput-object': "23x";
+    readonly 'aput-boolean': "23x";
+    readonly 'aput-byte': "23x";
+    readonly 'aput-char': "23x";
+    readonly 'aput-short': "23x";
+    readonly iget: "22c";
+    readonly 'iget-wide': "22c";
+    readonly 'iget-object': "22c";
+    readonly 'iget-boolean': "22c";
+    readonly 'iget-byte': "22c";
+    readonly 'iget-char': "22c";
+    readonly 'iget-short': "22c";
+    readonly iput: "22c";
+    readonly 'iput-wide': "22c";
+    readonly 'iput-object': "22c";
+    readonly 'iput-boolean': "22c";
+    readonly 'iput-byte': "22c";
+    readonly 'iput-char': "22c";
+    readonly 'iput-short': "22c";
+    readonly sget: "21c";
+    readonly 'sget-wide': "21c";
+    readonly 'sget-object': "21c";
+    readonly 'sget-boolean': "21c";
+    readonly 'sget-byte': "21c";
+    readonly 'sget-char': "21c";
+    readonly 'sget-short': "21c";
+    readonly sput: "21c";
+    readonly 'sput-wide': "21c";
+    readonly 'sput-object': "21c";
+    readonly 'sput-boolean': "21c";
+    readonly 'sput-byte': "21c";
+    readonly 'sput-char': "21c";
+    readonly 'sput-short': "21c";
+    readonly 'invoke-virtual': "35c";
+    readonly 'invoke-super': "35c";
+    readonly 'invoke-direct': "35c";
+    readonly 'invoke-static': "35c";
+    readonly 'invoke-interface': "35c";
+    readonly 'invoke-virtual/range': "3rc";
+    readonly 'invoke-super/range': "3rc";
+    readonly 'invoke-direct/range': "3rc";
+    readonly 'invoke-static/range': "3rc";
+    readonly 'invoke-interface/range': "3rc";
+    readonly 'neg-int': "12x";
+    readonly 'not-int': "12x";
+    readonly 'neg-long': "12x";
+    readonly 'not-long': "12x";
+    readonly 'neg-float': "12x";
+    readonly 'neg-double': "12x";
+    readonly 'int-to-long': "12x";
+    readonly 'int-to-float': "12x";
+    readonly 'int-to-double': "12x";
+    readonly 'long-to-int': "12x";
+    readonly 'long-to-float': "12x";
+    readonly 'long-to-double': "12x";
+    readonly 'float-to-int': "12x";
+    readonly 'float-to-long': "12x";
+    readonly 'float-to-double': "12x";
+    readonly 'double-to-int': "12x";
+    readonly 'double-to-long': "12x";
+    readonly 'double-to-float': "12x";
+    readonly 'int-to-byte': "12x";
+    readonly 'int-to-char': "12x";
+    readonly 'int-to-short': "12x";
+    readonly 'add-int': "23x";
+    readonly 'sub-int': "23x";
+    readonly 'mul-int': "23x";
+    readonly 'div-int': "23x";
+    readonly 'rem-int': "23x";
+    readonly 'and-int': "23x";
+    readonly 'or-int': "23x";
+    readonly 'xor-int': "23x";
+    readonly 'shl-int': "23x";
+    readonly 'shr-int': "23x";
+    readonly 'ushr-int': "23x";
+    readonly 'add-long': "23x";
+    readonly 'sub-long': "23x";
+    readonly 'mul-long': "23x";
+    readonly 'div-long': "23x";
+    readonly 'rem-long': "23x";
+    readonly 'and-long': "23x";
+    readonly 'or-long': "23x";
+    readonly 'xor-long': "23x";
+    readonly 'shl-long': "23x";
+    readonly 'shr-long': "23x";
+    readonly 'ushr-long': "23x";
+    readonly 'add-float': "23x";
+    readonly 'sub-float': "23x";
+    readonly 'mul-float': "23x";
+    readonly 'div-float': "23x";
+    readonly 'rem-float': "23x";
+    readonly 'add-double': "23x";
+    readonly 'sub-double': "23x";
+    readonly 'mul-double': "23x";
+    readonly 'div-double': "23x";
+    readonly 'rem-double': "23x";
+    readonly 'add-int/2addr': "12x";
+    readonly 'sub-int/2addr': "12x";
+    readonly 'mul-int/2addr': "12x";
+    readonly 'div-int/2addr': "12x";
+    readonly 'rem-int/2addr': "12x";
+    readonly 'and-int/2addr': "12x";
+    readonly 'or-int/2addr': "12x";
+    readonly 'xor-int/2addr': "12x";
+    readonly 'shl-int/2addr': "12x";
+    readonly 'shr-int/2addr': "12x";
+    readonly 'ushr-int/2addr': "12x";
+    readonly 'add-long/2addr': "12x";
+    readonly 'sub-long/2addr': "12x";
+    readonly 'mul-long/2addr': "12x";
+    readonly 'div-long/2addr': "12x";
+    readonly 'rem-long/2addr': "12x";
+    readonly 'and-long/2addr': "12x";
+    readonly 'or-long/2addr': "12x";
+    readonly 'xor-long/2addr': "12x";
+    readonly 'shl-long/2addr': "12x";
+    readonly 'shr-long/2addr': "12x";
+    readonly 'ushr-long/2addr': "12x";
+    readonly 'add-float/2addr': "12x";
+    readonly 'sub-float/2addr': "12x";
+    readonly 'mul-float/2addr': "12x";
+    readonly 'div-float/2addr': "12x";
+    readonly 'rem-float/2addr': "12x";
+    readonly 'add-double/2addr': "12x";
+    readonly 'sub-double/2addr': "12x";
+    readonly 'mul-double/2addr': "12x";
+    readonly 'div-double/2addr': "12x";
+    readonly 'rem-double/2addr': "12x";
+    readonly 'add-int/lit16': "22s";
+    readonly 'rsub-int': "22s";
+    readonly 'rsub-int/lit16': "22s";
+    readonly 'mul-int/lit16': "22s";
+    readonly 'div-int/lit16': "22s";
+    readonly 'rem-int/lit16': "22s";
+    readonly 'and-int/lit16': "22s";
+    readonly 'or-int/lit16': "22s";
+    readonly 'xor-int/lit16': "22s";
+    readonly 'add-int/lit8': "22b";
+    readonly 'rsub-int/lit8': "22b";
+    readonly 'mul-int/lit8': "22b";
+    readonly 'div-int/lit8': "22b";
+    readonly 'rem-int/lit8': "22b";
+    readonly 'and-int/lit8': "22b";
+    readonly 'or-int/lit8': "22b";
+    readonly 'xor-int/lit8': "22b";
+    readonly 'shl-int/lit8': "22b";
+    readonly 'shr-int/lit8': "22b";
+    readonly 'ushr-int/lit8': "22b";
+    readonly 'invoke-polymorphic': "45cc";
+    readonly 'invoke-polymorphic/range': "4rcc";
+    readonly 'invoke-custom': "35c";
+    readonly 'invoke-custom/range': "3rc";
+};