@futpib/parser 1.0.4 → 1.0.7

package/build/bashParser.test.js

@@ -98,6 +98,55 @@ test('double quoted string with variable', async (t) => {
         });
     }
 });
+test('double quoted string with trailing dollar', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo "hello$"', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    if (cmd.type === 'simple') {
+        t.deepEqual(cmd.args[0], {
+            parts: [{
+                    type: 'doubleQuoted',
+                    parts: [
+                        { type: 'literal', value: 'hello' },
+                        { type: 'literal', value: '$' },
+                    ],
+                }],
+        });
+    }
+});
+test('double quoted string with only dollar', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo "$"', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    if (cmd.type === 'simple') {
+        t.deepEqual(cmd.args[0], {
+            parts: [{
+                    type: 'doubleQuoted',
+                    parts: [
+                        { type: 'literal', value: '$' },
+                    ],
+                }],
+        });
+    }
+});
+test('grep with dollar anchor in double quotes', async (t) => {
+    const result = await runParser(bashScriptParser, 'grep "\\.ts$"', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    if (cmd.type === 'simple') {
+        t.deepEqual(cmd.args[0], {
+            parts: [{
+                    type: 'doubleQuoted',
+                    parts: [
+                        { type: 'literal', value: '\\' },
+                        { type: 'literal', value: '.ts' },
+                        { type: 'literal', value: '$' },
+                    ],
+                }],
+        });
+    }
+});
+test('pipeline with dollar anchor in double quoted grep pattern', async (t) => {
+    const result = await runParser(bashScriptParser, 'ls -la /home | grep "\\.ts$" | grep -v "\\.test\\.ts"', stringParserInputCompanion);
+    t.is(result.entries[0].pipeline.commands.length, 3);
+});
 test('simple variable', async (t) => {
     const result = await runParser(bashScriptParser, 'echo $HOME', stringParserInputCompanion);
     const cmd = result.entries[0].pipeline.commands[0];
@@ -172,6 +221,119 @@ test('[[ treated as command name', async (t) => {
         t.is(cmd.args.length, 3); // -f, file, ]]
     }
 });
+// Braced variable expansion: ${VAR}
+test('braced variable expansion', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo ${HOME}', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    if (cmd.type === 'simple') {
+        t.is(cmd.args[0].parts[0].type, 'variableBraced');
+    }
+});
+// Braced variable with default: ${VAR:-default}
+test('braced variable with default value', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo ${VAR:-default}', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    if (cmd.type === 'simple') {
+        t.is(cmd.args[0].parts[0].type, 'variableBraced');
+    }
+});
+// Arithmetic expansion: $((1+2))
+test('arithmetic expansion', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo $((1+2))', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    if (cmd.type === 'simple') {
+        t.is(cmd.args[0].parts[0].type, 'arithmeticExpansion');
+    }
+});
+// Bare $ at end of unquoted word
+test('bare dollar at end of unquoted word', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo foo$', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    if (cmd.type === 'simple') {
+        t.deepEqual(cmd.args[0], {
+            parts: [
+                { type: 'literal', value: 'foo' },
+                { type: 'literal', value: '$' },
+            ],
+        });
+    }
+});
+// Bare $ as its own unquoted word
+test('bare dollar as standalone unquoted word', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo $', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    if (cmd.type === 'simple') {
+        t.deepEqual(cmd.args[0], {
+            parts: [
+                { type: 'literal', value: '$' },
+            ],
+        });
+    }
+});
+// Comment after command
+test('comment after command', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo hello # this is a comment', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    if (cmd.type === 'simple') {
+        t.is(cmd.args.length, 1);
+        t.deepEqual(cmd.args[0], {
+            parts: [{ type: 'literal', value: 'hello' }],
+        });
+    }
+});
+// ANSI-C quoting: $'...'
+test('ansi-c quoting', async (t) => {
+    const result = await runParser(bashScriptParser, "echo $'hello\\nworld'", stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    if (cmd.type === 'simple') {
+        t.is(cmd.args.length, 1);
+    }
+});
+// Braced variable in double quotes: "${VAR}"
+test('braced variable in double quotes', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo "${HOME}"', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    if (cmd.type === 'simple') {
+        const dq = cmd.args[0].parts[0];
+        if (dq.type === 'doubleQuoted') {
+            t.is(dq.parts[0].type, 'variableBraced');
+        }
+    }
+});
+// Arithmetic expansion in double quotes
+test('arithmetic expansion in double quotes', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo "$((1+2))"', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    if (cmd.type === 'simple') {
+        const dq = cmd.args[0].parts[0];
+        if (dq.type === 'doubleQuoted') {
+            t.is(dq.parts[0].type, 'arithmeticExpansion');
+        }
+    }
+});
+// Process substitution: <(cmd)
+test('process substitution input', async (t) => {
+    const result = await runParser(bashScriptParser, 'diff <(sort file1) <(sort file2)', stringParserInputCompanion);
+    t.truthy(result);
+});
+// Line continuation (backslash-newline)
+test('line continuation', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo hello \\\nworld', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    if (cmd.type === 'simple') {
+        t.is(cmd.args.length, 2);
+    }
+});
+// Hash in middle of unquoted word is literal, not a comment
+test('hash in middle of unquoted word', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo foo#bar', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    if (cmd.type === 'simple') {
+        t.deepEqual(cmd.args[0], {
+            parts: [{ type: 'literal', value: 'foo#bar' }],
+        });
+    }
+});
 test('if treated as command name', async (t) => {
     const result = await runParser(bashScriptParser, 'if true', stringParserInputCompanion);
     const cmd = result.entries[0].pipeline.commands[0];
@@ -179,3 +341,74 @@ test('if treated as command name', async (t) => {
         t.deepEqual(cmd.name, { parts: [{ type: 'literal', value: 'if' }] });
     }
 });
+test('find -exec with {} placeholder', async (t) => {
+    const result = await runParser(bashScriptParser, 'find . -name "*.tmp" -exec rm {} \\;', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    t.is(cmd.name.parts[0].type, 'literal');
+    t.is(cmd.name.parts[0].value, 'find');
+    // {} should be parsed as a literal word argument
+    const braceArg = cmd.args[5]; // ., -name, "*.tmp", -exec, rm, {}, \;
+    t.is(braceArg.parts[0].type, 'literal');
+    t.is(braceArg.parts[0].value, '{}');
+});
+test('lone open brace as argument', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo {', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    t.deepEqual(cmd.args[0], {
+        parts: [{ type: 'literal', value: '{' }],
+    });
+});
+test('close brace mid-word', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo foo}bar', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    t.is(cmd.args.length, 1);
+    t.is(cmd.args[0].parts[0].type, 'literal');
+});
+test('open brace mid-word', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo foo{bar', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    t.is(cmd.args.length, 1);
+    t.is(cmd.args[0].parts[0].type, 'literal');
+});
+test('braces mid-word like brace expansion', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo file.{c,h}', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    t.is(cmd.args.length, 1);
+    t.is(cmd.args[0].parts[0].type, 'literal');
+});
+test('find -exec with {.} placeholder variant', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo {.}', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    t.is(cmd.args.length, 1);
+    t.is(cmd.args[0].parts[0].type, 'literal');
+});
+test('lone close brace as argument', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo }', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    t.deepEqual(cmd.args[0], {
+        parts: [{ type: 'literal', value: '}' }],
+    });
+});
+test('close brace at start of word', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo }hello', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    t.is(cmd.args.length, 1);
+    t.is(cmd.args[0].parts[0].type, 'literal');
+});
+test('multi-line script with blank lines', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo hello\n\necho world', stringParserInputCompanion);
+    t.is(result.entries.length, 2);
+});
+test('mid-script comment', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo hello\n# comment\necho world', stringParserInputCompanion);
+    t.is(result.entries.length, 2);
+});
+test('nested parentheses in arithmetic expansion', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo $((1 + (2 * 3)))', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    const arith = cmd.args[0].parts[0];
+    t.is(arith.type, 'arithmeticExpansion');
+    if (arith.type === 'arithmeticExpansion') {
+        t.is(arith.expression, '1 + (2 * 3)');
+    }
+});

package/build/bashParserEdgeCases.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/bashParserEdgeCases.test.js

@@ -0,0 +1,117 @@
+import test from 'ava';
+import { runParser } from './parser.js';
+import { stringParserInputCompanion } from './parserInputCompanion.js';
+import { bashScriptParser } from './bashParser.js';
+// Braced variable expansion: ${VAR}
+test('braced variable expansion', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo ${HOME}', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    if (cmd.type === 'simple') {
+        t.is(cmd.args[0].parts[0].type, 'variableBraced');
+    }
+});
+// Braced variable with default: ${VAR:-default}
+test('braced variable with default value', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo ${VAR:-default}', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    if (cmd.type === 'simple') {
+        t.is(cmd.args[0].parts[0].type, 'variableBraced');
+    }
+});
+// Arithmetic expansion: $((1+2))
+test('arithmetic expansion', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo $((1+2))', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    if (cmd.type === 'simple') {
+        t.is(cmd.args[0].parts[0].type, 'arithmeticExpansion');
+    }
+});
+// Bare $ at end of unquoted word
+test('bare dollar at end of unquoted word', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo foo$', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    if (cmd.type === 'simple') {
+        t.deepEqual(cmd.args[0], {
+            parts: [
+                { type: 'literal', value: 'foo' },
+                { type: 'literal', value: '$' },
+            ],
+        });
+    }
+});
+// Bare $ as its own unquoted word
+test('bare dollar as standalone unquoted word', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo $', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    if (cmd.type === 'simple') {
+        t.deepEqual(cmd.args[0], {
+            parts: [
+                { type: 'literal', value: '$' },
+            ],
+        });
+    }
+});
+// Comment after command
+test('comment after command', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo hello # this is a comment', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    if (cmd.type === 'simple') {
+        t.is(cmd.args.length, 1);
+        t.deepEqual(cmd.args[0], {
+            parts: [{ type: 'literal', value: 'hello' }],
+        });
+    }
+});
+// ANSI-C quoting: $'...'
+test('ansi-c quoting', async (t) => {
+    const result = await runParser(bashScriptParser, "echo $'hello\\nworld'", stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    if (cmd.type === 'simple') {
+        t.is(cmd.args.length, 1);
+    }
+});
+// Braced variable in double quotes: "${VAR}"
+test('braced variable in double quotes', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo "${HOME}"', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    if (cmd.type === 'simple') {
+        const dq = cmd.args[0].parts[0];
+        if (dq.type === 'doubleQuoted') {
+            t.is(dq.parts[0].type, 'variableBraced');
+        }
+    }
+});
+// Arithmetic expansion in double quotes
+test('arithmetic expansion in double quotes', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo "$((1+2))"', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    if (cmd.type === 'simple') {
+        const dq = cmd.args[0].parts[0];
+        if (dq.type === 'doubleQuoted') {
+            t.is(dq.parts[0].type, 'arithmeticExpansion');
+        }
+    }
+});
+// Process substitution: <(cmd)
+test('process substitution input', async (t) => {
+    const result = await runParser(bashScriptParser, 'diff <(sort file1) <(sort file2)', stringParserInputCompanion);
+    t.truthy(result);
+});
+// Line continuation (backslash-newline)
+test('line continuation', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo hello \\\nworld', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    if (cmd.type === 'simple') {
+        t.is(cmd.args.length, 2);
+    }
+});
+// Hash in middle of unquoted word is literal, not a comment
+test('hash in middle of unquoted word', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo foo#bar', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    if (cmd.type === 'simple') {
+        t.deepEqual(cmd.args[0], {
+            parts: [{ type: 'literal', value: 'foo#bar' }],
+        });
+    }
+});

package/build/dalvikBytecodeParser/addressConversion.d.ts

@@ -0,0 +1,110 @@
+import { type RawDalvikBytecodeOperation, type IndexResolvedOperation } from '../dalvikBytecodeParser.js';
+import { type CodeUnit, type InstructionIndex } from '../dalvikExecutableParser/typedNumbers.js';
+/**
+ * Map from code unit offset to instruction index.
+ * Keys are raw code unit offsets, values are instruction indices.
+ */
+export type CodeUnitToIndexMap = Map<CodeUnit, InstructionIndex>;
+/**
+ * Map from instruction index to code unit offset.
+ * Keys are instruction indices, values are raw code unit offsets.
+ */
+export type IndexToCodeUnitMap = Map<InstructionIndex, CodeUnit>;
+/**
+ * Calculate the size of an operation in code units (16-bit words).
+ * Works with any tier of operation (Tier 1, 2, 3, or SmaliCodeOperation).
+ */
+export declare function getOperationSizeInCodeUnits(operation: {
+    operation: string;
+    data?: Uint8Array | number[];
+}): number;
+/**
+ * Build mapping from code unit offset to instruction index.
+ * Also maps the end position (total code units) to instructions.length.
+ */
+export declare function buildCodeUnitToIndexMap(instructions: RawDalvikBytecodeOperation[]): CodeUnitToIndexMap;
+/**
+ * Build mapping from instruction index to code unit offset.
+ * Also maps instructions.length to the total code units.
+ */
+export declare function buildIndexToCodeUnitMap(instructions: RawDalvikBytecodeOperation[]): IndexToCodeUnitMap;
+/**
+ * Convert a code unit offset to an instruction index.
+ */
+export declare function codeUnitToInstructionIndex(codeUnitOffset: CodeUnit, codeUnitToIndexMap: CodeUnitToIndexMap): InstructionIndex;
+/**
+ * Convert an instruction index to a code unit offset.
+ */
+export declare function instructionIndexToCodeUnit(instructionIndex: InstructionIndex, indexToCodeUnitMap: IndexToCodeUnitMap): CodeUnit;
+/**
+ * Convert a relative branch offset (in code units) to a relative instruction offset.
+ * The offset is relative to the source instruction.
+ */
+export declare function convertBranchOffsetToInstructionOffset(branchOffsetInCodeUnits: CodeUnit, sourceInstructionIndex: InstructionIndex, indexToCodeUnitMap: IndexToCodeUnitMap, codeUnitToIndexMap: CodeUnitToIndexMap): InstructionIndex;
+/**
+ * Convert a relative instruction offset back to a code unit offset.
+ * The offset is relative to the source instruction.
+ */
+export declare function convertInstructionOffsetToBranchOffset(instructionOffset: InstructionIndex, sourceInstructionIndex: InstructionIndex, indexToCodeUnitMap: IndexToCodeUnitMap): CodeUnit;
+/**
+ * Find the switch instruction that references a payload at the given index.
+ * Returns the index of the switch instruction.
+ */
+export declare function findSwitchInstructionForPayload(instructions: RawDalvikBytecodeOperation[], payloadIndex: InstructionIndex, indexToCodeUnitMap: IndexToCodeUnitMap): InstructionIndex;
+export type ConvertedBranchOffsetOperation<T> = T extends {
+    branchOffsetCodeUnit: CodeUnit;
+} ? Omit<T, 'branchOffsetCodeUnit'> & {
+    branchOffsetIndex: InstructionIndex;
+} : T extends {
+    branchOffsetsCodeUnit: CodeUnit[];
+} ? Omit<T, 'branchOffsetsCodeUnit'> & {
+    branchOffsetsIndex: InstructionIndex[];
+} : T;
+export type ConvertedRawDalvikBytecodeOperation = ConvertedBranchOffsetOperation<RawDalvikBytecodeOperation>;
+export type ResolvedBranchOffsetOperation<T> = T extends {
+    branchOffsetIndex: InstructionIndex;
+} ? Omit<T, 'branchOffsetIndex'> & {
+    targetInstructionIndex: number;
+} : T extends {
+    branchOffsetsIndex: InstructionIndex[];
+} ? Omit<T, 'branchOffsetsIndex'> & {
+    targetInstructionIndices: number[];
+} : T;
+export type DalvikBytecodeOperation = IndexResolvedOperation<ResolvedBranchOffsetOperation<ConvertedRawDalvikBytecodeOperation>>;
+export type DalvikBytecode = DalvikBytecodeOperation[];
+/**
+ * Convert all branch offsets in instructions from code units to instruction offsets.
+ * Tier 1 (CodeUnit) -> Tier 2 (InstructionIndex)
+ */
+export declare function convertBranchOffsetsToInstructionOffsets(instructions: RawDalvikBytecodeOperation[]): ConvertedRawDalvikBytecodeOperation[];
+/**
+ * Unwrap instruction indices to plain numbers and convert relative to absolute.
+ * Tier 2 (InstructionIndex, relative) -> Tier 3 (plain number, absolute)
+ */
+export declare function unwrapBranchOffsets(instructions: ConvertedRawDalvikBytecodeOperation[]): DalvikBytecodeOperation[];
+/**
+ * Wrap plain numbers to instruction indices and convert absolute to relative.
+ * Tier 3 (plain number, absolute) -> Tier 2 (InstructionIndex, relative)
+ */
+export declare function wrapBranchOffsets(instructions: DalvikBytecodeOperation[]): ConvertedRawDalvikBytecodeOperation[];
+/**
+ * Build mapping from instruction index to code unit offset.
+ * Works with any tier of operations.
+ */
+export declare function buildIndexToCodeUnitMapGeneric(instructions: Array<{
+    operation: string;
+    data?: Uint8Array | number[];
+}>): IndexToCodeUnitMap;
+/**
+ * Build mapping from instruction index to code unit offset for Tier 2 operations.
+ */
+export declare function buildIndexToCodeUnitMapFromConverted(instructions: ConvertedRawDalvikBytecodeOperation[]): IndexToCodeUnitMap;
+/**
+ * Build mapping from instruction index to code unit offset for Tier 3 operations.
+ */
+export declare function buildIndexToCodeUnitMapFromResolved(instructions: DalvikBytecodeOperation[]): IndexToCodeUnitMap;
+/**
+ * Convert all branch offsets in instructions from instruction offsets back to code units.
+ * Tier 2 (InstructionIndex) -> Tier 1 (CodeUnit)
+ */
+export declare function convertInstructionOffsetsToBranchOffsets(instructions: ConvertedRawDalvikBytecodeOperation[]): RawDalvikBytecodeOperation[];