1 files changed, 0 insertions, 247 deletions
diff --git a/src/compiler/scala/tools/nsc/backend/icode/Primitives.scala b/src/compiler/scala/tools/nsc/backend/icode/Primitives.scala
deleted file mode 100644
index dd930ba52f..0000000000
--- a/src/compiler/scala/tools/nsc/backend/icode/Primitives.scala
+++ /dev/null
@@ -1,247 +0,0 @@
-/* NSC -- new scala compiler
- * Copyright 2005-2013 LAMP/EPFL
- * @author  Martin Odersky
- */
-
-
-package scala.tools.nsc
-package backend
-package icode
-
-import java.io.PrintWriter
-
-trait Primitives { self: ICodes =>
-
-  /** This class represents a primitive operation. */
-  class Primitive {
-  }
-
-
-  // type : (type) => type
-  // range: type <- { BOOL, Ix, Ux, Rx }
-  // jvm  : {i, l, f, d}neg
-  case class Negation(kind: TypeKind) extends Primitive
-
-  // type : zero ? (type) => BOOL : (type,type) => BOOL
-  // range: type <- { BOOL, Ix, Ux, Rx, REF }
-  // jvm  : if{eq, ne, lt, ge, le, gt}, if{null, nonnull}
-  //        if_icmp{eq, ne, lt, ge, le, gt}, if_acmp{eq,ne}
-  case class Test(op: TestOp, kind: TypeKind,  zero: Boolean)  extends Primitive
-
-  // type : (type,type) => I4
-  // range: type <- { Ix, Ux, Rx }
-  // jvm  : lcmp, {f, d}cmp{l, g}
-  case class Comparison(op: ComparisonOp, kind: TypeKind) extends Primitive
-
-  // type : (type,type) => type
-  // range: type <- { Ix, Ux, Rx }
-  // jvm  : {i, l, f, d}{add, sub, mul, div, rem}
-  case class Arithmetic(op: ArithmeticOp, kind: TypeKind) extends Primitive
-
-  // type : (type,type) => type
-  // range: type <- { BOOL, Ix, Ux }
-  // jvm  : {i, l}{and, or, xor}
-  case class Logical(op: LogicalOp, kind: TypeKind) extends Primitive
-
-  // type : (type,I4) => type
-  // range: type <- { Ix, Ux }
-  // jvm  : {i, l}{shl, ushl, shr}
-  case class Shift(op: ShiftOp, kind: TypeKind) extends Primitive
-
-  // type : (src) => dst
-  // range: src,dst <- { Ix, Ux, Rx }
-  // jvm  : i2{l, f, d}, l2{i, f, d}, f2{i, l, d}, d2{i, l, f}, i2{b, c, s}
-  case class Conversion(src: TypeKind, dst: TypeKind) extends Primitive
-
-  // type : (Array[REF]) => I4
-  // range: type <- { BOOL, Ix, Ux, Rx, REF }
-  // jvm  : arraylength
-  case class ArrayLength(kind: TypeKind) extends Primitive
-
-  // type : (buf,el) => buf
-  // range: lf,rg <- { BOOL, Ix, Ux, Rx, REF, STR }
-  // jvm  : It should call the appropriate 'append' method on StringBuffer
-  case class StringConcat(el: TypeKind) extends Primitive
-
-  /** Signals the beginning of a series of concatenations.
-   *  On the JVM platform, it should create a new StringBuffer
-   */
-  case object StartConcat extends Primitive
-
-  /**
-   * type: (buf) => STR
-   * jvm : It should turn the StringBuffer into a String.
-   */
-  case object EndConcat extends Primitive
-
-  /** Pretty printer for primitives */
-  class PrimitivePrinter(out: PrintWriter) {
-    def print(s: String): PrimitivePrinter = {
-      out.print(s)
-      this
-    }
-  }
-
-  /** This class represents a comparison operation. */
-  class ComparisonOp {
-
-    /** Returns a string representation of this operation. */
-    override def toString(): String = this match {
-      case CMPL => "CMPL"
-      case CMP  => "CMP"
-      case CMPG => "CMPG"
-      case _ => throw new RuntimeException("ComparisonOp unknown case")
-    }
-  }
-
-  /** A comparison operation with -1 default for NaNs */
-  case object CMPL extends ComparisonOp
-
-  /** A comparison operation with no default for NaNs */
-  case object CMP extends ComparisonOp
-
-    /** A comparison operation with +1 default for NaNs */
-  case object CMPG extends ComparisonOp
-
-
-  /** This class represents a test operation. */
-  sealed abstract class TestOp {
-
-    /** Returns the negation of this operation. */
-    def negate(): TestOp
-
-    /** Returns a string representation of this operation. */
-    override def toString(): String
-
-    /** used only from GenASM */
-    def opcodeIF(): Int
-
-    /** used only from GenASM */
-    def opcodeIFICMP(): Int
-
-  }
-
-  /** An equality test */
-  case object EQ extends TestOp {
-    def negate() = NE
-    override def toString() = "EQ"
-    override def opcodeIF()     = scala.tools.asm.Opcodes.IFEQ
-    override def opcodeIFICMP() = scala.tools.asm.Opcodes.IF_ICMPEQ
-  }
-
-  /** A non-equality test */
-  case object NE extends TestOp {
-    def negate() = EQ
-    override def toString() = "NE"
-    override def opcodeIF()     = scala.tools.asm.Opcodes.IFNE
-    override def opcodeIFICMP() = scala.tools.asm.Opcodes.IF_ICMPNE
-  }
-
-  /** A less-than test */
-  case object LT extends TestOp {
-    def negate() = GE
-    override def toString() = "LT"
-    override def opcodeIF()     = scala.tools.asm.Opcodes.IFLT
-    override def opcodeIFICMP() = scala.tools.asm.Opcodes.IF_ICMPLT
-  }
-
-  /** A greater-than-or-equal test */
-  case object GE extends TestOp {
-    def negate() = LT
-    override def toString() = "GE"
-    override def opcodeIF()     = scala.tools.asm.Opcodes.IFGE
-    override def opcodeIFICMP() = scala.tools.asm.Opcodes.IF_ICMPGE
-  }
-
-  /** A less-than-or-equal test */
-  case object LE extends TestOp {
-    def negate() = GT
-    override def toString() = "LE"
-    override def opcodeIF()     = scala.tools.asm.Opcodes.IFLE
-    override def opcodeIFICMP() = scala.tools.asm.Opcodes.IF_ICMPLE
-  }
-
-  /** A greater-than test */
-  case object GT extends TestOp {
-    def negate() = LE
-    override def toString() = "GT"
-    override def opcodeIF()     = scala.tools.asm.Opcodes.IFGT
-    override def opcodeIFICMP() = scala.tools.asm.Opcodes.IF_ICMPGT
-  }
-
-  /** This class represents an arithmetic operation. */
-  class ArithmeticOp {
-
-    /** Returns a string representation of this operation. */
-    override def toString(): String = this match {
-      case ADD => "ADD"
-      case SUB => "SUB"
-      case MUL => "MUL"
-      case DIV => "DIV"
-      case REM => "REM"
-      case NOT => "NOT"
-      case _   => throw new RuntimeException("ArithmeticOp unknown case")
-    }
-  }
-
-  /** An arithmetic addition operation */
-  case object ADD extends ArithmeticOp
-
-  /** An arithmetic subtraction operation */
-  case object SUB extends ArithmeticOp
-
-  /** An arithmetic multiplication operation */
-  case object MUL extends ArithmeticOp
-
-  /** An arithmetic division operation */
-  case object DIV extends ArithmeticOp
-
-  /** An arithmetic remainder operation */
-  case object REM extends ArithmeticOp
-
-  /** Bitwise negation. */
-  case object NOT extends ArithmeticOp
-
-  /** This class represents a shift operation. */
-  class ShiftOp {
-
-    /** Returns a string representation of this operation. */
-    override def toString(): String = this match {
-      case LSL =>  "LSL"
-      case ASR =>  "ASR"
-      case LSR =>  "LSR"
-      case _  => throw new RuntimeException("ShiftOp unknown case")
-    }
-  }
-
-  /** A logical shift to the left */
-  case object LSL extends ShiftOp
-
-  /** An arithmetic shift to the right */
-  case object ASR extends ShiftOp
-
-  /** A logical shift to the right */
-  case object LSR extends ShiftOp
-
-  /** This class represents a logical operation. */
-  class LogicalOp {
-
-    /** Returns a string representation of this operation. */
-    override def toString(): String = this match {
-      case AND => "AND"
-      case OR  => "OR"
-      case XOR => "XOR"
-      case _  => throw new RuntimeException("LogicalOp unknown case")
-    }
-  }
-
-  /** A bitwise AND operation */
-  case object AND extends LogicalOp
-
-  /** A bitwise OR operation */
-  case object OR extends LogicalOp
-
-  /** A bitwise XOR operation */
-  case object XOR extends LogicalOp
-}
-