From 3b5256aedddd36832a319157b4665c9a7daad862 Mon Sep 17 00:00:00 2001 From: Algent Date: Thu, 3 Sep 2026 09:26:11 +0200 Subject: [PATCH] refactor: port StackAnalyser control flow to Java --- JAVA_MIGRATION.md | 27 ++ JAVA_MIGRATION_HANDOFF.md | 40 +- .../multipart/asm/StackAnalyser.scala | 184 +-------- .../multipart/asm/StackAnalyserLogic.java | 350 ++++++++++++++++++ 4 files changed, 417 insertions(+), 184 deletions(-) create mode 100644 src/main/scala/codechicken/multipart/asm/StackAnalyserLogic.java diff --git a/JAVA_MIGRATION.md b/JAVA_MIGRATION.md index 3fc504d..2b6afbc 100644 --- a/JAVA_MIGRATION.md +++ b/JAVA_MIGRATION.md @@ -1378,3 +1378,30 @@ generated-trait compatibility work. Scala-runtime removal remains a later projec Formatting/checkstyle/build and the Forge suite pass; all 39 generated dump hashes and the dev config are unchanged. No production ABI, source counts or next target changed. `multipart/asm/StackAnalyser.scala` remains next, using explicit migration-test authorization and separate characterization and refactor commits. +- Characterized `StackAnalyser` against untouched Scala in 15 plain-JVM tests, committed separately as `a6aca65`. + The baseline build passed 320 JVM tests and the Forge suite passed 122. The new tests exercise receiver/parameter + initialization, narrow/wide slot aliases, partial failures, every duplication opcode, typed constants, case-class + equality/copy/products, instruction provenance, loads/stores/increments, arithmetic/casts, arrays, fields, calls, + branches/switches/returns, handler precedence, unsupported-node behavior and overridable default-argument dispatch. +- Extracted analyser control flow (`setL`, `pop`, `insert`, `popArgs`, `visitInsn`) into package-private Java + `StackAnalyserLogic`. The Scala shell retains construction/state, default-argument bridges, simple accessors and + the complete nested model. An isolated Scala 2.11.5 probe rejects a Java class alongside its same-name Scala + companion; completing the model requires a coordinated class/companion conversion rather than replacing the class + independently. The retained `ScalaSignature` model and its primitive/erased bridges are untouched. +- Preserved current opcode behavior, including wide `DUP2` expansion, int-conversion/comparison/`INSTANCEOF` result + types, reference-array descriptor construction, reversed multidimensional size capture and `NEWARRAY`'s existing + `MatchError`. Virtual calls still use the Scala default-argument getters. No compiler algorithm, optimization or + unrelated bug fix is included. +- Saved the pre-port dev jar, Scala source, test reports and generated dumps under ignored + `run/migration-stack-analyser-reference/`. All 40 named analyser surfaces match by member name, descriptor, + modifiers, generic declarations and private fields; the other 39 named model/companion classfiles are byte-identical, + preserving their serialized and Scala-facing behavior. All 199 retained ASM/generator disassemblies and all 39 + generated dump names/hashes match. An additional one-off comparison of 8,960 opcode/node/stack combinations matches + expression trees, types, aliases, instruction bindings, locals, exceptions and partial mutation. +- Formatting/checkstyle/build and Forge pass, including a clean build after stopping Gradle: 320 JVM / 122 Forge + tests, zero failures/errors/skips. All characterization tests remain unchanged after the port. The forced Scala + compilation version guard is retained, and all five `@Mod` version annotations match both clean packaged jars. + Two unreferenced traversal closures become one Java helper (452 to 451 packaged classes); sources now total 207 + Java files and 9 Scala files / 1,726 nonblank Scala lines. No new compatibility divergence is introduced. Next is + `ASMMixinCompiler.scala`, bounded to `ClassInfo`/`MethodInfo` metadata lookup and traversal, with fresh characterization + before touching its Forge-initialized state and no trait-rewriting algorithm changes. diff --git a/JAVA_MIGRATION_HANDOFF.md b/JAVA_MIGRATION_HANDOFF.md index 1217255..ebd7547 100644 --- a/JAVA_MIGRATION_HANDOFF.md +++ b/JAVA_MIGRATION_HANDOFF.md @@ -12,8 +12,8 @@ what breaks, and what is left. The other documents hold the reasoning. | `JAVA_MIGRATION_MANUAL_CHECKS.md` | What no automated test can cover, and must be checked by hand in a client | | `JAVA_MIGRATION_PROFILE.md` | The focused baseline, first measured result, findings, and exact rerun command | -Branch: `algent/java`. Base: `master`. 172 commits including the API-cleanup plan, divergence-log cleanup, ports -through the `ScalaSignature` parser extraction, and its characterization backfill and review fixes. +Branch: `algent/java`. Base: `master`. 174 commits including the API-cleanup plan, divergence-log cleanup, ports +through the `StackAnalyser` control-flow extraction, and the ASM characterization backfill and review fixes. ## The one rule that matters @@ -74,7 +74,7 @@ awk -F'"' '/ locals.size) locals += null - locals(i) = entry - if (entry.getType.getSize == 2) - locals(i + 1) = entry - } + def setL(i: Int, entry: LocalEntry): Unit = + StackAnalyserLogic.setL(this, i, entry) def push(entry: StackEntry) = insert(0, entry) def _pop(i: Int = 0) = stack.remove(stack.size - i - 1) - def pop(i: Int = 0) = { - val e = _pop(i) - if (e.getType.getSize == 2) { - if (peek(i) != e) - throw new IllegalStateException( - "Wide stack entry elems don't match (" + e + "," + peek(i) - ) - _pop(i) - } - e - } + def pop(i: Int = 0): StackEntry = StackAnalyserLogic.pop(this, i) def peek(i: Int = 0) = stack(stack.size - i - 1) - def insert(i: Int, entry: StackEntry) { - if (entry.getType.getSize == 0) - return - stack.insert(stack.size - i, entry) - if (entry.getType.getSize == 2) - stack.insert(stack.size - i, entry) - } + def insert(i: Int, entry: StackEntry): Unit = + StackAnalyserLogic.insert(this, i, entry) - def popArgs(desc: String) = { - val t = getType(desc) - val args = new Array[StackEntry](t.getArgumentTypes.length) - for (i <- 0 until args.length) - args(args.length - i - 1) = pop() - args - } + def popArgs(desc: String): Array[StackEntry] = + StackAnalyserLogic.popArgs(this, desc) - def visitInsn(ainsn: AbstractInsnNode) { - implicit val thisInsn = ainsn // passes to any StackEntry we create - ainsn match { - case insn: InsnNode => - ainsn.getOpcode match { - case ACONST_NULL => push(Const(null)) - case ICONST_M1 => push(Const(-1)) - case ICONST_0 => push(Const(0)) - case ICONST_1 => push(Const(1)) - case ICONST_2 => push(Const(2)) - case ICONST_3 => push(Const(3)) - case ICONST_4 => push(Const(4)) - case ICONST_5 => push(Const(5)) - case LCONST_0 => push(Const(0L)) - case LCONST_1 => push(Const(1L)) - case FCONST_0 => push(Const(0f)) - case FCONST_1 => push(Const(1f)) - case FCONST_2 => push(Const(2f)) - case DCONST_0 => push(Const(0d)) - case DCONST_1 => push(Const(1d)) - - case i if i >= IALOAD && i <= SALOAD => - push(ArrayLoad(pop(), pop())) - case i if i >= IASTORE && i <= SASTORE => - pop(); pop(); pop() - - case POP => _pop() - case POP2 => _pop(); _pop() - case DUP => push(peek()) - case DUP_X1 => insert(2, peek()) - case DUP_X2 => insert(3, peek()) - case DUP2 => push(peek(1)); push(peek(1)) - case DUP2_X1 => insert(3, peek(1)); insert(3, peek()) - case DUP2_X2 => insert(4, peek(1)); insert(4, peek()) - case SWAP => push(pop(1)) - - case i if i >= IADD && i <= DREM => - push(BinaryOp(i, pop(), pop())) - case i if i >= INEG && i <= DNEG => - push(UnaryOp(i, pop())) - case i if i >= ISHL && i <= LXOR => - push(BinaryOp(i, pop(), pop())) - - case L2I | F2I | D2I => push(PrimitiveCast(pop(), DOUBLE_TYPE)) - case I2L | F2L | D2L => push(PrimitiveCast(pop(), LONG_TYPE)) - case I2F | L2F | D2F => push(PrimitiveCast(pop(), FLOAT_TYPE)) - case I2D | L2D | F2D => push(PrimitiveCast(pop(), DOUBLE_TYPE)) - case I2B => push(PrimitiveCast(pop(), BYTE_TYPE)) - case I2C => push(PrimitiveCast(pop(), CHAR_TYPE)) - case I2S => push(PrimitiveCast(pop(), SHORT_TYPE)) - - case i if i >= LCMP && i <= DCMPG => - push(BinaryOp(i, pop(), pop())) - - case i if i >= IRETURN && i <= ARETURN => pop() - - case ARRAYLENGTH => push(ArrayLength(pop())) - case ATHROW => pop() - case MONITORENTER | MONITOREXIT => pop() - - case _ => - - } - case iinsn: IntInsnNode => - ainsn.getOpcode match { - case BIPUSH => push(Const(iinsn.operand.toByte)) - case SIPUSH => push(Const(iinsn.operand.toShort)) - } - case ldcinsn: LdcInsnNode => - ainsn.getOpcode match { - case LDC => push(Const(ldcinsn.cst)) - } - case vinsn: VarInsnNode => - ainsn.getOpcode match { - case i if i >= ILOAD && i <= ALOAD => - push(Load(locals(vinsn.`var`))) - case i if i >= ISTORE && i <= ASTORE => - setL(vinsn.`var`, Store(pop())) - } - case incinsn: IincInsnNode => - ainsn.getOpcode match { - case IINC => - setL( - incinsn.`var`, - Store( - BinaryOp(IINC, Const(incinsn.incr), Load(locals(incinsn.`var`))) - ) - ) - } - case jinsn: JumpInsnNode => - ainsn.getOpcode match { - case i if i >= IFEQ && i <= IFLE => pop() - case i if i >= IF_ICMPEQ && i <= IF_ACMPNE => pop(); pop() - case JSR => push(ReturnAddress()) - case IFNULL | IFNONNULL => pop() - case GOTO => - } - case sinsn: TableSwitchInsnNode => pop() - case linsn: LookupSwitchInsnNode => pop() - case finsn: FieldInsnNode => - ainsn.getOpcode match { - case GETSTATIC => push(GetField(null, finsn)) - case PUTSTATIC => pop() - case GETFIELD => push(GetField(pop(), finsn)) - case PUTFIELD => pop(); pop() - } - case minsn: MethodInsnNode => - ainsn.getOpcode match { - case INVOKEVIRTUAL | INVOKESPECIAL | INVOKEINTERFACE => - push(Invoke(ainsn.getOpcode, popArgs(minsn.desc), pop(), minsn)) - case INVOKESTATIC => - push(Invoke(ainsn.getOpcode, popArgs(minsn.desc), null, minsn)) - } - case tinsn: TypeInsnNode => - ainsn.getOpcode match { - case NEW => push(New(getObjectType(tinsn.desc))) - case NEWARRAY => push(NewArray(pop(), getObjectType(tinsn.desc))) - case ANEWARRAY => - push(NewArray(pop(), getObjectType("[" + tinsn.desc))) - case CHECKCAST => push(Cast(pop(), getObjectType(tinsn.desc))) - case INSTANCEOF => push(UnaryOp(INSTANCEOF, pop())) - } - case mainsn: MultiANewArrayInsnNode => - val sizes = new Array[StackEntry](mainsn.dims) - for (i <- 0 until sizes.length) - sizes(i) = pop() - push(NewMultiArray(sizes, getType(mainsn.desc))) - /*case fnode:FrameNode => fnode.`type` match - { - case F_NEW|F_FULL => println("reset stacks/locals") - case F_APPEND => println("add local") - case F_CHOP => println("rem locals") - case F_SAME => println("reset") - case F_SAME1 => println("reset locals and all but bottom stack") - }*/ - case lnode: LabelNode => - catchHandlers.get(lnode) match { - case Some(tcblock) => - push(CaughtException(Type.getType(tcblock.`type`))) - case None => - } - case _ => - } - } + def visitInsn(ainsn: AbstractInsnNode): Unit = + StackAnalyserLogic.visitInsn(this, ainsn) } diff --git a/src/main/scala/codechicken/multipart/asm/StackAnalyserLogic.java b/src/main/scala/codechicken/multipart/asm/StackAnalyserLogic.java new file mode 100644 index 0000000..8bac6a9 --- /dev/null +++ b/src/main/scala/codechicken/multipart/asm/StackAnalyserLogic.java @@ -0,0 +1,350 @@ +package codechicken.multipart.asm; + +import static org.objectweb.asm.Opcodes.*; +import static org.objectweb.asm.Type.*; + +import org.objectweb.asm.Type; +import org.objectweb.asm.tree.AbstractInsnNode; +import org.objectweb.asm.tree.FieldInsnNode; +import org.objectweb.asm.tree.IincInsnNode; +import org.objectweb.asm.tree.InsnNode; +import org.objectweb.asm.tree.IntInsnNode; +import org.objectweb.asm.tree.JumpInsnNode; +import org.objectweb.asm.tree.LabelNode; +import org.objectweb.asm.tree.LdcInsnNode; +import org.objectweb.asm.tree.LookupSwitchInsnNode; +import org.objectweb.asm.tree.MethodInsnNode; +import org.objectweb.asm.tree.MultiANewArrayInsnNode; +import org.objectweb.asm.tree.TableSwitchInsnNode; +import org.objectweb.asm.tree.TryCatchBlockNode; +import org.objectweb.asm.tree.TypeInsnNode; +import org.objectweb.asm.tree.VarInsnNode; + +import codechicken.multipart.asm.StackAnalyser.ArrayLength; +import codechicken.multipart.asm.StackAnalyser.ArrayLoad; +import codechicken.multipart.asm.StackAnalyser.BinaryOp; +import codechicken.multipart.asm.StackAnalyser.Cast; +import codechicken.multipart.asm.StackAnalyser.CaughtException; +import codechicken.multipart.asm.StackAnalyser.Const; +import codechicken.multipart.asm.StackAnalyser.GetField; +import codechicken.multipart.asm.StackAnalyser.Invoke; +import codechicken.multipart.asm.StackAnalyser.Load; +import codechicken.multipart.asm.StackAnalyser.LocalEntry; +import codechicken.multipart.asm.StackAnalyser.New; +import codechicken.multipart.asm.StackAnalyser.NewArray; +import codechicken.multipart.asm.StackAnalyser.NewMultiArray; +import codechicken.multipart.asm.StackAnalyser.PrimitiveCast; +import codechicken.multipart.asm.StackAnalyser.ReturnAddress; +import codechicken.multipart.asm.StackAnalyser.StackEntry; +import codechicken.multipart.asm.StackAnalyser.Store; +import codechicken.multipart.asm.StackAnalyser.UnaryOp; +import scala.MatchError; +import scala.None$; +import scala.Option; +import scala.Predef; +import scala.Some; + +/** Analyser control flow behind the retained Scala model and default-argument API. */ +final class StackAnalyserLogic { + + private StackAnalyserLogic() {} + + static void setL(StackAnalyser a, int i, LocalEntry entry) { + while (i + entry.getType().getSize() > a.locals().size()) a.locals().$plus$eq(null); + a.locals().update(i, entry); + if (entry.getType().getSize() == 2) a.locals().update(i + 1, entry); + } + + static StackEntry pop(StackAnalyser a, int i) { + StackEntry entry = a._pop(i); + if (entry.getType().getSize() == 2) { + StackEntry other = a.peek(i); + if (!(other == null ? entry == null : other.equals(entry))) { + throw new IllegalStateException("Wide stack entry elems don't match (" + entry + "," + a.peek(i)); + } + a._pop(i); + } + return entry; + } + + static void insert(StackAnalyser a, int i, StackEntry entry) { + if (entry.getType().getSize() == 0) return; + a.stack().insert(a.stack().size() - i, Predef.wrapRefArray(new StackEntry[] { entry })); + if (entry.getType().getSize() == 2) { + a.stack().insert(a.stack().size() - i, Predef.wrapRefArray(new StackEntry[] { entry })); + } + } + + static StackEntry[] popArgs(StackAnalyser a, String desc) { + StackEntry[] args = new StackEntry[getType(desc).getArgumentTypes().length]; + for (int i = 0; i < args.length; i++) args[args.length - i - 1] = pop(a); + return args; + } + + // These calls must retain virtual dispatch through Scala's default-argument getters. + private static StackEntry pop(StackAnalyser a) { + return a.pop(a.pop$default$1()); + } + + private static StackEntry peek(StackAnalyser a) { + return a.peek(a.peek$default$1()); + } + + private static void rawPop(StackAnalyser a) { + a._pop(a._pop$default$1()); + } + + static void visitInsn(StackAnalyser a, AbstractInsnNode insn) { + if (insn instanceof InsnNode) { + int op = insn.getOpcode(); + switch (op) { + case ACONST_NULL: + a.push(new Const(null, insn)); + break; + case ICONST_M1: + a.push(new Const(-1, insn)); + break; + case ICONST_0: + a.push(new Const(0, insn)); + break; + case ICONST_1: + a.push(new Const(1, insn)); + break; + case ICONST_2: + a.push(new Const(2, insn)); + break; + case ICONST_3: + a.push(new Const(3, insn)); + break; + case ICONST_4: + a.push(new Const(4, insn)); + break; + case ICONST_5: + a.push(new Const(5, insn)); + break; + case LCONST_0: + a.push(new Const(0L, insn)); + break; + case LCONST_1: + a.push(new Const(1L, insn)); + break; + case FCONST_0: + a.push(new Const(0f, insn)); + break; + case FCONST_1: + a.push(new Const(1f, insn)); + break; + case FCONST_2: + a.push(new Const(2f, insn)); + break; + case DCONST_0: + a.push(new Const(0d, insn)); + break; + case DCONST_1: + a.push(new Const(1d, insn)); + break; + case POP: + rawPop(a); + break; + case POP2: + rawPop(a); + rawPop(a); + break; + case DUP: + a.push(peek(a)); + break; + case DUP_X1: + a.insert(2, peek(a)); + break; + case DUP_X2: + a.insert(3, peek(a)); + break; + case DUP2: + a.push(a.peek(1)); + a.push(a.peek(1)); + break; + case DUP2_X1: + a.insert(3, a.peek(1)); + a.insert(3, peek(a)); + break; + case DUP2_X2: + a.insert(4, a.peek(1)); + a.insert(4, peek(a)); + break; + case SWAP: + a.push(a.pop(1)); + break; + // Preserve the reference's inferred types, including conversions to int reporting double. + case L2I: + case F2I: + case D2I: + a.push(new PrimitiveCast(pop(a), DOUBLE_TYPE, insn)); + break; + case I2L: + case F2L: + case D2L: + a.push(new PrimitiveCast(pop(a), LONG_TYPE, insn)); + break; + case I2F: + case L2F: + case D2F: + a.push(new PrimitiveCast(pop(a), FLOAT_TYPE, insn)); + break; + case I2D: + case L2D: + case F2D: + a.push(new PrimitiveCast(pop(a), DOUBLE_TYPE, insn)); + break; + case I2B: + a.push(new PrimitiveCast(pop(a), BYTE_TYPE, insn)); + break; + case I2C: + a.push(new PrimitiveCast(pop(a), CHAR_TYPE, insn)); + break; + case I2S: + a.push(new PrimitiveCast(pop(a), SHORT_TYPE, insn)); + break; + case ARRAYLENGTH: + a.push(new ArrayLength(pop(a), insn)); + break; + case ATHROW: + case MONITORENTER: + case MONITOREXIT: + pop(a); + break; + default: + if (op >= IALOAD && op <= SALOAD) { + a.push(new ArrayLoad(pop(a), pop(a), insn)); + } else if (op >= IASTORE && op <= SASTORE) { + pop(a); + pop(a); + pop(a); + } else if (op >= IADD && op <= DREM || op >= ISHL && op <= LXOR || op >= LCMP && op <= DCMPG) { + a.push(new BinaryOp(op, pop(a), pop(a), insn)); + } else if (op >= INEG && op <= DNEG) { + a.push(new UnaryOp(op, pop(a), insn)); + } else if (op >= IRETURN && op <= ARETURN) { + pop(a); + } + } + } else if (insn instanceof IntInsnNode) { + IntInsnNode intInsn = (IntInsnNode) insn; + switch (insn.getOpcode()) { + case BIPUSH: + a.push(new Const((byte) intInsn.operand, insn)); + break; + case SIPUSH: + a.push(new Const((short) intInsn.operand, insn)); + break; + default: + throw new MatchError(insn.getOpcode()); + } + } else if (insn instanceof LdcInsnNode) { + if (insn.getOpcode() != LDC) throw new MatchError(insn.getOpcode()); + a.push(new Const(((LdcInsnNode) insn).cst, insn)); + } else if (insn instanceof VarInsnNode) { + VarInsnNode varInsn = (VarInsnNode) insn; + int op = insn.getOpcode(); + if (op >= ILOAD && op <= ALOAD) { + a.push(new Load(a.locals().apply(varInsn.var), insn)); + } else if (op >= ISTORE && op <= ASTORE) { + a.setL(varInsn.var, new Store(pop(a), insn)); + } else { + throw new MatchError(op); + } + } else if (insn instanceof IincInsnNode) { + IincInsnNode incInsn = (IincInsnNode) insn; + if (insn.getOpcode() != IINC) throw new MatchError(insn.getOpcode()); + a.setL( + incInsn.var, + new Store( + new BinaryOp( + IINC, + new Const(incInsn.incr, insn), + new Load(a.locals().apply(incInsn.var), insn), + insn), + insn)); + } else if (insn instanceof JumpInsnNode) { + int op = insn.getOpcode(); + if (op >= IFEQ && op <= IFLE || op == IFNULL || op == IFNONNULL) { + pop(a); + } else if (op >= IF_ICMPEQ && op <= IF_ACMPNE) { + pop(a); + pop(a); + } else if (op == JSR) { + a.push(new ReturnAddress(insn)); + } else if (op != GOTO) { + throw new MatchError(op); + } + } else if (insn instanceof TableSwitchInsnNode || insn instanceof LookupSwitchInsnNode) { + pop(a); + } else if (insn instanceof FieldInsnNode) { + FieldInsnNode field = (FieldInsnNode) insn; + switch (insn.getOpcode()) { + case GETSTATIC: + a.push(new GetField(null, field, insn)); + break; + case PUTSTATIC: + pop(a); + break; + case GETFIELD: + a.push(new GetField(pop(a), field, insn)); + break; + case PUTFIELD: + pop(a); + pop(a); + break; + default: + throw new MatchError(insn.getOpcode()); + } + } else if (insn instanceof MethodInsnNode) { + MethodInsnNode method = (MethodInsnNode) insn; + switch (insn.getOpcode()) { + case INVOKEVIRTUAL: + case INVOKESPECIAL: + case INVOKEINTERFACE: + a.push(new Invoke(insn.getOpcode(), a.popArgs(method.desc), pop(a), method, insn)); + break; + case INVOKESTATIC: + a.push(new Invoke(insn.getOpcode(), a.popArgs(method.desc), null, method, insn)); + break; + default: + throw new MatchError(insn.getOpcode()); + } + } else if (insn instanceof TypeInsnNode) { + TypeInsnNode typeInsn = (TypeInsnNode) insn; + switch (insn.getOpcode()) { + case NEW: + a.push(new New(getObjectType(typeInsn.desc), insn)); + break; + case NEWARRAY: + a.push(new NewArray(pop(a), getObjectType(typeInsn.desc), insn)); + break; + case ANEWARRAY: + a.push(new NewArray(pop(a), getObjectType("[" + typeInsn.desc), insn)); + break; + case CHECKCAST: + a.push(new Cast(pop(a), getObjectType(typeInsn.desc), insn)); + break; + case INSTANCEOF: + a.push(new UnaryOp(INSTANCEOF, pop(a), insn)); + break; + default: + throw new MatchError(insn.getOpcode()); + } + } else if (insn instanceof MultiANewArrayInsnNode) { + MultiANewArrayInsnNode multi = (MultiANewArrayInsnNode) insn; + StackEntry[] sizes = new StackEntry[multi.dims]; + for (int i = 0; i < sizes.length; i++) sizes[i] = pop(a); + a.push(new NewMultiArray(sizes, getType(multi.desc), insn)); + } else if (insn instanceof LabelNode) { + Option handler = a.codechicken$multipart$asm$StackAnalyser$$catchHandlers() + .get((LabelNode) insn); + if (handler instanceof Some) { + a.push(new CaughtException(Type.getType(((Some) handler).x().type), insn)); + } else if (!None$.MODULE$.equals(handler)) { + throw new MatchError(handler); + } + } + } +}