Merge pull request #7 from JonathanxD/feature/reuse-locals

Added ability to reuse local variables, fixes #6#

Author: JonathanxD

build.gradle

@@ -18,13 +18,13 @@ buildscript {
 }
 
 group 'com.github.jonathanxd'
-version '3.0.2-e'
+version '3.0.3'
 
 apply from: project(":CodeAPI").file("gradle/common.gradle")
 
 dependencies {
     compile project(":CodeAPI")
-    compile 'com.github.JonathanxD:BytecodeDisassembler:2.0.2'
+    compile 'com.github.JonathanxD:BytecodeDisassembler:2.0.3-c2'
     compile group: 'org.ow2.asm', name: 'asm-all', version: '5.1'
     testCompile project(path: ':CodeAPI', configuration: 'tests')
 }

src/main/kotlin/com/github/jonathanxd/codeapi/bytecode/BytecodeClass.kt

@@ -30,7 +30,7 @@ package com.github.jonathanxd.codeapi.bytecode
 import com.github.jonathanxd.bytecodedisassembler.Disassembler
 import com.github.jonathanxd.codeapi.base.TypeDeclaration
 
-class BytecodeClass(val type: TypeDeclaration, private val bytecode_: ByteArray) {
+class BytecodeClass constructor(val type: TypeDeclaration, private val bytecode_: ByteArray) {
 
     val disassembledCode: String by lazy {
         Disassembler.disassemble(bytes = this.bytecode, hash = true)

src/main/kotlin/com/github/jonathanxd/codeapi/bytecode/common/Frame.kt

@@ -0,0 +1,213 @@
+/*
+ *      CodeAPI-BytecodeWriter - Framework to generate Java code and Bytecode code. <https://github.com/JonathanxD/CodeAPI-BytecodeWriter>
+ *
+ *         The MIT License (MIT)
+ *
+ *      Copyright (c) 2017 TheRealBuggy/JonathanxD (https://github.com/JonathanxD/ & https://github.com/TheRealBuggy/) <[email protected]>
+ *      Copyright (c) contributors
+ *
+ *
+ *      Permission is hereby granted, free of charge, to any person obtaining a copy
+ *      of this software and associated documentation files (the "Software"), to deal
+ *      in the Software without restriction, including without limitation the rights
+ *      to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *      copies of the Software, and to permit persons to whom the Software is
+ *      furnished to do so, subject to the following conditions:
+ *
+ *      The above copyright notice and this permission notice shall be included in
+ *      all copies or substantial portions of the Software.
+ *
+ *      THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *      IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *      FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *      AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *      LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *      OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ *      THE SOFTWARE.
+ */
+package com.github.jonathanxd.codeapi.bytecode.common
+
+import com.github.jonathanxd.codeapi.type.CodeType
+import org.objectweb.asm.Label
+import java.util.*
+
+/**
+ * Jvm Frame, this frame contains all variables of parent frame and store variables of current frame.
+ */
+internal class Frame(val parent: Frame? = null, variables: List<Variable> = emptyList(), val endLabel: Label? = null) {
+
+    private val variables: MutableList<Variable> = (parent?.immutableVariableList.orEmpty() + variables).toMutableList()
+    val immutableVariableList: List<Variable> = Collections.unmodifiableList(this.variables)
+
+    /**
+     * Get variable at stack pos `i`.
+     *
+     * @param i Index in the stack.
+     * @return Variable or [Optional.empty] if not present.
+     */
+    fun getVar(i: Int): Variable? {
+        if (i < 0 || i >= this.variables.size)
+            return null
+
+        return this.variables[i]
+    }
+
+    /**
+     * Get a variable by name.
+     *
+     * @param name Name of the variable.
+     * @return Variable or `null` if not present.
+     */
+    fun getVarByName(name: String): Variable? {
+        return this.variables.find { `var` -> `var`.name == name }
+    }
+
+    /**
+     * Get a variable by name and type.
+     *
+     * @param name Name of the variable.
+     * @param type Type of the variable.
+     * @return Variable or `null` if not present.
+     */
+    fun getVar(name: String, type: CodeType?): Variable? {
+        if (type == null) {
+            return this.getVarByName(name)
+        }
+
+        return this.variables.find { `var` -> `var`.name == name && `var`.type.compareTo(type) == 0 }
+    }
+
+    /**
+     * Gets the position of a variable instance
+     *
+     * @param variable Variable instance
+     * @return Position of variable if exists, or [OptionalInt.empty] otherwise.
+     */
+    fun getVarPos(variable: Variable): OptionalInt {
+        for (i in this.variables.indices.reversed()) {
+            if (this.variables[i] == variable)
+                return OptionalInt.of(i)
+        }
+
+        return OptionalInt.empty()
+    }
+
+    /**
+     * Add variable
+     */
+    fun add(variable: Variable) {
+        this.variables.add(variable)
+    }
+
+    /**
+     * Store a variable in stack "table".
+     *
+     * @param name       Name of variable
+     * @param type       Type of variable
+     * @param startLabel Start label (first occurrence of variable).
+     * @param endLabel   End label (last usage of variable).
+     * @return [OptionalInt] holding the position, or empty if failed to store.
+     * @throws RuntimeException if variable is already defined.
+     */
+    fun storeVar(name: String, type: CodeType, startLabel: Label, endLabel: Label?): OptionalInt {
+        val variable = Variable(name, type, startLabel, endLabel ?: this.endLabel)
+
+        for (i in this.variables.indices.reversed()) {
+            val variable1 = this.variables[i]
+
+            if (variable1 == variable) {
+                if (variable1.isTemp) {
+                    throw RuntimeException("Cannot store variable named '$name'. Variable already stored!")
+                }
+
+                return OptionalInt.of(i)
+            }
+        }
+
+        this.variables.add(variable)
+        // ? Last index with synchronized method is good!!!
+        return this.getVarPos(variable)
+    }
+
+    /**
+     * Store a internal variable. (internal variables doesn't have their names generated in
+     * LocalVariableTable).
+     *
+     * Name generation could also be avoided using '#' symbol in the variable name.
+     *
+     * Position of internal variables couldn't be getted by [.storeVar].
+     *
+     * Internal variables could be freely redefined and has no restrictions about the redefinition.
+     *
+     * @param name       Name of variable
+     * @param type       Type of variable
+     * @param startLabel Start label (first occurrence of variable).
+     * @param endLabel   End label (last usage of variable).
+     * @return [OptionalInt] holding the position, or empty if failed to store.
+     */
+    fun storeInternalVar(name: String, type: CodeType, startLabel: Label, endLabel: Label?): OptionalInt {
+        val variable = Variable(name, type, startLabel, endLabel ?: this.endLabel, true)
+
+        for (i in variables.indices.reversed()) {
+            if (this.variables[i] == variable) {
+                return OptionalInt.of(i)
+            }
+        }
+
+        this.variables.add(variable)
+        // ? Last index with synchronized method is good!!!
+        return this.getVarPos(variable)
+    }
+
+    /**
+     * Redefine a variable in a `position`.
+     *
+     * @param pos        Position of variable in stack map.
+     * @param name       Name of variable
+     * @param type       Type of variable
+     * @param startLabel Start label (first occurrence of variable).
+     * @param endLabel   End label (last usage of variable).
+     */
+    fun redefineVar(pos: Int, name: String, type: CodeType, startLabel: Label, endLabel: Label?) {
+        val variable = Variable(name, type, startLabel, endLabel)
+
+        if (pos >= this.variables.size) {
+            this.variables.add(pos, variable)
+        } else {
+            if (this.variables[pos].isTemp) {
+                throw RuntimeException("Cannot store variable named '$name'. Variable already stored!")
+            }
+
+            this.variables[pos] = variable
+        }
+    }
+
+    /**
+     * Return last position in stack map.
+     *
+     * @return Last position in stack map.
+     */
+    fun currentPos(): Int {
+        return this.variables.size - 1
+    }
+
+    /**
+     * Create a unique name of variable based on [base] name.
+     */
+    fun getUniqueVariableName(base: String): String {
+        if (!hasVar(base))
+            return base
+
+        var finalName = base
+        var i = 0
+
+        do {
+            finalName += i
+            ++i
+        } while (hasVar(finalName))
+
+        return finalName
+    }
+
+    fun hasVar(varName: String) = this.variables.any { it.name == varName }
+}