30:T97c0,Lang = { function createUnsignedParser(bits) { const max = (1n << BigInt(bits)) - 1n; // Maximum value for unsigned integer return (r) => r.INT_LITERAL.chain((num) => { if (num >= 0n && num <= max) { return P.succeed(num); } else { return P.fail(`Value out of range for u${bits}`); } }); } function createSignedParser(bits) { const min = -(1n << (BigInt(bits) - 1n)); // Minimum value for signed integer const max = (1n << (BigInt(bits) - 1n)) - 1n; // Maximum value for signed integer return (r) => r.INT_LITERAL.chain((num) => { if (num >= min && num <= max) { return P.succeed(num); } else { return P.fail(`Value out of range for i${bits}`); } }); } const flagTokens = [ "abstract", "annotation", "bridge", "enum", "final", "interface", "mandated", "module", "native", "open", "private", "protected", "public", "static", "static_phase", "strict", "strictfp", "super", "synchronized", "synthetic", "transient", "transitive", "varargs", "volatile" ]; const mhtagTokens = [ "getField", "getStatic", "putField", "putStatic", "invokeVirtual", "invokeStatic", "invokeSpecial", "newInvokeSpecial", "invokeInterface" ]; const noArgInstructions = [ "iload_0", "iload_1", "iload_2", "iload_3", "astore_0", "astore_1", "astore_2", "astore_3", "aaload", "aastore", "aconst_null", "aload_0", "aload_1", "aload_2", "aload_3", "areturn", "arraylength", "athrow", "baload", "bastore", "caload", "castore", "d2f", "d2i", "d2l", "dadd", "daload", "dastore", "dcmpg", "dcmpl", "dconst_0", "dconst_1", "ddiv", "dload_0", "dload_1", "dload_2", "dload_3", "dmul", "dneg", "drem", "dreturn", "dstore_0", "dstore_1", "dstore_2", "dstore_3", "dsub", "dup", "dup2", "dup2_x1", "dup2_x2", "dup_x1", "dup_x2", "f2d", "f2i", "f2l", "fadd", "faload", "fastore", "fcmpg", "fcmpl", "fconst_0", "fconst_1", "fconst_2", "fdiv", "fload_0", "fload_1", "fload_2", "fload_3", "fmul", "fneg", "frem", "freturn", "fstore_0", "fstore_1", "fstore_2", "fstore_3", "fsub", "i2b", "i2c", "i2d", "i2f", "i2l", "i2s", "iadd", "iaload", "iand", "iastore", "iconst_0", "iconst_1", "iconst_2", "iconst_3", "iconst_4", "iconst_5", "iconst_m1", "idiv", "imul", "ineg", "ior", "irem", "ireturn", "ishl", "ishr", "istore_0", "istore_1", "istore_2", "istore_3", "isub", "iushr", "ixor", "l2d", "l2f", "l2i", "ladd", "laload", "land", "lastore", "lcmp", "lconst_0", "lconst_1", "ldiv", "lload_0", "lload_1", "lload_2", "lload_3", "lmul", "lneg", "lor", "lrem", "lreturn", "lshl", "lshr", "lstore_0", "lstore_1", "lstore_2", "lstore_3", "lsub", "lushr", "lxor", "monitorenter", "monitorexit", "nop", "pop", "pop2", "return", "saload", "sastore", "swap" ]; const u8Instructions = [ "aload", "astore", "dload", "dstore", "fload", "fstore", "iload", "istore", "lload", "lstore", "ret" ]; const i8Instructions = ["bipush"]; const clsrefInstructions = [ "anewarray", "checkcast", "instanceof", "multianewarray", "new" ]; const lblInstructions = [ "goto", "goto_w", "if_acmpeq", "if_acmpne", "if_icmpeq", "if_icmpge", "if_icmpgt", "if_icmple", "if_icmplt", "if_icmpne", "ifeq", "ifge", "ifgt", "ifle", "iflt", "ifne", "ifnonnull", "ifnull", "jsr", "jsr_w" ]; const refOrTaggedConstInstructions = [ "getfield", "getstatic", "invokedynamic", "invokespecial", "invokestatic", "invokevirtual", "putfield", "putstatic" ]; const ldcInstructions = ["ldc", "ldc_w", "ldc2_w"]; const newarrayTypes = [ "boolean", "char", "float", "double", "byte", "short", "int", "long" ]; return P.createLanguage({ // Whitespace and Comments whitespace: () => P.regexp(/[ \t]+/).desc("whitespace"), comment: () => P.string(";") .then(P.regexp(/[^\n]*/)) .desc("comment"), ws: (r) => P.alt(r.whitespace, r.comment).many(), // NL Parser: One or more newlines with optional comments or whitespace NL: (r) => P.seq(r.ws, P.regexp(/\n/).atLeast(1), r.ws).atLeast(1).desc("NL"), // WORD Parser WORD: () => P.regexp(/(?:[a-zA-Z_$$<]|\[[A-Z\[])[\w$;/\[\($<>*+-]*/).desc("WORD"), // REF Parser REF: () => P.regexp(/\[[a-z0-9_]+\]/).desc("REF"), // BSREF Parser BSREF: () => P.regexp(/\[bs:[a-z0-9_]+\]/).desc("BSREF"), // LABEL_DEF Parser LABEL_DEF: () => P.regexp(/L\w+:/).desc("LABEL_DEF"), // STRING_LITERAL Parser STRING_LITERAL: () => P.alt( P.regexp(/b?"[^"\n\\]*(?:\\.[^"\n\\]*)*"/), P.regexp(/b?'[^'\n\\]*(?:\\.[^'\n\\]*)*'/) ).desc("STRING_LITERAL"), // INT_LITERAL Parser INT_LITERAL: () => P.regexp(/[+-]?(?:0x[0-9a-fA-F]+|[1-9][0-9]*|0)/).desc("INT_LITERAL"), // DOUBLE_LITERAL Parser DOUBLE_LITERAL: () => P.alt( P.regexp(/[+-]Infinity/), P.regexp(/[+-]NaN(?:<0x[0-9a-fA-F]{16}>)?/), P.regexp(/[+-]?\d+\.\d+(?:e[+-]?\d+)?/), P.regexp(/[+-]?\d+(?:e[+-]?\d+)/), P.regexp(/[+-]?0x[0-9a-fA-F]+(?:\.[0-9a-fA-F]+)?(?:p[+-]?\d+)/) ).desc("DOUBLE_LITERAL"), LONG_LITERAL: () => P.regexp(/[+-]?(?:0x[0-9a-fA-F]+|[1-9][0-9]*|0)L/).desc("LONG_LITERAL"), FLOAT_LITERAL: () => P.alt( P.regexp(/[+-]Infinityf/), P.regexp(/[+-]NaN(?:<0x[0-9a-fA-F]{8}>)?f/), P.regexp(/[+-]?\d+\.\d+(?:e[+-]?\d+)?f/), P.regexp(/[+-]?\d+(?:e[+-]?\d+)f/), P.regexp(/[+-]?0x[0-9a-fA-F]+(?:\.[0-9a-fA-F]+)?(?:p[+-]?\d+)f/) ).desc("FLOAT_LITERAL"), STRING_LITERAL: () => P.alt( P.regexp( /b?"(?:[^"\\\n]|\\[\\nrt"'\\]|\\u[0-9a-fA-F]{4}|\\U[0-9a-fA-F]{8}|\\x[0-9a-fA-F]{2})*"/ ), P.regexp( /b?'(?:[^'\\\n]|\\[\\nrt"'\\]|\\u[0-9a-fA-F]{4}|\\U[0-9a-fA-F]{8}|\\x[0-9a-fA-F]{2})*'/ ) ).desc("STRING_LITERAL"), u8: (r) => createUnsignedParser(8)(r), u16: (r) => createUnsignedParser(16)(r), u32: (r) => createUnsignedParser(32)(r), u64: (r) => createUnsignedParser(64)(r), // Signed integer parsers i8: (r) => createSignedParser(8)(r), i16: (r) => createSignedParser(16)(r), i32: (r) => createSignedParser(32)(r), i64: (r) => createSignedParser(64)(r), flags: (r) => P.alt(...flagTokens.map(P.string)).sepBy(P.whitespace), lbl: (r) => r.WORD.chain((word) => { if (word.startsWith("L") && word[0] === "L") { return P.succeed(word); } else { return P.fail("Not a valid lbl"); } }).desc("lbl"), // New parsers utf: (r) => P.alt(r.WORD, r.STRING_LITERAL).desc("utf"), utfref: (r) => P.alt(r.REF, r.utf).desc("utfref"), clsref: (r) => P.alt(r.REF, r.utf).desc("clsref"), single: (r) => P.alt(r.REF, r.utf).desc("single"), natref: (r) => P.alt(r.REF, P.seq(r.utf.skip(r.ws), r.utfref)).desc("natref"), mhtag: () => P.alt(...mhtagTokens.map(P.string)).desc("mhtag"), ref_or_tagged_const: (r) => P.alt(r.REF, r.tagged_const).desc("ref_or_tagged_const"), mhnotref: (r) => P.seq(r.mhtag.skip(r.ws), r.ref_or_tagged_const).desc("mhnotref"), tagged_const: (r) => P.alt( P.seq(P.string("Utf8").skip(r.ws), r.utf), P.seq(P.string("Int").skip(r.ws), r.i32), P.seq(P.string("Float").skip(r.ws), r.FLOAT_LITERAL), P.seq(P.string("Long").skip(r.ws), r.LONG_LITERAL), P.seq(P.string("Double").skip(r.ws), r.DOUBLE_LITERAL), P.seq(P.string("Class").skip(r.ws), r.utfref), P.seq(P.string("String").skip(r.ws), r.utfref), P.seq(P.string("MethodType").skip(r.ws), r.utfref), P.seq(P.string("Module").skip(r.ws), r.utfref), P.seq(P.string("Package").skip(r.ws), r.utfref), P.seq(P.string("Field").skip(r.ws), r.clsref.skip(r.ws), r.natref), P.seq(P.string("Method").skip(r.ws), r.clsref.skip(r.ws), r.natref), P.seq( P.string("InterfaceMethod").skip(r.ws), r.clsref.skip(r.ws), r.natref ), P.seq( P.string("NameAndType").skip(r.ws), r.utfref.skip(r.ws), r.utfref ), P.seq(P.string("MethodHandle").skip(r.ws), r.mhnotref), P.seq(P.string("Dynamic").skip(r.ws), r.bsref.skip(r.ws), r.natref), P.seq( P.string("InvokeDynamic").skip(r.ws), r.bsref.skip(r.ws), r.natref ) ).desc("tagged_const"), bs_args: (r) => P.seq(r.ref_or_tagged_const.many().skip(r.ws), P.string(":")).desc( "bs_args" ), bsref: (r) => P.alt(r.BSREF, P.seq(r.mhnotref.skip(r.ws), r.bs_args)).desc("bsref"), ref_or_tagged_bootstrap: (r) => P.alt( r.BSREF, P.seq(P.string("Bootstrap").skip(r.ws), r.REF.skip(r.ws), r.bs_args), P.seq( P.string("Bootstrap").skip(r.ws), r.mhnotref.skip(r.ws), r.bs_args ) ).desc("ref_or_tagged_bootstrap"), ldc_rhs: (r) => P.alt( r.INT_LITERAL, r.FLOAT_LITERAL, r.LONG_LITERAL, r.DOUBLE_LITERAL, r.STRING_LITERAL, r.REF, r.tagged_const ).desc("ldc_rhs"), instruction: (r) => P.alt( r.noArgInstruction, r.u8Instruction, r.i8Instruction, r.clsrefInstruction, r.lblInstruction, r.refOrTaggedConstInstruction, r.ldcInstruction, r.newarrayInstruction, r.i16Instruction, r.lookupswitchInstruction, r.tableswitchInstruction, r.wideInstruction, r.iincInstruction, r.multianewarrayInstruction ).desc("instruction"), // No-argument instructions noArgInstruction: () => P.alt(...noArgInstructions.map(P.string)).desc("No-Argument Instruction"), // u8 argument instructions u8Instruction: (r) => P.alt( ...u8Instructions.map((instr) => P.seqMap(P.string(instr).skip(r.ws), r.u8, (op, arg) => ({ op, arg })) ) ).desc("u8 Instruction"), // i8 argument instructions i8Instruction: (r) => P.seqMap(P.string("bipush").skip(r.ws), r.i8, (op, arg) => ({ op, arg })).desc("i8 Instruction"), // iinc instruction (special case with u8 and i8) iincInstruction: (r) => P.seqMap( P.string("iinc").skip(r.ws), r.u8.skip(r.ws), r.i8, (op, varnum, incr) => ({ op, varnum, incr }) ).desc("iinc Instruction"), // clsref instructions clsrefInstruction: (r) => P.alt( ...clsrefInstructions.map((instr) => P.seqMap(P.string(instr).skip(r.ws), r.clsref, (op, arg) => ({ op, arg })) ) ).desc("clsref Instruction"), // multianewarray instruction (clsref u8) multianewarrayInstruction: (r) => P.seqMap( P.string("multianewarray").skip(r.ws), r.clsref.skip(r.ws), r.u8, (op, cls, dims) => ({ op, cls, dims }) ).desc("multianewarray Instruction"), // lbl instructions lblInstruction: (r) => P.alt( ...lblInstructions.map((instr) => P.seqMap(P.string(instr).skip(r.ws), r.lbl, (op, arg) => ({ op, arg })) ) ).desc("Label Instruction"), // ref_or_tagged_const instructions refOrTaggedConstInstruction: (r) => P.alt( ...refOrTaggedConstInstructions.map((instr) => P.seqMap( P.string(instr).skip(r.ws), r.ref_or_tagged_const, (op, arg) => ({ op, arg }) ) ), // Handle optional u8 for "invokeinterface" P.seqMap( P.string("invokeinterface").skip(r.ws), r.ref_or_tagged_const.skip(r.ws), r.u8.atMost(1), // u8 is optional (op, arg, count) => ({ op, arg, count: count[0] || null }) ) ).desc("ref_or_tagged_const Instruction"), // ldc instructions ldcInstruction: (r) => P.alt( ...ldcInstructions.map((instr) => P.seqMap(P.string(instr).skip(r.ws), r.ldc_rhs, (op, arg) => ({ op, arg })) ) ).desc("ldc Instruction"), // newarray instruction newarrayInstruction: (r) => P.seqMap( P.string("newarray").skip(r.ws), P.alt(...newarrayTypes.map(P.string)), (op, arg) => ({ op, arg }) ).desc("newarray Instruction"), // i16 argument instruction i16Instruction: (r) => P.seqMap(P.string("sipush").skip(r.ws), r.i16, (op, arg) => ({ op, arg })).desc("i16 Instruction"), // lookupswitch instruction lookupswitchInstruction: (r) => P.seqMap( P.string("lookupswitch").skip(r.ws), r.NL, r.lookupPairs.atLeast(0), P.string("default").skip(r.ws).skip(P.string(":")).skip(r.ws), r.lbl, (op, _, pairs, __, defaultLbl) => ({ op, pairs, defaultLbl }) ).desc("lookupswitch Instruction"), lookupPairs: (r) => P.seqMap( r.i32.skip(r.ws).skip(P.string(":")).skip(r.ws), r.lbl.skip(r.NL), (key, lbl) => ({ key, lbl }) ), // tableswitch instruction tableswitchInstruction: (r) => P.seqMap( P.string("tableswitch").skip(r.ws), r.i32.skip(r.ws).skip(r.NL), r.tableLabels.atLeast(1), P.string("default").skip(r.ws).skip(P.string(":")).skip(r.ws), r.lbl, (op, low, labels, _, defaultLbl) => ({ op, low, labels, defaultLbl }) ).desc("tableswitch Instruction"), tableLabels: (r) => r.lbl.skip(r.NL), // wide instruction wideInstruction: (r) => P.seqMap( P.string("wide").skip(r.ws), r.wideInstructionBody, (op, body) => ({ op, body }) ).desc("wide Instruction"), wideInstructionBody: (r) => P.alt( P.seqMap( P.alt( P.string("aload"), P.string("astore"), P.string("dload"), P.string("dstore"), P.string("fload"), P.string("fstore"), P.string("iload"), P.string("istore"), P.string("lload"), P.string("lstore"), P.string("ret") ).skip(r.ws), r.u16, (instr, arg) => ({ instr, arg }) ), P.seqMap( P.string("iinc").skip(r.ws), r.u16.skip(r.ws), r.i16, (instr, varnum, incr) => ({ instr, varnum, incr }) ) ).desc("wide Instruction Body"), // vtype Parser vtype: (r) => P.alt( P.string("Float"), P.string("Integer"), P.string("Long"), P.string("Null"), P.seqMap(P.string("Object").skip(r.ws), r.clsref, (_, cls) => ({ type: "Object", cls })), P.string("Top"), P.seqMap(P.string("Uninitialized").skip(r.ws), r.lbl, (_, lbl) => ({ type: "Uninitialized", lbl })), P.string("UninitializedThis") ).desc("vtype"), // stack_map_item Parser stack_map_item: (r) => P.alt( P.string("same").result({ type: "same" }), P.seqMap(P.string("stack_1").skip(r.ws), r.vtype, (_, vtype) => ({ type: "stack_1", vtype })), P.seqMap( P.string("stack_1_extended").skip(r.ws), r.vtype, (_, vtype) => ({ type: "stack_1_extended", vtype }) ), P.seqMap(P.string("chop").skip(r.ws), r.u8, (_, num) => ({ type: "chop", num })), P.string("same_extended").result({ type: "same_extended" }), P.seqMap( P.string("append").skip(r.ws), r.vtype.many1(), (_, vtypes) => ({ type: "append", vtypes }) ), P.seqMap( P.string("full").skip(r.ws).skip(r.NL), P.string("locals").skip(r.ws), r.vtype.many().skip(r.NL), P.string("stack").skip(r.ws), r.vtype.many().skip(r.NL), P.string(".end").skip(r.ws).skip(P.string("stack")), (_, __, locals, ___, stack, ____) => ({ type: "full", locals, stack }) ) ).desc("stack_map_item"), // code_directive Parser code_directive: (r) => P.alt( P.seqMap( P.string(".catch").skip(r.ws), r.clsref.skip(r.ws), P.string("from").skip(r.ws), r.lbl.skip(r.ws), P.string("to").skip(r.ws), r.lbl.skip(r.ws), P.string("using").skip(r.ws), r.lbl, (_, clsref, __, fromLbl, ___, toLbl, ____, usingLbl) => ({ type: "catch", clsref, fromLbl, toLbl, usingLbl }) ), P.seqMap( P.string(".stack").skip(r.ws), r.stack_map_item, (_, item) => ({ type: "stack", item }) ) ).desc("code_directive"), // code_item Parser code_item: (r) => P.alt( P.seqMap( r.LABEL_DEF.skip(r.ws), r.instruction.atMost(1), (labelDef, instr) => ({ labelDef, instruction: instr[0] || null }) ), r.instruction, r.code_directive ).desc("code_item"), // code_attr Parser code_attr: (r) => P.seqMap( P.string("long").skip(r.ws).atMost(1), P.string("stack").skip(r.ws), r.u16.skip(r.ws), P.string("locals").skip(r.ws), r.u16.skip(r.NL), r.code_item.skip(r.NL).many(), r.attribute.skip(r.NL).many(), P.string(".end").skip(r.ws).skip(P.string("code")), ( longOpt, _, stackSize, __, localsSize, codeItems, attributes, ___ ) => ({ long: longOpt.length > 0, stackSize, localsSize, codeItems, attributes }) ).desc("code_attr"), // attrbody Parser attrbody: (r) => P.alt( P.seqMap( P.string(".annotationdefault").skip(r.ws), r.element_value, (_, value) => ({ type: "annotationdefault", value }) ), P.string(".bootstrapmethods").result({ type: "bootstrapmethods" }), P.seqMap(P.string(".code").skip(r.ws), r.code_attr, (_, code) => ({ type: "code", code })), P.seqMap( P.string(".constantvalue").skip(r.ws), r.ldc_rhs, (_, value) => ({ type: "constantvalue", value }) ), P.string(".deprecated").result({ type: "deprecated" }), P.seqMap( P.string(".enclosing").skip(r.ws), P.string("method").skip(r.ws), r.clsref.skip(r.ws), r.natref, (_, __, cls, nat) => ({ type: "enclosingmethod", cls, nat }) ), P.seqMap( P.string(".exceptions").skip(r.ws), r.clsref.many(), (_, exceptions) => ({ type: "exceptions", exceptions }) ), P.seqMap( P.string(".innerclasses").skip(r.NL), P.seqMap( r.clsref.skip(r.ws), r.clsref.skip(r.ws), r.utfref.skip(r.ws), r.flags.skip(r.NL), (innerCls, outerCls, innerName, flags) => ({ innerCls, outerCls, innerName, flags }) ).many(), P.string(".end").skip(r.ws).skip(P.string("innerclasses")), (_, classes, __) => ({ type: "innerclasses", classes }) ), P.seqMap( P.string(".linenumbertable").skip(r.ws), r.NL.atMost(1), P.seqMap(r.lbl.skip(r.ws), r.u16.skip(r.NL), (label, lineNumber) => ({ label, lineNumber })).many(), P.string(".end").skip(r.ws).skip(P.string("linenumbertable")), (_, __, lines, ___) => ({ type: "linenumbertable", lines }) ), P.seqMap( P.string(".localvariabletable").skip(r.NL), r.local_var_table_item.skip(r.NL).many(), P.string(".end").skip(r.ws).skip(P.string("localvariabletable")), (_, vars, __) => ({ type: "localvariabletable", vars }) ), P.seqMap( P.string(".localvariabletypetable").skip(r.NL), r.local_var_table_item.skip(r.NL).many(), P.string(".end").skip(r.ws).skip(P.string("localvariabletypetable")), (_, vars, __) => ({ type: "localvariabletypetable", vars }) ), P.seqMap( P.string(".methodparameters").skip(r.NL), r.method_parameter_item.skip(r.NL).many(), P.string(".end").skip(r.ws).skip(P.string("methodparameters")), (_, params, __) => ({ type: "methodparameters", params }) ), P.seqMap(P.string(".module").skip(r.ws), r.module, (_, module) => ({ type: "module", module })), P.seqMap( P.string(".modulemainclass").skip(r.ws), r.clsref, (_, cls) => ({ type: "modulemainclass", cls }) ), P.seqMap( P.string(".modulepackages").skip(r.ws), r.single.many(), (_, packages) => ({ type: "modulepackages", packages }) ), P.seqMap(P.string(".nesthost").skip(r.ws), r.clsref, (_, cls) => ({ type: "nesthost", cls })), P.seqMap( P.string(".nestmembers").skip(r.ws), r.clsref.many(), (_, members) => ({ type: "nestmembers", members }) ), P.seqMap( P.string(".permittedsubclasses").skip(r.ws), r.clsref.many(), (_, subclasses) => ({ type: "permittedsubclasses", subclasses }) ), P.seqMap( P.string(".record").skip(r.NL), r.record_item.skip(r.NL).many(), P.string(".end").skip(r.ws).skip(P.string("record")), (_, records, __) => ({ type: "record", records }) ), P.seqMap( P.string(".runtime").skip(r.ws), r.runtime_visibility.skip(r.ws), r.runtime_attr, (_, visibility, attr) => ({ type: "runtime", visibility, attr }) ), P.seqMap(P.string(".signature").skip(r.ws), r.utfref, (_, sig) => ({ type: "signature", sig })), P.seqMap( P.string(".sourcedebugextension").skip(r.ws), r.STRING_LITERAL, (_, value) => ({ type: "sourcedebugextension", value }) ), P.seqMap(P.string(".sourcefile").skip(r.ws), r.utfref, (_, value) => ({ type: "sourcefile", value })), P.string(".stackmaptable").result({ type: "stackmaptable" }), P.string(".synthetic").result({ type: "synthetic" }) ).desc("attrbody"), // runtime_visibility Parser runtime_visibility: () => P.alt(P.string("visible"), P.string("invisible")).desc( "runtime_visibility" ), // runtime_attr Parser runtime_attr: (r) => P.alt( P.seqMap( P.string("annotations").skip(r.NL), r.annotation.skip(r.NL).many(), P.string(".end").skip(r.ws).skip(P.string("annotations")), (_, annotations, __) => ({ type: "annotations", annotations }) ), P.seqMap( P.string("paramannotations").skip(r.NL), r.param_annotation.skip(r.NL).many(), P.string(".end").skip(r.ws).skip(P.string("paramannotations")), (_, paramAnnotations, __) => ({ type: "paramannotations", paramAnnotations }) ), P.seqMap( P.string("typeannotations").skip(r.NL), r.type_annotation.skip(r.NL).many(), P.string(".end").skip(r.ws).skip(P.string("typeannotations")), (_, typeAnnotations, __) => ({ type: "typeannotations", typeAnnotations }) ) ).desc("runtime_attr"), // annotation Parser annotation: (r) => P.seqMap(r.annotation_sub, P.string("annotation"), (sub, _) => ({ ...sub })).desc("annotation"), // annotation_sub Parser annotation_sub: (r) => P.seqMap( r.utfref.skip(r.NL), P.seqMap( r.utfref.skip(r.ws).skip(P.string("=")).skip(r.ws), r.element_value.skip(r.NL), (name, value) => ({ name, value }) ).many(), P.string(".end"), (typeName, elements, _) => ({ typeName, elements }) ).desc("annotation_sub"), // element_value Parser element_value: (r) => P.alt( P.seqMap( P.string("annotation").skip(r.ws), r.annotation, (_, annotation) => ({ type: "annotation", annotation }) ), P.seqMap( P.string("array").skip(r.ws).skip(r.NL), r.element_value.skip(r.NL).many(), P.string(".end").skip(r.ws).skip(P.string("array")), (_, values, __) => ({ type: "array", values }) ), P.seqMap(P.string("boolean").skip(r.ws), r.ldc_rhs, (_, value) => ({ type: "boolean", value })), P.seqMap(P.string("byte").skip(r.ws), r.ldc_rhs, (_, value) => ({ type: "byte", value })), P.seqMap(P.string("char").skip(r.ws), r.ldc_rhs, (_, value) => ({ type: "char", value })), P.seqMap(P.string("class").skip(r.ws), r.utfref, (_, value) => ({ type: "class", value })), P.seqMap(P.string("double").skip(r.ws), r.ldc_rhs, (_, value) => ({ type: "double", value })), P.seqMap( P.string("enum").skip(r.ws), r.utfref.skip(r.ws), r.utfref, (_, typeName, constName) => ({ type: "enum", typeName, constName }) ), P.seqMap(P.string("float").skip(r.ws), r.ldc_rhs, (_, value) => ({ type: "float", value })), P.seqMap(P.string("int").skip(r.ws), r.ldc_rhs, (_, value) => ({ type: "int", value })), P.seqMap(P.string("long").skip(r.ws), r.ldc_rhs, (_, value) => ({ type: "long", value })), P.seqMap(P.string("short").skip(r.ws), r.ldc_rhs, (_, value) => ({ type: "short", value })), P.seqMap(P.string("string").skip(r.ws), r.utfref, (_, value) => ({ type: "string", value })) ).desc("element_value"), // local_var_table_item Parser local_var_table_item: (r) => P.seqMap( r.u16.skip(r.ws), P.string("is").skip(r.ws), r.utfref.skip(r.ws), r.utfref.skip(r.ws), P.string("from").skip(r.ws), r.lbl.skip(r.ws), P.string("to").skip(r.ws), r.lbl, (index, _, name, descriptor, __, startLbl, ___, endLbl) => ({ index, name, descriptor, startLbl, endLbl }) ).desc("local_var_table_item"), // method_parameter_item Parser method_parameter_item: (r) => P.seqMap(r.utfref.skip(r.ws), r.flags, (name, flags) => ({ name, flags })).desc("method_parameter_item"), // module Parser module: (r) => P.seqMap( r.utfref.skip(r.ws), r.flags.skip(r.ws), P.string("version").skip(r.ws), r.utfref.skip(r.NL), r.module_directives.many(), P.string(".end").skip(r.ws).skip(P.string("module")), (name, flags, _, version, directives, __) => ({ name, flags, version, directives }) ).desc("module"), // module_directives Parser module_directives: (r) => P.alt( P.seqMap( P.string(".requires").skip(r.ws), r.single.skip(r.ws), r.flags.skip(r.ws), P.string("version").skip(r.ws), r.utfref.skip(r.NL), (_, moduleName, flags, __, version, ___) => ({ type: "requires", moduleName, flags, version }) ), P.seqMap( P.string(".exports").skip(r.ws), r.exports_item.skip(r.NL), (_, exportsItem) => ({ type: "exports", exportsItem }) ), P.seqMap( P.string(".opens").skip(r.ws), r.exports_item.skip(r.NL), (_, opensItem) => ({ type: "opens", opensItem }) ), P.seqMap( P.string(".uses").skip(r.ws), r.clsref.skip(r.NL), (_, cls) => ({ type: "uses", cls }) ), P.seqMap( P.string(".provides").skip(r.ws), r.clsref.skip(r.ws), P.string("with").skip(r.ws), r.clsref.skip(r.NL).many(), (_, service, __, implementations) => ({ type: "provides", service, implementations }) ) ).desc("module_directives"), // exports_item Parser exports_item: (r) => P.seqMap( r.single.skip(r.ws), r.flags.skip(r.ws), P.seq(P.string("to").skip(r.ws), r.single.skip(r.NL).many()).atMost(1), (packageName, flags, toClause) => ({ packageName, flags, to: toClause.length > 0 ? toClause[0][1] : [] }) ).desc("exports_item"), // record_item Parser record_item: (r) => P.seqMap( r.utfref.skip(r.ws), r.utfref.skip(r.ws), r.record_attrs.atMost(1), r.NL, (name, descriptor, attrs, _) => ({ name, descriptor, attrs: attrs[0] || null }) ).desc("record_item"), // record_attrs Parser record_attrs: (r) => P.seqMap( P.string(".attributes").skip(r.ws).skip(r.NL), r.attribute.skip(r.NL).many(), P.string(".end").skip(r.ws).skip(P.string("attributes")), (_, attributes, __) => ({ attributes }) ).desc("record_attrs"), // param_annotation Parser param_annotation: (r) => P.seqMap( P.string(".paramannotation").skip(r.ws).skip(r.NL), r.annotation.skip(r.NL).many(), P.string(".end").skip(r.ws).skip(P.string("paramannotation")), (_, annotations, __) => ({ annotations }) ).desc("param_annotation"), // type_annotation Parser type_annotation: (r) => P.seqMap( P.string(".typeannotation").skip(r.ws), r.ta_target_info.skip(r.ws), r.ta_target_path.skip(r.ws), r.annotation_sub, P.string("typeannotation"), (_, targetInfo, targetPath, annotation, __) => ({ targetInfo, targetPath, annotation }) ).desc("type_annotation"), // ta_target_info Parser ta_target_info: (r) => P.seqMap( r.u8.skip(r.ws), r.ta_target_info_body.skip(r.NL), (u8value, body) => ({ u8value, body }) ).desc("ta_target_info"), // ta_target_info_body Parser ta_target_info_body: (r) => P.alt( P.seqMap(P.string("typeparam").skip(r.ws), r.u8, (_, index) => ({ type: "typeparam", index })), P.seqMap(P.string("super").skip(r.ws), r.u16, (_, index) => ({ type: "super", index })), P.seqMap( P.string("typeparambound").skip(r.ws), r.u8.skip(r.ws), r.u8, (_, index1, index2) => ({ type: "typeparambound", index1, index2 }) ), P.string("empty").result({ type: "empty" }), P.seqMap(P.string("methodparam").skip(r.ws), r.u8, (_, index) => ({ type: "methodparam", index })), P.seqMap(P.string("throws").skip(r.ws), r.u16, (_, index) => ({ type: "throws", index })), P.seqMap( P.string("localvar").skip(r.ws).skip(r.NL), r.localvar_info.skip(r.NL).many(), P.string(".end").skip(r.ws).skip(P.string("localvar")), (_, infos, __) => ({ type: "localvar", infos }) ), P.seqMap(P.string("catch").skip(r.ws), r.u16, (_, index) => ({ type: "catch", index })), P.seqMap(P.string("offset").skip(r.ws), r.lbl, (_, label) => ({ type: "offset", label })), P.seqMap( P.string("typearg").skip(r.ws), r.lbl.skip(r.ws), r.u8, (_, label, index) => ({ type: "typearg", label, index }) ) ).desc("ta_target_info_body"), // localvar_info Parser localvar_info: (r) => P.alt( P.string("nowhere").result({ type: "nowhere" }), P.seqMap( P.string("from").skip(r.ws), r.lbl.skip(r.ws), P.string("to").skip(r.ws), r.lbl, (_, fromLbl, __, toLbl) => ({ type: "range", fromLbl, toLbl }) ) ).desc("localvar_info"), // ta_target_path Parser ta_target_path: (r) => P.seqMap( P.string(".typepath").skip(r.ws).skip(r.NL), P.seqMap(r.u8.skip(r.ws), r.u8.skip(r.NL), (kind, index) => ({ kind, index })).many(), P.string(".end").skip(r.ws).skip(P.string("typepath")).skip(r.NL), (_, path, __) => ({ path }) ).desc("ta_target_path"), // source_file Parser source_file: (r) => P.seq(r.NL.atMost(1), r.class_def.many()) .map(([, classes]) => ({ classes })) .desc("source_file"), // class_def Parser class_def: (r) => P.seqMap( P.seq( P.string(".version") .skip(r.ws) .then(r.u16) .skip(r.ws) .chain((major) => r.u16.map((minor) => ({ major, minor }))) .skip(r.NL) ).atMost(1), P.string(".class").skip(r.ws), r.flags.skip(r.ws), r.clsref.skip(r.NL), P.string(".super").skip(r.ws), r.clsref.skip(r.NL), r.interface.many(), r.clsitem.many(), P.string(".end").skip(r.ws).skip(P.string("class")).skip(r.NL), ( versionOpt, _, flags, className, __, superClass, interfaces, items ) => ({ version: versionOpt.length > 0 ? versionOpt[0] : null, flags, className, superClass, interfaces, items }) ).desc("class_def"), // interface Parser interface: (r) => P.seqMap( P.string(".implements").skip(r.ws), r.clsref.skip(r.NL), (_, interfaceName) => interfaceName ).desc("interface"), // clsitem Parser clsitem: (r) => P.alt( P.seqMap( P.string(".bootstrap").skip(r.ws), r.BSREF.skip(r.ws).skip(P.string("=")).skip(r.ws), r.ref_or_tagged_bootstrap.skip(r.NL), (_, bsref, bootstrap) => ({ type: "bootstrap", bsref, bootstrap }) ), P.seqMap( P.string(".const").skip(r.ws), r.REF.skip(r.ws).skip(P.string("=")).skip(r.ws), r.ref_or_tagged_const.skip(r.NL), (_, ref, constValue) => ({ type: "const", ref, constValue }) ), P.seqMap(r.field, r.NL, (field, _) => ({ type: "field", field })), P.seqMap(r.method, r.NL, (method, _) => ({ type: "method", method })), P.seqMap(r.attribute, r.NL, (attribute, _) => ({ type: "attribute", attribute })) ).desc("clsitem"), // field Parser field: (r) => P.seqMap( P.string(".field").skip(r.ws), r.flags.skip(r.ws), r.utfref.skip(r.ws), r.utfref, P.seq(P.string("=").skip(r.ws), r.ldc_rhs).atMost(1), r.fieldattrs.atMost(1), (_, flags, name, descriptor, valueOpt, attrsOpt) => ({ flags, name, descriptor, value: valueOpt.length > 0 ? valueOpt[0][1] : null, attrs: attrsOpt.length > 0 ? attrsOpt[0] : null }) ).desc("field"), // fieldattrs Parser fieldattrs: (r) => P.seqMap( P.string(".fieldattributes").skip(r.ws).skip(r.NL), r.attribute.skip(r.NL).many(), P.string(".end").skip(r.ws).skip(P.string("fieldattributes")), (_, attributes, __) => ({ attributes }) ).desc("fieldattrs"), // method Parser method: (r) => P.seqMap( P.string(".method").skip(r.ws), r.flags.skip(r.ws), r.utfref.skip(r.ws).skip(P.string(":")).skip(r.ws), r.utfref.skip(r.NL), r.attribute.skip(r.NL).many(), P.string(".end").skip(r.ws).skip(P.string("method")), (_, flags, name, descriptor, attributes, __) => ({ flags, name, descriptor, attributes }) ).desc("method"), // attribute Parser attribute: (r) => P.alt( P.seqMap( P.string(".attribute").skip(r.ws), r.utfref.skip(r.ws), P.seq(P.string("length").skip(r.ws), r.u32.skip(r.ws)).atMost(1), r.STRING_LITERAL, (_, name, lengthOpt, value) => ({ name, length: lengthOpt.length > 0 ? lengthOpt[0][1] : null, value }) ), P.seqMap( P.string(".attribute").skip(r.ws), r.utfref.skip(r.ws), P.seq(P.string("length").skip(r.ws), r.u32.skip(r.ws)).atMost(1), r.attrbody, (_, name, lengthOpt, body) => ({ name, length: lengthOpt.length > 0 ? lengthOpt[0][1] : null, body }) ), r.attrbody // Assuming attrbody can appear on its own ).desc("attribute") }); }31:T5ef3,{ var test = tape.createHarness(); var str = ""; test.createStream({ objectMode: false }).on("data", function (row) { str += row + "\n"; // for example console.log(row); }); var t = test("Parser tests", (t) => { t.test("WORD Parser Tests", (t) => { const wordParser = Lang.WORD; t.test("parses a valid WORD starting with a letter", (t) => { const input = "myVariable"; const result = wordParser.tryParse(input); t.equal(result, "myVariable"); t.end(); }); t.test("parses a valid WORD starting with an underscore", (t) => { const input = "_privateVar"; const result = wordParser.tryParse(input); t.equal(result, "_privateVar"); t.end(); }); t.test("parses a valid WORD starting with a dollar sign", (t) => { const input = "$special"; const result = wordParser.tryParse(input); t.equal(result, "$special"); t.end(); }); t.test("parses a valid WORD starting with a parenthesis", (t) => { const input = "(init)"; const result = wordParser.tryParse(input); t.equal(result, "(init)"); t.end(); }); t.test("parses a valid WORD starting with a less than sign", (t) => { const input = ""; const result = wordParser.tryParse(input); t.equal(result, ""); t.end(); }); t.test( "parses a valid WORD starting with [ followed by an uppercase letter", (t) => { const input = "[Ljava/lang/String;"; const result = wordParser.tryParse(input); t.equal(result, "[Ljava/lang/String;"); t.end(); } ); t.test( "parses a valid WORD starting with [ followed by another [", (t) => { const input = "[[I"; const result = wordParser.tryParse(input); t.equal(result, "[[I"); t.end(); } ); t.test( "fails to parse a WORD starting with [ followed by a lowercase letter", (t) => { const input = "[myRef]"; try { wordParser.tryParse(input); t.fail("Should have thrown an error"); } catch (e) { t.pass("Successfully threw an error for invalid WORD"); } t.end(); } ); t.test( "fails to parse a WORD starting with [ followed by a digit", (t) => { const input = "[123]"; try { wordParser.tryParse(input); t.fail("Should have thrown an error"); } catch (e) { t.pass("Successfully threw an error for invalid WORD"); } t.end(); } ); }); t.test("REF Parser Tests", (t) => { const refParser = Lang.REF; t.test("parses a valid REF", (t) => { const input = "[my_ref]"; const result = refParser.tryParse(input); t.equal(result, "[my_ref]"); t.end(); }); t.end(); }); t.test("BSREF Parser Tests", (t) => { const bsrefParser = Lang.BSREF; t.test("parses a valid BSREF", (t) => { const input = "[bs:bootstrap_ref]"; const result = bsrefParser.tryParse(input); t.equal(result, "[bs:bootstrap_ref]"); t.end(); }); t.end(); }); t.test("LABEL_DEF Parser Tests", (t) => { const labelDefParser = Lang.LABEL_DEF; t.test("parses a valid LABEL_DEF", (t) => { const input = "L1:"; const result = labelDefParser.tryParse(input); t.equal(result, "L1:"); t.end(); }); t.end(); }); t.test("STRING_LITERAL Parser Tests", (t) => { const stringLiteralParser = Lang.STRING_LITERAL; t.test("parses a double-quoted string literal", (t) => { const input = '"Hello World!"'; const result = stringLiteralParser.tryParse(input); t.equal(result, '"Hello World!"'); t.end(); }); t.test("parses a single-quoted string literal", (t) => { const input = "'Hello World!'"; const result = stringLiteralParser.tryParse(input); t.equal(result, "'Hello World!'"); t.end(); }); t.test("parses a raw byte string literal", (t) => { const input = 'b"raw\\x00bytes"'; const result = stringLiteralParser.tryParse(input); t.equal(result, 'b"raw\\x00bytes"'); t.end(); }); t.end(); }); t.test("INT_LITERAL Parser Tests", (t) => { const intLiteralParser = Lang.INT_LITERAL; t.test("parses a decimal integer", (t) => { const input = "123"; const result = intLiteralParser.tryParse(input); t.equal(result, "123"); t.end(); }); t.test("parses a hexadecimal integer", (t) => { const input = "0xcafe"; const result = intLiteralParser.tryParse(input); t.equal(result, "0xcafe"); t.end(); }); t.test("parses a negative integer", (t) => { const input = "-42"; const result = intLiteralParser.tryParse(input); t.equal(result, "-42"); t.end(); }); t.end(); }); t.test("DOUBLE_LITERAL Parser Tests", (t) => { const doubleLiteralParser = Lang.DOUBLE_LITERAL; t.test("parses positive Infinity", (t) => { const input = "+Infinity"; const result = doubleLiteralParser.tryParse(input); t.equal(result, "+Infinity"); t.end(); }); t.test("parses negative Infinity", (t) => { const input = "-Infinity"; const result = doubleLiteralParser.tryParse(input); t.equal(result, "-Infinity"); t.end(); }); t.test("parses positive NaN with specific binary representation", (t) => { const input = "+NaN<0x7ff0123456789abc>"; const result = doubleLiteralParser.tryParse(input); t.equal(result, "+NaN<0x7ff0123456789abc>"); t.end(); }); t.test("parses decimal double", (t) => { const input = "3.14159"; const result = doubleLiteralParser.tryParse(input); t.equal(result, "3.14159"); t.end(); }); t.test("fails to parse NaN with incorrect hex digit count", (t) => { const input = "-NaN<0x123456789abc>"; // Only 13 digits instead of 16 try { doubleLiteralParser.tryParse(input); t.fail("Should have thrown an error"); } catch (e) { t.pass("Successfully threw an error for invalid NaN hex digits"); } t.end(); }); t.end(); }); t.test("LONG_LITERAL Parser Tests", (t) => { const longLiteralParser = Lang.LONG_LITERAL; t.test("parses a decimal long integer", (t) => { const input = "123L"; const result = longLiteralParser.tryParse(input); t.equal(result, "123L"); t.end(); }); t.test("parses a hexadecimal long integer", (t) => { const input = "-0x1afL"; const result = longLiteralParser.tryParse(input); t.equal(result, "-0x1afL"); t.end(); }); t.end(); }); t.test("FLOAT_LITERAL Parser Tests", (t) => { const floatLiteralParser = Lang.FLOAT_LITERAL; t.test("parses a decimal float with 'f' suffix", (t) => { const input = "3.14f"; const result = floatLiteralParser.tryParse(input); t.equal(result, "3.14f"); t.end(); }); t.test("parses a float with exponent and 'f' suffix", (t) => { const input = "-1.0e-5f"; const result = floatLiteralParser.tryParse(input); t.equal(result, "-1.0e-5f"); t.end(); }); t.test("parses positive Infinity with 'f' suffix", (t) => { const input = "+Infinityf"; const result = floatLiteralParser.tryParse(input); t.equal(result, "+Infinityf"); t.end(); }); t.test("parses negative NaN with specific binary representation", (t) => { const input = "-NaN<0xFFABCDEF>f"; const result = floatLiteralParser.tryParse(input); t.equal(result, "-NaN<0xFFABCDEF>f"); t.end(); }); t.test("fails to parse NaN with incorrect hex digit count", (t) => { const input = "+NaN<0xABCDEF>f"; // Only 6 digits instead of 8 try { floatLiteralParser.tryParse(input); t.fail("Should have thrown an error"); } catch (e) { t.pass("Successfully threw an error for invalid NaN hex digits"); } t.end(); }); t.end(); }); t.test("STRING_LITERAL Parser Tests", (t) => { const stringLiteralParser = Lang.STRING_LITERAL; t.test("parses a string literal with escape sequences", (t) => { const input = '"Hello\\nWorld\\t!"'; const result = stringLiteralParser.tryParse(input); t.equal(result, '"Hello\\nWorld\\t!"'); t.end(); }); t.test("parses a string literal with Unicode escape sequences", (t) => { const input = '"Unicode char: \\u263A"'; const result = stringLiteralParser.tryParse(input); t.equal(result, '"Unicode char: \\u263A"'); t.end(); }); t.test("parses a string literal with 32-bit Unicode escape", (t) => { const input = '"Unicode char: \\U0001F600"'; const result = stringLiteralParser.tryParse(input); t.equal(result, '"Unicode char: \\U0001F600"'); t.end(); }); t.test("parses a raw byte string with byte escape", (t) => { const input = 'b"Raw bytes: \\xFF\\x00"'; const result = stringLiteralParser.tryParse(input); t.equal(result, 'b"Raw bytes: \\xFF\\x00"'); t.end(); }); t.test("fails to parse string with invalid escape sequence", (t) => { const input = '"Invalid escape: \\z"'; try { stringLiteralParser.tryParse(input); t.fail("Should have thrown an error"); } catch (e) { t.pass("Successfully threw an error for invalid escape sequence"); } t.end(); }); t.end(); }); t.test("lbl Parser Tests", (t) => { const lblParser = Lang.lbl; t.test("parses a valid lbl", (t) => { const input = "Label1"; const result = lblParser.tryParse(input); t.equal(result, "Label1"); t.end(); }); t.test("fails to parse an invalid lbl", (t) => { const input = "label1"; try { lblParser.tryParse(input); t.fail("Should have thrown an error"); } catch (e) { t.pass("Successfully threw an error for invalid labels"); } t.end(); }); t.end(); }); t.test("Code Item Parser", (t) => { const codeItemParser = Lang.code_item; t.test("parses an instruction line without a label", (t) => { const input = `ldc "Hello World!"`; const result = codeItemParser.tryParse(input); t.deepEqual(result, { op: "ldc", arg: '"Hello World!"' }); t.end(); }); t.test("parses an instruction line with a label", (t) => { const input = `L1: goto L2`; const result = codeItemParser.tryParse(input); t.deepEqual(result, { labelDef: "L1:", instruction: { op: "goto", arg: "L2" } }); t.end(); }); t.test("parses a label without an instruction", (t) => { const input = `LEND:`; const result = codeItemParser.tryParse(input); t.deepEqual(result, { labelDef: "LEND:", instruction: null }); t.end(); }); t.test("parses a code directive", (t) => { const input = `.catch java/lang/Exception from L1 to L2 using L3`; const result = codeItemParser.tryParse(input); t.deepEqual(result, { type: "catch", clsref: "java/lang/Exception", fromLbl: "L1", toLbl: "L2", usingLbl: "L3" }); t.end(); }); }); t.test("Code Attribute Parser", (t) => { const codeAttrParser = Lang.code_attr; t.test("parses a basic code attribute", (t) => { const input = `stack 13 locals 13 getstatic Field java/lang/System out Ljava/io/PrintStream; .end code`; const result = codeAttrParser.tryParse(input); t.deepEqual(result, { long: false, stackSize: "13", localsSize: "13", codeItems: [ { op: "getstatic", arg: [ "Field", "java/lang/System", ["out", "Ljava/io/PrintStream;"] ] } ], attributes: [] }); t.end(); }); }); t.test("Parses .linenumbertable attribute", (t) => { // Define the input string for the linenumbertable const lineNumberTableInput = `.linenumbertable L0 12 L5 13 L21 15 L28 17 L31 16 L32 18 .end linenumbertable`; // Define the expected JavaScript object output const expectedLineNumberTable = { type: "linenumbertable", // This comes from the outer P.seqMap in attrbody lines: [ { label: "L0", lineNumber: "12" }, { label: "L5", lineNumber: "13" }, { label: "L21", lineNumber: "15" }, { label: "L28", lineNumber: "17" }, { label: "L31", lineNumber: "16" }, { label: "L32", lineNumber: "18" } ] }; try { // Parse the input using the appropriate parser rule. // Since `.linenumbertable` is defined within `attrbody`, we test that. const result = Lang.attrbody.tryParse(lineNumberTableInput); // Perform a deep comparison between the actual result and the expected structure t.deepEqual( result, expectedLineNumberTable, "Parsed linenumbertable structure should match expected" ); } catch (e) { // If parsing unexpectedly fails, report it as a test failure t.fail( `Parser unexpectedly threw an error for .linenumbertable: ${e.message}\n${e.stack}` ); } // End this specific test case t.end(); }); t.test("Parses a complete source file", (t) => { const input = `.version 55 0 .class public super MainApp .super java/lang/Object .method public : ()V .code stack 1 locals 1 L0: aload_0 L1: invokespecial Method java/lang/Object ()V L4: return L5: .linenumbertable L0 1 .end linenumbertable .end code .end method .method public static main : ([Ljava/lang/String;)V .code stack 2 locals 3 L0: new ThingProducer L3: dup L4: invokespecial Method ThingProducer ()V L7: astore_1 L8: aload_1 L9: ldc "MyThing" L11: invokevirtual Method ThingProducer produceThing (Ljava/lang/String;)LThing; L14: astore_2 L15: getstatic Field java/lang/System out Ljava/io/PrintStream; L18: aload_2 L19: invokevirtual Method Thing getName ()Ljava/lang/String; L22: invokedynamic [_8] L27: invokevirtual Method java/io/PrintStream println (Ljava/lang/String;)V L30: return L31: .linenumbertable L0 3 L8 4 L15 5 L30 6 .end linenumbertable .end code .end method .sourcefile "MainApp.java" .innerclasses java/lang/invoke/MethodHandles$Lookup java/lang/invoke/MethodHandles Lookup public static final .end innerclasses ;.bootstrapmethods ;.const [_8] = InvokeDynamic invokeStatic Method java/lang/invoke/StringConcatFactory makeConcatWithConstants (Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;Ljava/lang/String;[Ljava/lang/Object;)Ljava/lang/invoke/CallSite; String "Produced a thing with name: \u0001" : makeConcatWithConstants (Ljava/lang/String;)Ljava/lang/String; .end class `; const expected = { classes: [ { // FIX 1: Version should be an array containing the object version: [{ major: "55", minor: "0" }], flags: ["public", "super"], className: "MainApp", superClass: "java/lang/Object", interfaces: [], items: [ // Method (structure was likely correct) { type: "method", method: { flags: ["public"], name: "", descriptor: "()V", attributes: [ { type: "code", code: { long: false, stackSize: "1", localsSize: "1", codeItems: [ { labelDef: "L0:", instruction: "aload_0" }, { labelDef: "L1:", instruction: { op: "invokespecial", arg: [ "Method", "java/lang/Object", ["", "()V"] ] } }, { labelDef: "L4:", instruction: "return" }, { labelDef: "L5:", instruction: null } ], attributes: [ { type: "linenumbertable", lines: [{ label: "L0", lineNumber: "1" }] } ] } } ] } }, // Method main (structure was likely correct) { type: "method", method: { flags: ["public", "static"], name: "main", descriptor: "([Ljava/lang/String;)V", attributes: [ { type: "code", code: { long: false, stackSize: "2", localsSize: "3", codeItems: [ { labelDef: "L0:", instruction: { op: "new", arg: "ThingProducer" } }, { labelDef: "L3:", instruction: "dup" }, { labelDef: "L4:", instruction: { op: "invokespecial", arg: [ "Method", "ThingProducer", ["", "()V"] ] } }, { labelDef: "L7:", instruction: "astore_1" }, { labelDef: "L8:", instruction: "aload_1" }, { labelDef: "L9:", instruction: { op: "ldc", arg: '"MyThing"' } }, { labelDef: "L11:", instruction: { op: "invokevirtual", arg: [ "Method", "ThingProducer", ["produceThing", "(Ljava/lang/String;)LThing;"] ] } }, { labelDef: "L14:", instruction: "astore_2" }, { labelDef: "L15:", instruction: { op: "getstatic", arg: [ "Field", "java/lang/System", ["out", "Ljava/io/PrintStream;"] ] } }, { labelDef: "L18:", instruction: "aload_2" }, { labelDef: "L19:", instruction: { op: "invokevirtual", arg: [ "Method", "Thing", ["getName", "()Ljava/lang/String;"] ] } }, { labelDef: "L22:", instruction: { op: "invokedynamic", arg: "[_8]" } }, { labelDef: "L27:", instruction: { op: "invokevirtual", arg: [ "Method", "java/io/PrintStream", ["println", "(Ljava/lang/String;)V"] ] } }, { labelDef: "L30:", instruction: "return" }, { labelDef: "L31:", instruction: null } ], attributes: [ { type: "linenumbertable", lines: [ { label: "L0", lineNumber: "3" }, { label: "L8", lineNumber: "4" }, { label: "L15", lineNumber: "5" }, { label: "L30", lineNumber: "6" } ] } ] } } ] } }, // FIX 2: Correct structure for SourceFile attribute { type: "attribute", // From clsitem attribute: { // From r.attribute matching r.attrbody type: "sourcefile", // From attrbody's .sourcefile rule value: '"MainApp.java"' } }, // FIX 2: Correct structure for InnerClasses attribute { type: "attribute", // From clsitem attribute: { // From r.attribute matching r.attrbody type: "innerclasses", // From attrbody's .innerclasses rule classes: [ { innerCls: "java/lang/invoke/MethodHandles$Lookup", outerCls: "java/lang/invoke/MethodHandles", innerName: "Lookup", flags: ["public", "static", "final"] } ] } } ] } ] }; try { const result = Lang.source_file.tryParse(input); t.deepEqual( result, expected, "Parsed source file structure should match expected" ); } catch (e) { t.fail(`Parser unexpectedly threw an error: ${e.message}\n${e.stack}`); // Optional: Log the error details if needed // console.error("Parsing failed:", e); } t.end(); // End this specific test case }); }); var m = new Promise((resolve, reject) => { test.onFinish(() => { console.log("test finished"); resolve(str); }); t.on("error", (_) => { reject(str); }); }); // t.run(); //t.end(); return m; }32:Tc8d,c = Lang.source_file.tryParse(`.version 55 0 .class public super [2] .super [3] .method public [4] : [5] .attribute [6] .code stack 1 locals 1 L0: aload_0 L1: invokespecial [7] L4: return L5: .attribute [8] .linenumbertable L0 1 .end linenumbertable .end code .end method .method public static [9] : [10] .attribute [6] .code stack 2 locals 3 L0: new [11] L3: dup L4: invokespecial [12] L7: astore_1 L8: aload_1 L9: ldc [1] L11: invokevirtual [13] L14: astore_2 L15: getstatic [14] L18: aload_2 L19: invokevirtual [15] L22: invokedynamic [16] L27: invokevirtual [17] L30: return L31: .attribute [8] .linenumbertable L0 3 L8 4 L15 5 L30 6 .end linenumbertable .end code .end method .attribute [18] .sourcefile [19] .attribute [20] .innerclasses [21] [22] [23] public static final .end innerclasses .attribute [60] .bootstrapmethods .const [1] = String [59] .const [2] = Class [58] .const [3] = Class [57] .const [4] = Utf8 .const [5] = Utf8 ()V .const [6] = Utf8 Code .const [7] = Method [3] [55] .const [8] = Utf8 LineNumberTable .const [9] = Utf8 main .const [10] = Utf8 ([Ljava/lang/String;)V .const [11] = Class [56] .const [12] = Method [11] [55] .const [13] = Method [11] [52] .const [14] = Field [47] [48] .const [15] = Method [42] [43] .const [16] = InvokeDynamic [bs:0] [33] .const [17] = Method [26] [27] .const [18] = Utf8 SourceFile .const [19] = Utf8 "MainApp.java" .const [20] = Utf8 InnerClasses .const [21] = Class [25] .const [22] = Class [24] .const [23] = Utf8 Lookup .const [24] = Utf8 java/lang/invoke/MethodHandles .const [25] = Utf8 java/lang/invoke/MethodHandles$Lookup .const [26] = Class [30] .const [27] = NameAndType [28] [29] .const [28] = Utf8 println .const [29] = Utf8 (Ljava/lang/String;)V .const [30] = Utf8 java/io/PrintStream .const [31] = MethodHandle invokeStatic [37] .const [32] = String [36] .const [33] = NameAndType [34] [35] .const [34] = Utf8 makeConcatWithConstants .const [35] = Utf8 (Ljava/lang/String;)Ljava/lang/String; .const [36] = Utf8 "Produced a thing with name: \u0001" .const [37] = Method [38] [39] .const [38] = Class [41] .const [39] = NameAndType [34] [40] .const [40] = Utf8 (Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;Ljava/lang/String;[Ljava/lang/Object;)Ljava/lang/invoke/CallSite; .const [41] = Utf8 java/lang/invoke/StringConcatFactory .const [42] = Class [46] .const [43] = NameAndType [44] [45] .const [44] = Utf8 getName .const [45] = Utf8 ()Ljava/lang/String; .const [46] = Utf8 Thing .const [47] = Class [51] .const [48] = NameAndType [49] [50] .const [49] = Utf8 out .const [50] = Utf8 Ljava/io/PrintStream; .const [51] = Utf8 java/lang/System .const [52] = NameAndType [53] [54] .const [53] = Utf8 produceThing .const [54] = Utf8 (Ljava/lang/String;)LThing; .const [55] = NameAndType [4] [5] .const [56] = Utf8 ThingProducer .const [57] = Utf8 java/lang/Object .const [58] = Utf8 MainApp .const [59] = Utf8 MyThing .const [60] = Utf8 BootstrapMethods .bootstrap [bs:0] = Bootstrap [31] [32] : .end class `)33:[] 2e:{"title":"Krakatau parser","cells":[{"id":0,"value":"# Krakatau parser","pinned":false,"hidden":false,"mode":"md"},{"id":6,"value":"P = import(\"https://esm.sh/parsimmon\").then((_) => _.default)","pinned":true,"hidden":false,"mode":"ojs"},{"id":14,"value":"tape = await import(\"https://esm.sh/gh/Kreijstal/tap-js\").then((_) => _.default)","pinned":true,"hidden":false,"mode":"ojs"},{"id":4,"value":"$30","pinned":false,"hidden":false,"mode":"ojs"},{"id":359,"value":"tape","pinned":true,"hidden":false,"mode":"ojs"},{"id":12,"value":"$31","pinned":false,"hidden":false,"mode":"ojs"},{"id":241,"value":"Lang.instruction.tryParse(\n `invokeinterface InterfaceMethod org/apache/lucene/analysis/tokenattributes/TermAttribute term ()Ljava/lang/String; 1`\n)","pinned":true,"hidden":false,"mode":"ojs"},{"id":232,"value":"P.seq(\n P.string(\".linenumbertable\").skip(Lang.ws),\n P.seqMap(\n Lang.lbl.skip(Lang.ws),\n Lang.u16.skip(Lang.NL),\n (label, lineNumber) => ({\n label,\n lineNumber\n })\n )\n).tryParse(`.linenumbertable L0 12\n`)","pinned":true,"hidden":false,"mode":"ojs"},{"id":176,"value":"P.seqMap(\n P.string(\".linenumbertable\").skip(Lang.ws),\n Lang.NL.atMost(1),\n P.seqMap(\n Lang.lbl.skip(Lang.ws),\n Lang.u16.skip(Lang.NL),\n (label, lineNumber) => ({\n label,\n lineNumber\n })\n ).many(),\n P.string(\".end\").skip(Lang.ws).skip(P.string(\"linenumbertable\")),\n (_, ___, lines, __) => ({ type: \"linenumbertable\", lines })\n).tryParse(`.linenumbertable\n L0 12\n L5 13\n L21 15\n L28 17\n L31 16\n L32 18\n .end linenumbertable`)","pinned":true,"hidden":false,"mode":"ojs"},{"id":288,"value":"console.log(JSON.stringify(c, null, 1))","pinned":true,"hidden":false,"mode":"ojs"},{"id":306,"value":"P.seq(\n P.string(\".innerclasses\").skip(Lang.NL),\n P.seq(\n Lang.clsref.skip(Lang.ws),\n Lang.clsref.skip(Lang.ws),\n Lang.utfref.skip(Lang.ws)\n ).many()\n //P.string(\".end\").skip(Lang.ws).skip(P.string(\"innerclasses\"))\n).tryParse(`.innerclasses\n java/lang/invoke/MethodHandles$Lookup java/lang/invoke/MethodHandles Lookup public static final`) /* .end innerclasse*/","pinned":true,"hidden":false,"mode":"ojs"},{"id":318,"value":"Lang.flags.tryParse(`public static enum`)","pinned":true,"hidden":false,"mode":"ojs"},{"id":93,"value":"$32","pinned":true,"hidden":false,"mode":"ojs"},{"id":369,"value":"JSON.stringify(c, null, 1)","pinned":true,"hidden":false,"mode":"ojs"}],"files":"$W33","stdlib":"1","titling":"auto"}