scalaprimitives.scala

来自「JAVA 语言的函数式编程扩展」· SCALA 代码 · 共 647 行 · 第 1/2 页

    addPrimitives(CharClass, nme.MOD, MOD)
    addPrimitives(CharClass, nme.LT, LT)
    addPrimitives(CharClass, nme.LE, LE)
    addPrimitives(CharClass, nme.GT, GT)
    addPrimitives(CharClass, nme.GE, GE)
    addPrimitives(CharClass, nme.XOR, XOR)
    addPrimitives(CharClass, nme.OR, OR)
    addPrimitives(CharClass, nme.AND, AND)
    addPrimitives(CharClass, nme.LSL, LSL)
    addPrimitives(CharClass, nme.LSR, LSR)
    addPrimitives(CharClass, nme.ASR, ASR)
      // conversions
    addPrimitives(CharClass, nme.toByte,   C2B)
    addPrimitives(CharClass, nme.toShort,  C2S)
    addPrimitives(CharClass, nme.toChar,   C2C)
    addPrimitives(CharClass, nme.toInt,    C2I)
    addPrimitives(CharClass, nme.toLong,   C2L)
    // unary methods
    addPrimitives(CharClass, nme.UNARY_+, POS)
    addPrimitives(CharClass, nme.UNARY_-, NEG)
    addPrimitives(CharClass, nme.UNARY_~, NOT)
    if (!forCLDC) {
      addPrimitives(CharClass, nme.toFloat,  C2F)
      addPrimitives(CharClass, nme.toDouble, C2D)
    }

    // scala.Int
    addPrimitives(IntClass, nme.EQ, EQ)
    addPrimitives(IntClass, nme.NE, NE)
    addPrimitives(IntClass, nme.ADD, ADD)
    addPrimitives(IntClass, nme.SUB, SUB)
    addPrimitives(IntClass, nme.MUL, MUL)
    addPrimitives(IntClass, nme.DIV, DIV)
    addPrimitives(IntClass, nme.MOD, MOD)
    addPrimitives(IntClass, nme.LT, LT)
    addPrimitives(IntClass, nme.LE, LE)
    addPrimitives(IntClass, nme.GT, GT)
    addPrimitives(IntClass, nme.GE, GE)
    addPrimitives(IntClass, nme.XOR, XOR)
    addPrimitives(IntClass, nme.OR, OR)
    addPrimitives(IntClass, nme.AND, AND)
    addPrimitives(IntClass, nme.LSL, LSL)
    addPrimitives(IntClass, nme.LSR, LSR)
    addPrimitives(IntClass, nme.ASR, ASR)
      // conversions
    addPrimitives(IntClass, nme.toByte,   I2B)
    addPrimitives(IntClass, nme.toShort,  I2S)
    addPrimitives(IntClass, nme.toChar,   I2C)
    addPrimitives(IntClass, nme.toInt,    I2I)
    addPrimitives(IntClass, nme.toLong,   I2L)
    // unary methods
    addPrimitives(IntClass, nme.UNARY_+, POS)
    addPrimitives(IntClass, nme.UNARY_-, NEG)
    addPrimitives(IntClass, nme.UNARY_~, NOT)
    if (!forCLDC) {
      addPrimitives(IntClass, nme.toFloat,  I2F)
      addPrimitives(IntClass, nme.toDouble, I2D)
    }

    // scala.Long
    addPrimitives(LongClass, nme.EQ, EQ)
    addPrimitives(LongClass, nme.NE, NE)
    addPrimitives(LongClass, nme.ADD, ADD)
    addPrimitives(LongClass, nme.SUB, SUB)
    addPrimitives(LongClass, nme.MUL, MUL)
    addPrimitives(LongClass, nme.DIV, DIV)
    addPrimitives(LongClass, nme.MOD, MOD)
    addPrimitives(LongClass, nme.LT, LT)
    addPrimitives(LongClass, nme.LE, LE)
    addPrimitives(LongClass, nme.GT, GT)
    addPrimitives(LongClass, nme.GE, GE)
    addPrimitives(LongClass, nme.XOR, XOR)
    addPrimitives(LongClass, nme.OR, OR)
    addPrimitives(LongClass, nme.AND, AND)
    addPrimitives(LongClass, nme.LSL, LSL)
    addPrimitives(LongClass, nme.LSR, LSR)
    addPrimitives(LongClass, nme.ASR, ASR)
      // conversions
    addPrimitives(LongClass, nme.toByte,   L2B)
    addPrimitives(LongClass, nme.toShort,  L2S)
    addPrimitives(LongClass, nme.toChar,   L2C)
    addPrimitives(LongClass, nme.toInt,    L2I)
    addPrimitives(LongClass, nme.toLong,   L2L)
    // unary methods
    addPrimitives(LongClass, nme.UNARY_+, POS)
    addPrimitives(LongClass, nme.UNARY_-, NEG)
    addPrimitives(LongClass, nme.UNARY_~, NOT)
    if (!forCLDC) {
      addPrimitives(LongClass, nme.toFloat,  L2F)
      addPrimitives(LongClass, nme.toDouble, L2D)
    }

    if (!forCLDC) {
      // scala.Float
      addPrimitives(FloatClass, nme.EQ, EQ)
      addPrimitives(FloatClass, nme.NE, NE)
      addPrimitives(FloatClass, nme.ADD, ADD)
      addPrimitives(FloatClass, nme.SUB, SUB)
      addPrimitives(FloatClass, nme.MUL, MUL)
      addPrimitives(FloatClass, nme.DIV, DIV)
      addPrimitives(FloatClass, nme.MOD, MOD)
      addPrimitives(FloatClass, nme.LT, LT)
      addPrimitives(FloatClass, nme.LE, LE)
      addPrimitives(FloatClass, nme.GT, GT)
      addPrimitives(FloatClass, nme.GE, GE)
      // conversions
      addPrimitives(FloatClass, nme.toByte,   F2B)
      addPrimitives(FloatClass, nme.toShort,  F2S)
      addPrimitives(FloatClass, nme.toChar,   F2C)
      addPrimitives(FloatClass, nme.toInt,    F2I)
      addPrimitives(FloatClass, nme.toLong,   F2L)
      addPrimitives(FloatClass, nme.toFloat,  F2F)
      addPrimitives(FloatClass, nme.toDouble, F2D)
      // unary methods
      addPrimitives(FloatClass, nme.UNARY_+, POS)
      addPrimitives(FloatClass, nme.UNARY_-, NEG)

      // scala.Double
      addPrimitives(DoubleClass, nme.EQ, EQ)
      addPrimitives(DoubleClass, nme.NE, NE)
      addPrimitives(DoubleClass, nme.ADD, ADD)
      addPrimitives(DoubleClass, nme.SUB, SUB)
      addPrimitives(DoubleClass, nme.MUL, MUL)
      addPrimitives(DoubleClass, nme.DIV, DIV)
      addPrimitives(DoubleClass, nme.MOD, MOD)
      addPrimitives(DoubleClass, nme.LT, LT)
      addPrimitives(DoubleClass, nme.LE, LE)
      addPrimitives(DoubleClass, nme.GT, GT)
      addPrimitives(DoubleClass, nme.GE, GE)
      // conversions
      addPrimitives(DoubleClass, nme.toByte,   D2B)
      addPrimitives(DoubleClass, nme.toShort,  D2S)
      addPrimitives(DoubleClass, nme.toChar,   D2C)
      addPrimitives(DoubleClass, nme.toInt,    D2I)
      addPrimitives(DoubleClass, nme.toLong,   D2L)
      addPrimitives(DoubleClass, nme.toFloat,  D2F)
      addPrimitives(DoubleClass, nme.toDouble, D2D)
      // unary methods
      addPrimitives(DoubleClass, nme.UNARY_+, POS)
      addPrimitives(DoubleClass, nme.UNARY_-, NEG)
    }
    // and the type map!
    initPrimitiveTypeMap
  }

  /** Add a primitive operation to the map */
  def addPrimitive(s: Symbol, code: Int) {
    assert(!(primitives contains s), "Duplicate primitive " + s)
    primitives(s) = code
  }
  
  def addPrimitives(cls: Symbol, method: Name, code: Int) {
    val tpe = cls.info
    val sym = tpe.member(method)
    if (sym == NoSymbol)
      inform("Unknown primitive method " + cls + "." + method)
    for (s <- sym.alternatives)
      addPrimitive(
        s, 
        if (code == ADD && s.info.paramTypes.head == definitions.StringClass.tpe) CONCAT
        else code)
  }

  def isCoercion(code: Int): Boolean = (code >= B2B) && (code <= D2D)

  /** Check whether the given operation code is an array operation. */
  def isArrayOp(code: Int): Boolean =
    isArrayNew(code) | isArrayLength(code) | isArrayGet(code) | isArraySet(code)

  def isArrayNew(code: Int): Boolean = code match {
    case NEW_ZARRAY | NEW_BARRAY | NEW_SARRAY | NEW_CARRAY |
         NEW_IARRAY | NEW_LARRAY | NEW_FARRAY | NEW_DARRAY |
         NEW_OARRAY => true
    case _ => false
  }

  def isArrayLength(code: Int): Boolean = code match {
    case ZARRAY_LENGTH | BARRAY_LENGTH | SARRAY_LENGTH | CARRAY_LENGTH |
         IARRAY_LENGTH | LARRAY_LENGTH | FARRAY_LENGTH | DARRAY_LENGTH |
         OARRAY_LENGTH | LENGTH => true
    case _ => false
  }

  def isArrayGet(code: Int): Boolean = code match {
    case ZARRAY_GET | BARRAY_GET | SARRAY_GET | CARRAY_GET |
         IARRAY_GET | LARRAY_GET | FARRAY_GET | DARRAY_GET |
         OARRAY_GET | APPLY => true
    case _ => false
  }

  def isArraySet(code: Int): Boolean = code match {
    case ZARRAY_SET | BARRAY_SET | SARRAY_SET | CARRAY_SET |
         IARRAY_SET | LARRAY_SET | FARRAY_SET | DARRAY_SET |
         OARRAY_SET | UPDATE => true;
    case _ => false;
  }

  /** Check whether the given code is a comparison operator */
  def isComparisonOp(code: Int): Boolean = code match {
    case ID | NI | EQ | NE |
         LT | LE | GT | GE => true

    case _ => false
  }

  def isArithmeticOp(code: Int): Boolean = code match {
    case POS | NEG | NOT => true; // unary
    case ADD | SUB | MUL | 
         DIV | MOD       => true; // binary
    case OR  | XOR | AND | 
         LSL | LSR | ASR => true; // bitwise
    case _ => false;
  }

  def isLogicalOp(code: Int): Boolean = code match {
    case ZNOT | ZAND | ZOR => true
    case _ => false
  }

  def isShiftOp(code: Int): Boolean = code match {
    case LSL | LSR | ASR => true
    case _ => false
  }

  def isBitwiseOp(code: Int): Boolean = code match {
    case OR | XOR | AND => true
    case _ => false
  }

  /** If code is a coercion primitive, the result type */
  def generatedKind(code: Int): TypeKind = code match {
    case B2B | C2B | S2B | I2B | L2B | F2B | D2B => BYTE
    case B2C | C2C | S2C | I2C | L2C | F2C | D2C => CHAR
    case B2S | C2S | S2S | I2S | L2S | F2S | D2S => SHORT
    case B2I | C2I | S2I | I2I | L2I | F2I | D2I => INT
    case B2L | C2L | S2L | I2L | L2L | F2L | D2L => LONG
    case B2F | C2F | S2F | I2F | L2F | F2F | D2F => FLOAT
    case B2D | C2D | S2D | I2D | L2D | F2D | D2D => DOUBLE
  }
  
  def isPrimitive(sym: Symbol): Boolean = primitives contains sym

  /** Return the code for the givem symbol. */
  def getPrimitive(sym: Symbol): Int = {
    assert(isPrimitive(sym), "Unkown primitive " + sym)
    primitives(sym)
  }

  /** 
   * Return the primitive code of the given operation. If the 
   * operation is an array get/set, we inspect the type of the receiver
   * to demux the operation.
   *
   * @param fun The method symbol
   * @param tpe The type of the receiver object. It is used only for array
   *            operations
   */
  def getPrimitive(fun: Symbol, tpe: Type): Int = {
    import definitions._
    val code = getPrimitive(fun)

    var elem: Type = null
    tpe match {
      case TypeRef(_, sym, _elem :: Nil)
           if (sym == ArrayClass) => elem = _elem
      case _ => ()
    }

    code match {

      case APPLY =>
        toTypeKind(elem) match {
          case BOOL    => ZARRAY_GET
          case BYTE    => BARRAY_GET
          case SHORT   => SARRAY_GET
          case CHAR    => CARRAY_GET
          case INT     => IARRAY_GET
          case LONG    => LARRAY_GET
          case FLOAT   => FARRAY_GET
          case DOUBLE  => DARRAY_GET
          case REFERENCE(_) | ARRAY(_) => OARRAY_GET
          case _ =>
            abort("Unexpected array element type: " + elem)
        }

      case UPDATE =>
        toTypeKind(elem) match {
          case BOOL    => ZARRAY_SET
          case BYTE    => BARRAY_SET
          case SHORT   => SARRAY_SET
          case CHAR    => CARRAY_SET
          case INT     => IARRAY_SET
          case LONG    => LARRAY_SET
          case FLOAT   => FARRAY_SET
          case DOUBLE  => DARRAY_SET
          case REFERENCE(_) | ARRAY(_) => OARRAY_SET
          case _ =>
            abort("Unexpected array element type: " + elem)
        }

      case LENGTH =>
        assert(elem != null)
        toTypeKind(elem) match {
          case BOOL    => ZARRAY_LENGTH
          case BYTE    => BARRAY_LENGTH
          case SHORT   => SARRAY_LENGTH
          case CHAR    => CARRAY_LENGTH
          case INT     => IARRAY_LENGTH
          case LONG    => LARRAY_LENGTH
          case FLOAT   => FARRAY_LENGTH
          case DOUBLE  => DARRAY_LENGTH
          case REFERENCE(_) | ARRAY(_) => OARRAY_LENGTH
          case _ =>
            abort("Unexpected array element type: " + elem)
        }

      case _ =>
        code
    }
  }

}