Merge branch 'master' of github.com:MightyPirates/OpenComputers into MC1.7

Conflicts:
	src/main/scala/li/cil/oc/client/Proxy.scala

src/main/resources/assets/opencomputers/lua/kernel.lua

@@ -348,7 +348,9 @@ function wrapSingleUserdata(data)
   -- without the need of metamethods like __eq, as well as proper reference
   -- behavior after saving and loading again.
   for k, v in pairs(wrappedUserdata) do
-    if v == data then
+    -- We need a custom 'equals' check for userdata because metamethods on
+    -- userdata introduced by JNLua tend to crash the game for some reason.
+    if userdata.equal(v, data) then
       return k
     end
   end

src/main/resources/reference.conf

@@ -171,6 +171,11 @@ opencomputers {
       # always be erased when the computer is completely powered off, even if
       # it crashed. This setting is purely for software-triggered reboots.
       eraseTmpOnReboot: false
+
+      # Forces the use of the LuaJ fallback instead of the native libraries.
+      # Use this if you have (unfounded) concerns using native libraries or
+      # experience issues with the native library. Also used for debugging.
+      forceLuaJ: false
   }
 
   # Robot related settings, what they may do and general balancing.

src/main/scala/li/cil/oc/Settings.scala

@@ -50,6 +50,7 @@ class Settings(config: Config) {
   val allowBytecode = config.getBoolean("computer.allowBytecode")
   val logLuaCallbackErrors = config.getBoolean("computer.logCallbackErrors")
   val eraseTmpOnReboot = config.getBoolean("computer.eraseTmpOnReboot")
+  val forceLuaJ = config.getBoolean("computer.forceLuaJ")
 
   // ----------------------------------------------------------------------- //
   // robot

src/main/scala/li/cil/oc/client/Proxy.scala

@@ -6,7 +6,7 @@ import cpw.mods.fml.common.FMLCommonHandler
 import cpw.mods.fml.common.network.NetworkRegistry
 import li.cil.oc.client
 import li.cil.oc.client.renderer.block.BlockRenderer
-import li.cil.oc.client.renderer.item.UpgradeRenderer
+import li.cil.oc.client.renderer.item.{FloppyRenderer, UpgradeRenderer}
 import li.cil.oc.client.renderer.tileentity._
 import li.cil.oc.client.renderer.WirelessNetworkDebugRenderer
 import li.cil.oc.common.{Proxy => CommonProxy, tileentity}
@@ -45,6 +45,7 @@ private[oc] class Proxy extends CommonProxy {
     ClientRegistry.bindTileEntitySpecialRenderer(classOf[tileentity.Screen], ScreenRenderer)
 
     MinecraftForgeClient.registerItemRenderer(Items.multi, UpgradeRenderer)
+    MinecraftForgeClient.registerItemRenderer(Items.multi, FloppyRenderer)
 
     OpenComputers.channel.register(client.PacketHandler)
 

src/main/scala/li/cil/oc/client/renderer/item/FloppyRenderer.scala

@@ -0,0 +1,50 @@
+package li.cil.oc.client.renderer.item
+
+import li.cil.oc.{Settings, api}
+import net.minecraftforge.client.IItemRenderer
+import net.minecraftforge.client.IItemRenderer.{ItemRendererHelper, ItemRenderType}
+import net.minecraft.item.ItemStack
+import net.minecraft.client.Minecraft
+import net.minecraft.client.renderer.entity.{RenderItem, RenderManager}
+import net.minecraft.client.gui.ScaledResolution
+import org.lwjgl.opengl.GL11
+import scala.collection.convert.WrapAsScala._
+import net.minecraft.util.EnumChatFormatting
+
+object FloppyRenderer extends IItemRenderer {
+  val renderItem = new RenderItem()
+  renderItem.setRenderManager(RenderManager.instance)
+
+  override def handleRenderType(stack: ItemStack, renderType: ItemRenderType) = renderType == ItemRenderType.INVENTORY && {
+    val descriptor = api.Items.get(stack)
+    descriptor == api.Items.get("floppy") ||
+      descriptor == api.Items.get("lootDisk") ||
+      descriptor == api.Items.get("openOS")
+  }
+
+  override def shouldUseRenderHelper(renderType: ItemRenderType, stack: ItemStack, helper: ItemRendererHelper) = false
+
+  override def renderItem(renderType: ItemRenderType, stack: ItemStack, data: AnyRef*) {
+    val mc = Minecraft.getMinecraft
+    renderItem.renderItemIntoGUI(null, mc.getTextureManager, stack, 0, 0)
+    val res = new ScaledResolution(mc.gameSettings, mc.displayWidth, mc.displayHeight)
+    val fontRenderer = renderItem.getFontRendererFromRenderManager
+    if (fontRenderer != null && res.getScaleFactor > 1) {
+      GL11.glPushMatrix()
+      GL11.glTranslatef(4f + 2f / res.getScaleFactor, 9f + 2f / res.getScaleFactor, 0)
+      GL11.glScalef(1f / res.getScaleFactor, 1f / res.getScaleFactor, 1f)
+      val maxLength = (res.getScaleFactor * 7.5).toInt
+      val label =
+        if (stack.hasTagCompound && stack.getTagCompound.hasKey(Settings.namespace + "data") && stack.getTagCompound.getCompoundTag(Settings.namespace + "data").hasKey(Settings.namespace + "fs.label")) {
+          stack.getTagCompound.getCompoundTag(Settings.namespace + "data").getString(Settings.namespace + "fs.label")
+        }
+        else "disk"
+      val lines = fontRenderer.listFormattedStringToWidth(EnumChatFormatting.getTextWithoutFormattingCodes(label), maxLength).take(math.max(1, res.getScaleFactor / 2))
+      for (line <- lines) {
+        fontRenderer.drawString(line.asInstanceOf[String], 0, 0, 0)
+        GL11.glTranslatef(0, fontRenderer.FONT_HEIGHT, 0)
+      }
+      GL11.glPopMatrix()
+    }
+  }
+}

src/main/scala/li/cil/oc/common/Proxy.scala

@@ -42,7 +42,7 @@ class Proxy {
     api.Items.instance = Items
     api.Machine.instance = machine.Machine
     api.Machine.LuaArchitecture =
-      if (LuaStateFactory.isAvailable) classOf[NativeLuaArchitecture]
+      if (LuaStateFactory.isAvailable && !Settings.get.forceLuaJ) classOf[NativeLuaArchitecture]
       else classOf[LuaJLuaArchitecture]
     api.Network.instance = network.Network
 

src/main/scala/li/cil/oc/server/component/machine/LuaJLuaArchitecture.scala

@@ -25,11 +25,14 @@ class LuaJLuaArchitecture(val machine: api.machine.Machine) extends Architecture
 
   private[machine] var memory = 0
 
+  private[machine] var bootAddress = ""
+
   private val apis = Array(
     new ComponentAPI(this),
     new ComputerAPI(this),
     new OSAPI(this),
     new SystemAPI(this),
+    new UnicodeAPI(this),
     new UserdataAPI(this))
 
   private[machine] def invoke(f: () => Array[AnyRef]): Varargs = try {
@@ -158,16 +161,18 @@ class LuaJLuaArchitecture(val machine: api.machine.Machine) extends Architecture
       // The kernel thread returned. If it threw we'd be in the catch below.
       else {
         // We're expecting the result of a pcall, if anything, so boolean + (result | string).
-        if (results.`type`(2) != LuaValue.TBOOLEAN || !(results.isstring(3) || results.isnil(3))) {
+        if (results.`type`(2) != LuaValue.TBOOLEAN || !(results.isstring(3) || results.isnoneornil(3))) {
           OpenComputers.log.warning("Kernel returned unexpected results.")
         }
         // The pcall *should* never return normally... but check for it nonetheless.
-        if (results.toboolean(1)) {
+        if (results.toboolean(2)) {
           OpenComputers.log.warning("Kernel stopped unexpectedly.")
           new ExecutionResult.Shutdown(false)
         }
         else {
-          val error = results.tojstring(3)
+          val error =
+            if (results.isuserdata(3)) results.touserdata(3).toString
+            else results.tojstring(3)
           if (error != null) new ExecutionResult.Error(error)
           else new ExecutionResult.Error("unknown error")
         }
@@ -219,6 +224,8 @@ class LuaJLuaArchitecture(val machine: api.machine.Machine) extends Architecture
   // ----------------------------------------------------------------------- //
 
   override def load(nbt: NBTTagCompound) {
+    bootAddress = nbt.getString("bootAddress")
+
     if (machine.isRunning) {
       machine.stop()
       machine.start()
@@ -226,5 +233,8 @@ class LuaJLuaArchitecture(val machine: api.machine.Machine) extends Architecture
   }
 
   override def save(nbt: NBTTagCompound) {
+    if (bootAddress != null) {
+      nbt.setString("bootAddress", bootAddress)
+    }
   }
 }

src/main/scala/li/cil/oc/server/component/machine/NativeLuaArchitecture.scala

@@ -241,7 +241,7 @@ class NativeLuaArchitecture(val machine: api.machine.Machine) extends Architectu
       else {
         assert(lua.isThread(1))
         // We're expecting the result of a pcall, if anything, so boolean + (result | string).
-        if (!lua.isBoolean(2) || !(lua.isString(3) || lua.isNil(3))) {
+        if (!lua.isBoolean(2) || !(lua.isString(3) || lua.isNoneOrNil(3))) {
           OpenComputers.log.warning("Kernel returned unexpected results.")
         }
         // The pcall *should* never return normally... but check for it nonetheless.
@@ -251,7 +251,9 @@ class NativeLuaArchitecture(val machine: api.machine.Machine) extends Architectu
         }
         else {
           lua.setTotalMemory(Int.MaxValue)
-          val error = lua.toString(3)
+          val error =
+            if (lua.isJavaObjectRaw(3)) lua.toJavaObjectRaw(3).toString
+            else lua.toString(3)
           if (error != null) new ExecutionResult.Error(error)
           else new ExecutionResult.Error("unknown error")
         }
@@ -314,6 +316,8 @@ class NativeLuaArchitecture(val machine: api.machine.Machine) extends Architectu
   private def state = machine.asInstanceOf[Machine].state
 
   override def load(nbt: NBTTagCompound) {
+    bootAddress = nbt.getString("bootAddress")
+
     // Unlimit memory use while unpersisting.
     lua.setTotalMemory(Integer.MAX_VALUE)
 
@@ -364,6 +368,10 @@ class NativeLuaArchitecture(val machine: api.machine.Machine) extends Architectu
   }
 
   override def save(nbt: NBTTagCompound) {
+    if (bootAddress != null) {
+      nbt.setString("bootAddress", bootAddress)
+    }
+
     // Unlimit memory while persisting.
     lua.setTotalMemory(Integer.MAX_VALUE)
 

src/main/scala/li/cil/oc/server/component/machine/luac/UserdataAPI.scala

@@ -103,6 +103,14 @@ class UserdataAPI(owner: NativeLuaArchitecture) extends NativeLuaAPI(owner) {
     })
     lua.setField(-2, "doc")
 
+    lua.pushScalaFunction(lua => {
+      val value1 = lua.toJavaObjectRaw(1)
+      val value2 = lua.toJavaObjectRaw(2)
+      lua.pushBoolean(value1.isInstanceOf[Value] && value2.isInstanceOf[Value] && value1 == value2)
+      1
+    })
+    lua.setField(-2, "equal")
+
     lua.setGlobal("userdata")
   }
 }

src/main/scala/li/cil/oc/server/component/machine/luaj/ComputerAPI.scala

@@ -27,6 +27,18 @@ class ComputerAPI(owner: LuaJLuaArchitecture) extends LuaJAPI(owner) {
       case _ => LuaValue.NIL
     })
 
+    // Get/set address of boot device.
+    computer.set("getBootAddress", (_: Varargs) => owner.bootAddress match {
+      case "" => LuaValue.NIL
+      case address => LuaValue.valueOf(address)
+    })
+
+    computer.set("setBootAddress", (args: Varargs) => {
+      if (args.isnoneornil(1)) owner.bootAddress = ""
+      else owner.bootAddress = args.checkjstring(1)
+      LuaValue.NIL
+    })
+
     computer.set("freeMemory", (_: Varargs) => LuaValue.valueOf(owner.memory / 2))
 
     computer.set("totalMemory", (_: Varargs) => LuaValue.valueOf(owner.memory))

src/main/scala/li/cil/oc/server/component/machine/luaj/SystemAPI.scala

@@ -13,7 +13,7 @@ class SystemAPI(owner: LuaJLuaArchitecture) extends LuaJAPI(owner) {
     system.set("allowBytecode", (_: Varargs) => LuaValue.valueOf(Settings.get.allowBytecode))
 
     // How long programs may run without yielding before we stop them.
-    system.set("timeout", LuaValue.valueOf(Settings.get.timeout))
+    system.set("timeout", (_: Varargs) => LuaValue.valueOf(Settings.get.timeout))
 
     lua.set("system", system)
   }

src/main/scala/li/cil/oc/server/component/machine/luaj/UserdataAPI.scala

@@ -59,6 +59,12 @@ class UserdataAPI(owner: LuaJLuaArchitecture) extends LuaJAPI(owner) {
       owner.documentation(() => machine.documentation(value, method))
     })
 
+    userdata.set("equal", (args: Varargs) => {
+      val value1 = args.checkuserdata(1, classOf[Value])
+      val value2 = args.checkuserdata(2, classOf[Value])
+      LuaValue.valueOf(value1.isInstanceOf[Value] && value2.isInstanceOf[Value] && value1 == value2)
+    })
+
     lua.set("userdata", userdata)
   }
 }

src/main/scala/li/cil/oc/util/ScalaClosure.scala

@@ -8,6 +8,7 @@ import scala.collection.mutable
 import scala.language.implicitConversions
 import scala.math.ScalaNumber
 import scala.runtime.BoxedUnit
+import li.cil.oc.api.machine.Value
 
 class ScalaClosure(val f: (Varargs) => Varargs) extends VarArgFunction {
   override def invoke(args: Varargs) = f(args)
@@ -41,6 +42,7 @@ object ScalaClosure {
       case value: java.lang.String => LuaValue.valueOf(value)
       case value: Array[Byte] => LuaValue.valueOf(value)
       case value: Array[_] => toLuaList(value)
+      case value: Value => LuaValue.userdataOf(value)
       case value: Product => toLuaList(value.productIterator.toIterable)
       case value: Seq[_] => toLuaList(value)
       case value: java.util.Map[_, _] => toLuaTable(value.toMap)