@futpib/parser 1.0.3 → 1.0.6

package/build/smaliParser.test.js

@@ -408,3 +408,61 @@ test('parse smali with virtual method after direct methods (a0/n issue)', async
     t.truthy(actual);
     t.is(actual.classData?.virtualMethods.length, 1);
 });
+// Minimal failing test case for .end local directive
+test('parse smali with .end local directive', async (t) => {
+    const smali = `.class public Lpl/czak/minimal/MainActivity;
+.super Landroid/app/Activity;
+
+# direct methods
+.method private sumToN(I)I
+    .registers 4
+    .param p1, "n"    # I
+
+    const/4 v0, 0x0
+
+    .local v0, "sum":I
+    const/4 v1, 0x1
+
+    .local v1, "i":I
+    :goto_2
+    if-gt v1, p1, :cond_8
+
+    add-int/2addr v0, v1
+
+    add-int/lit8 v1, v1, 0x1
+
+    goto :goto_2
+
+    .end local v1    # "i":I
+    :cond_8
+    return v0
+.end method
+`;
+    const actual = await runParser(smaliParser, smali, stringParserInputCompanion, {
+        errorJoinMode: 'all',
+    });
+    t.truthy(actual);
+    t.is(actual.classData?.directMethods.length, 1);
+});
+// Minimal test case for .local with generic type signature
+test('parse smali with .local directive with generic type signature', async (t) => {
+    const smali = `.class public Lpl/czak/minimal/MainActivity;
+.super Landroid/app/Activity;
+
+# direct methods
+.method private useLambda()Ljava/lang/String;
+    .registers 3
+
+    new-instance v0, Lpl/czak/minimal/MainActivity$$ExternalSyntheticLambda0;
+
+    .local v0, "supplier":Ljava/util/function/Supplier;, "Ljava/util/function/Supplier<Ljava/lang/String;>;"
+
+    return-object v0
+.end method
+`;
+    const actual = await runParser(smaliParser, smali, stringParserInputCompanion, {
+        errorJoinMode: 'all',
+    });
+    t.truthy(actual);
+    t.is(actual.classData?.directMethods.length, 1);
+});

package/build/stringEscapes.d.ts

@@ -0,0 +1,5 @@
+export declare function unescapeZigString(raw: string): string;
+export declare function escapeZigString(value: string): string;
+export declare function escapeZigChar(value: string): string;
+export declare function unescapeJavaString(raw: string): string;
+export declare function escapeJavaString(value: string): string;

package/build/stringEscapes.js

@@ -0,0 +1,244 @@
+export function unescapeZigString(raw) {
+    let result = '';
+    let i = 0;
+    while (i < raw.length) {
+        if (raw[i] === '\\' && i + 1 < raw.length) {
+            const next = raw[i + 1];
+            switch (next) {
+                case 'n':
+                    result += '\n';
+                    i += 2;
+                    break;
+                case 't':
+                    result += '\t';
+                    i += 2;
+                    break;
+                case 'r':
+                    result += '\r';
+                    i += 2;
+                    break;
+                case '\\':
+                    result += '\\';
+                    i += 2;
+                    break;
+                case '"':
+                    result += '"';
+                    i += 2;
+                    break;
+                case '\'':
+                    result += '\'';
+                    i += 2;
+                    break;
+                case 'x': {
+                    const hex = raw.slice(i + 2, i + 4);
+                    result += String.fromCharCode(parseInt(hex, 16));
+                    i += 4;
+                    break;
+                }
+                case 'u': {
+                    // \u{H+}
+                    const closeBrace = raw.indexOf('}', i + 3);
+                    const hex = raw.slice(i + 3, closeBrace);
+                    result += String.fromCodePoint(parseInt(hex, 16));
+                    i = closeBrace + 1;
+                    break;
+                }
+                default:
+                    result += raw[i];
+                    i++;
+                    break;
+            }
+        }
+        else {
+            result += raw[i];
+            i++;
+        }
+    }
+    return result;
+}
+export function escapeZigString(value) {
+    let result = '';
+    for (const ch of value) {
+        const code = ch.codePointAt(0);
+        switch (ch) {
+            case '\\':
+                result += '\\\\';
+                break;
+            case '"':
+                result += '\\"';
+                break;
+            case '\n':
+                result += '\\n';
+                break;
+            case '\r':
+                result += '\\r';
+                break;
+            case '\t':
+                result += '\\t';
+                break;
+            default:
+                if (code < 0x20) {
+                    result += '\\x' + code.toString(16).padStart(2, '0');
+                }
+                else if (code > 0x7E && code > 0xFFFF) {
+                    result += '\\u{' + code.toString(16) + '}';
+                }
+                else {
+                    result += ch;
+                }
+                break;
+        }
+    }
+    return result;
+}
+export function escapeZigChar(value) {
+    let result = '';
+    for (const ch of value) {
+        const code = ch.codePointAt(0);
+        switch (ch) {
+            case '\\':
+                result += '\\\\';
+                break;
+            case '\'':
+                result += '\\\'';
+                break;
+            case '\n':
+                result += '\\n';
+                break;
+            case '\r':
+                result += '\\r';
+                break;
+            case '\t':
+                result += '\\t';
+                break;
+            default:
+                if (code < 0x20) {
+                    result += '\\x' + code.toString(16).padStart(2, '0');
+                }
+                else if (code > 0x7E && code > 0xFFFF) {
+                    result += '\\u{' + code.toString(16) + '}';
+                }
+                else {
+                    result += ch;
+                }
+                break;
+        }
+    }
+    return result;
+}
+export function unescapeJavaString(raw) {
+    let result = '';
+    let i = 0;
+    while (i < raw.length) {
+        if (raw[i] === '\\' && i + 1 < raw.length) {
+            const next = raw[i + 1];
+            switch (next) {
+                case 'n':
+                    result += '\n';
+                    i += 2;
+                    break;
+                case 't':
+                    result += '\t';
+                    i += 2;
+                    break;
+                case 'r':
+                    result += '\r';
+                    i += 2;
+                    break;
+                case 'b':
+                    result += '\b';
+                    i += 2;
+                    break;
+                case 'f':
+                    result += '\f';
+                    i += 2;
+                    break;
+                case '\\':
+                    result += '\\';
+                    i += 2;
+                    break;
+                case '"':
+                    result += '"';
+                    i += 2;
+                    break;
+                case '\'':
+                    result += '\'';
+                    i += 2;
+                    break;
+                case 'u': {
+                    const hex = raw.slice(i + 2, i + 6);
+                    result += String.fromCharCode(parseInt(hex, 16));
+                    i += 6;
+                    break;
+                }
+                default: {
+                    // Octal escape: \0 - \377
+                    if (next >= '0' && next <= '7') {
+                        let octal = next;
+                        let j = i + 2;
+                        // Up to 3 octal digits, max value 377 (0xFF)
+                        if (j < raw.length && raw[j] >= '0' && raw[j] <= '7') {
+                            octal += raw[j];
+                            j++;
+                            if (j < raw.length && raw[j] >= '0' && raw[j] <= '7' && parseInt(octal + raw[j], 8) <= 0xFF) {
+                                octal += raw[j];
+                                j++;
+                            }
+                        }
+                        result += String.fromCharCode(parseInt(octal, 8));
+                        i = j;
+                    }
+                    else {
+                        result += raw[i];
+                        i++;
+                    }
+                    break;
+                }
+            }
+        }
+        else {
+            result += raw[i];
+            i++;
+        }
+    }
+    return result;
+}
+export function escapeJavaString(value) {
+    let result = '';
+    for (const ch of value) {
+        switch (ch) {
+            case '\\':
+                result += '\\\\';
+                break;
+            case '"':
+                result += '\\"';
+                break;
+            case '\n':
+                result += '\\n';
+                break;
+            case '\r':
+                result += '\\r';
+                break;
+            case '\t':
+                result += '\\t';
+                break;
+            case '\b':
+                result += '\\b';
+                break;
+            case '\f':
+                result += '\\f';
+                break;
+            default: {
+                const code = ch.charCodeAt(0);
+                if (code < 0x20) {
+                    result += '\\u' + code.toString(16).padStart(4, '0');
+                }
+                else {
+                    result += ch;
+                }
+                break;
+            }
+        }
+    }
+    return result;
+}

package/build/symbolicExpression.d.ts

@@ -0,0 +1,29 @@
+export type SymbolicExpressionAtom = {
+    type: 'atom';
+    value: string;
+};
+export type SymbolicExpressionString = {
+    type: 'string';
+    value: string;
+};
+export type SymbolicExpressionList = {
+    type: 'list';
+    value: SymbolicExpression[];
+};
+export type SymbolicExpressionQuote = {
+    type: 'quote';
+    value: SymbolicExpression;
+};
+export type SymbolicExpressionQuasiquote = {
+    type: 'quasiquote';
+    value: SymbolicExpression;
+};
+export type SymbolicExpressionUnquote = {
+    type: 'unquote';
+    value: SymbolicExpression;
+};
+export type SymbolicExpressionUnquoteSplicing = {
+    type: 'unquote-splicing';
+    value: SymbolicExpression;
+};
+export type SymbolicExpression = SymbolicExpressionAtom | SymbolicExpressionString | SymbolicExpressionList | SymbolicExpressionQuote | SymbolicExpressionQuasiquote | SymbolicExpressionUnquote | SymbolicExpressionUnquoteSplicing;

package/build/symbolicExpression.js

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

package/build/symbolicExpressionParser.d.ts

@@ -0,0 +1,4 @@
+import { type Parser } from './parser.js';
+import { type SymbolicExpression } from './symbolicExpression.js';
+export declare const symbolicExpressionParser: Parser<SymbolicExpression, string>;
+export declare const symbolicExpressionDocumentParser: Parser<SymbolicExpression, string>;

package/build/symbolicExpressionParser.js

@@ -0,0 +1,123 @@
+import { setParserName } from './parser.js';
+import { createDisjunctionParser } from './disjunctionParser.js';
+import { createExactSequenceParser } from './exactSequenceParser.js';
+import { promiseCompose } from './promiseCompose.js';
+import { createTupleParser } from './tupleParser.js';
+import { createArrayParser } from './arrayParser.js';
+import { createParserAccessorParser } from './parserAccessorParser.js';
+import { createRegExpParser } from './regexpParser.js';
+// Whitespace parser (spaces, tabs, newlines)
+const symbolicExpressionWhitespaceParser = promiseCompose(createRegExpParser(/\s+/), match => match[0]);
+setParserName(symbolicExpressionWhitespaceParser, 'symbolicExpressionWhitespaceParser');
+const symbolicExpressionOptionalWhitespaceParser = promiseCompose(createRegExpParser(/\s*/), match => match[0]);
+setParserName(symbolicExpressionOptionalWhitespaceParser, 'symbolicExpressionOptionalWhitespaceParser');
+// String literal parser: "..." with escape sequences
+const symbolicExpressionStringParser = promiseCompose(createRegExpParser(/"(?:[^"\\]|\\.)*"/s), match => {
+    // Remove surrounding quotes and process escape sequences in a single pass
+    const raw = match[0].slice(1, -1);
+    const value = raw.replace(/\\(.)/gs, (_, char) => {
+        switch (char) {
+            case 'n': return '\n';
+            case 'r': return '\r';
+            case 't': return '\t';
+            case 'f': return '\f';
+            case 'b': return '\b';
+            case '"': return '"';
+            case '\\': return '\\';
+            default: return char;
+        }
+    });
+    return {
+        type: 'string',
+        value,
+    };
+});
+setParserName(symbolicExpressionStringParser, 'symbolicExpressionStringParser');
+// Atom parser: unquoted symbols (any chars except whitespace, parens, quotes, etc.)
+// Supports backslash escapes: \x becomes x, trailing \ becomes nothing
+const symbolicExpressionAtomParser = promiseCompose(createRegExpParser(/(?:[^\s()"'`,;\\]|\\.)+\\?|\\$/), match => {
+    const raw = match[0];
+    // Process backslash escapes: \x becomes x, trailing \ becomes nothing
+    const value = raw.replace(/\\(.?)/g, '$1');
+    return {
+        type: 'atom',
+        value,
+    };
+});
+setParserName(symbolicExpressionAtomParser, 'symbolicExpressionAtomParser');
+// Quote parser: 'expr
+const symbolicExpressionQuoteParser = promiseCompose(createTupleParser([
+    createExactSequenceParser("'"),
+    symbolicExpressionOptionalWhitespaceParser,
+    createParserAccessorParser(() => symbolicExpressionParser),
+]), ([, , expr]) => ({
+    type: 'quote',
+    value: expr,
+}));
+setParserName(symbolicExpressionQuoteParser, 'symbolicExpressionQuoteParser');
+// Quasiquote parser: `expr
+const symbolicExpressionQuasiquoteParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('`'),
+    symbolicExpressionOptionalWhitespaceParser,
+    createParserAccessorParser(() => symbolicExpressionParser),
+]), ([, , expr]) => ({
+    type: 'quasiquote',
+    value: expr,
+}));
+setParserName(symbolicExpressionQuasiquoteParser, 'symbolicExpressionQuasiquoteParser');
+// Unquote-splicing parser: ,@expr (must come before unquote)
+const symbolicExpressionUnquoteSplicingParser = promiseCompose(createTupleParser([
+    createExactSequenceParser(',@'),
+    symbolicExpressionOptionalWhitespaceParser,
+    createParserAccessorParser(() => symbolicExpressionParser),
+]), ([, , expr]) => ({
+    type: 'unquote-splicing',
+    value: expr,
+}));
+setParserName(symbolicExpressionUnquoteSplicingParser, 'symbolicExpressionUnquoteSplicingParser');
+// Unquote parser: ,expr
+const symbolicExpressionUnquoteParser = promiseCompose(createTupleParser([
+    createExactSequenceParser(','),
+    symbolicExpressionOptionalWhitespaceParser,
+    createParserAccessorParser(() => symbolicExpressionParser),
+]), ([, , expr]) => ({
+    type: 'unquote',
+    value: expr,
+}));
+setParserName(symbolicExpressionUnquoteParser, 'symbolicExpressionUnquoteParser');
+// List element parser with optional whitespace
+const symbolicExpressionListElementParser = promiseCompose(createTupleParser([
+    createParserAccessorParser(() => symbolicExpressionParser),
+    symbolicExpressionOptionalWhitespaceParser,
+]), ([expr]) => expr);
+setParserName(symbolicExpressionListElementParser, 'symbolicExpressionListElementParser');
+// List parser: (...)
+const symbolicExpressionListParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('('),
+    symbolicExpressionOptionalWhitespaceParser,
+    createArrayParser(symbolicExpressionListElementParser),
+    createExactSequenceParser(')'),
+]), ([, , elements]) => ({
+    type: 'list',
+    value: elements,
+}));
+setParserName(symbolicExpressionListParser, 'symbolicExpressionListParser');
+// Main expression parser (union of all expression types)
+// Order matters: unquote-splicing before unquote, etc.
+export const symbolicExpressionParser = createDisjunctionParser([
+    symbolicExpressionListParser,
+    symbolicExpressionStringParser,
+    symbolicExpressionQuoteParser,
+    symbolicExpressionQuasiquoteParser,
+    symbolicExpressionUnquoteSplicingParser,
+    symbolicExpressionUnquoteParser,
+    symbolicExpressionAtomParser,
+]);
+setParserName(symbolicExpressionParser, 'symbolicExpressionParser');
+// Top-level parser that handles leading/trailing whitespace
+export const symbolicExpressionDocumentParser = promiseCompose(createTupleParser([
+    symbolicExpressionOptionalWhitespaceParser,
+    symbolicExpressionParser,
+    symbolicExpressionOptionalWhitespaceParser,
+]), ([, expr]) => expr);
+setParserName(symbolicExpressionDocumentParser, 'symbolicExpressionDocumentParser');

package/build/symbolicExpressionParser.test.d.ts

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