pickler.scala

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

        case name: Name =>
          writeName(name)
          if (name.isTermName) TERMname else TYPEname
        case NoSymbol =>
          NONEsym
        case sym: Symbol if !isLocal(sym) =>
          val tag =
            if (sym.isModuleClass) {
              writeRef(sym.name.toTermName); EXTMODCLASSref
            } else {
              writeRef(sym.name); EXTref
            }
          if (!sym.owner.isRoot) writeRef(sym.owner)
          tag
        case sym: ClassSymbol =>
          val posOffset = writeSymInfo(sym)
          if (sym.thisSym.tpe != sym.tpe) writeRef(sym.typeOfThis)
          CLASSsym + posOffset
        case sym: TypeSymbol =>
          val posOffset = writeSymInfo(sym)
          (if (sym.isAbstractType) TYPEsym else ALIASsym) + posOffset
        case sym: TermSymbol =>
          val posOffset = writeSymInfo(sym)
          if (sym.alias != NoSymbol) writeRef(sym.alias)
          (if (sym.isModule) MODULEsym else VALsym) + posOffset
        case NoType =>
          NOtpe
        case NoPrefix =>
          NOPREFIXtpe
        case ThisType(sym) =>
          writeRef(sym); THIStpe
        case SingleType(pre, sym) =>
          writeRef(pre); writeRef(sym); SINGLEtpe
        case ConstantType(value) =>
          writeRef(value); CONSTANTtpe
        case TypeRef(pre, sym, args) =>
          writeRef(pre); writeRef(sym); writeRefs(args); TYPEREFtpe
        case TypeBounds(lo, hi) =>
          writeRef(lo); writeRef(hi); TYPEBOUNDStpe
        case tp @ RefinedType(parents, decls) =>
          writeRef(tp.typeSymbol); writeRefs(parents); REFINEDtpe
        case ClassInfoType(parents, decls, clazz) =>
          writeRef(clazz); writeRefs(parents); CLASSINFOtpe
        case MethodType(formals, restpe) =>
          writeRef(restpe); writeRefs(formals)
          if (entry.isInstanceOf[ImplicitMethodType]) IMPLICITMETHODtpe
          else METHODtpe
        case PolyType(tparams, restpe) =>
          writeRef(restpe); writeRefs(tparams); POLYtpe
        case ExistentialType(tparams, restpe) =>
          writeRef(restpe); writeRefs(tparams); EXISTENTIALtpe
        case DeBruijnIndex(l, i) =>
          writeNat(l); writeNat(i); DEBRUIJNINDEXtpe
        case c @ Constant(_) =>
          if (c.tag == BooleanTag) writeLong(if (c.booleanValue) 1 else 0)
          else if (ByteTag <= c.tag && c.tag <= LongTag) writeLong(c.longValue)
          else if (c.tag == FloatTag) writeLong(Float.floatToIntBits(c.floatValue))
          else if (c.tag == DoubleTag) writeLong(Double.doubleToLongBits(c.doubleValue))
          else if (c.tag == StringTag) writeRef(newTermName(c.stringValue))
          else if (c.tag == ClassTag) writeRef(c.typeValue)
          LITERAL + c.tag
        case AnnotatedType(attribs, tp, selfsym) => 
	  if (settings.selfInAnnots.value) {
	    writeRef(tp)
	    writeRef(selfsym)
	    writeRefs(attribs)
	    ANNOTATEDWSELFtpe
	  } else {
            writeRef(tp)
            writeRefs(attribs)
            ANNOTATEDtpe
	  }
        case (target: Symbol, attr @ AnnotationInfo(atp, args, assocs)) =>
          writeRef(target)
          writeRef(atp)
          for (c <- args) writeRef(c)
          for ((name, c) <- assocs) { writeRef(name); writeRef(c) }
          ATTRIBUTE
        case (target: Symbol, children: List[_]) =>
          writeRef(target)
          for (c <- children) writeRef(c.asInstanceOf[Symbol])
          CHILDREN

	case EmptyTree =>
	  writeNat(EMPTYtree)
	  TREE

	case tree@PackageDef(name, stats) =>
	  writeNat(PACKAGEtree)
	  writeRef(tree.tpe)
	  writeRef(tree.symbol)
	  writeRef(tree.mods)
	  writeRef(name)
          writeRefs(stats)
	  TREE

	case tree@ClassDef(mods, name, tparams, impl) =>
	  writeNat(CLASStree)
	  writeRef(tree.tpe)
	  writeRef(tree.symbol)
	  writeRef(mods)
	  writeRef(name)
          writeRef(impl)
	  writeRefs(tparams)
	  TREE
	  
	case tree@ModuleDef(mods, name, impl) =>
	  writeNat(MODULEtree)
	  writeRef(tree.tpe)
	  writeRef(tree.symbol)
	  writeRef(mods)
	  writeRef(name)
	  writeRef(impl)
	  TREE
  
	case tree@ValDef(mods, name, tpt, rhs) =>
          writeNat(VALDEFtree)
	  writeRef(tree.tpe)
	  writeRef(tree.symbol)
	  writeRef(mods)
	  writeRef(name)
	  writeRef(tpt)
	  writeRef(rhs)
	  TREE

	
	case tree@DefDef(mods, name, tparams, vparamss, tpt, rhs) =>
          writeNat(DEFDEFtree)
	  writeRef(tree.tpe)
	  writeRef(tree.symbol)
	  writeRef(mods)
	  writeRef(name)
	  writeNat(tparams.length)
	  writeRefs(tparams)
	  writeNat(vparamss.length)
	  for(vparams <- vparamss) {
	    writeNat(vparams.length)
	    writeRefs(vparams)
	  }
	  writeRef(tpt)
	  writeRef(rhs)
	  TREE
  

	case tree@TypeDef(mods, name, tparams, rhs) =>
	  writeNat(TYPEDEFtree)
	  writeRef(tree.tpe)
	  writeRef(tree.symbol)
	  writeRef(mods)
	  writeRef(name)
	  writeRef(rhs)
	  writeRefs(tparams)
	  TREE


	case tree@LabelDef(name, params, rhs) =>
	  writeNat(LABELtree)
	  writeRef(tree.tpe)
	  writeRef(tree.symbol)
	  writeRef(rhs)
	  writeRefs(params)
	  TREE


	case tree@Import(expr, selectors) =>
	  writeNat(IMPORTtree)
	  writeRef(tree.tpe)
	  writeRef(tree.symbol)
	  writeRef(expr)
	  for ((from, to) <- selectors) {
	    writeRef(from)
	    writeRef(to)
	  }
	  TREE


	case tree@Annotation(constr, elements) =>                            
	  writeNat(ANNOTATIONtree)
	  writeRef(tree.tpe)
	  writeRef(constr)
	  writeRefs(elements)
	  TREE

	case tree@DocDef(comment, definition) =>
          writeNat(DOCDEFtree)
	  writeRef(tree.tpe)
	  writeRef(Constant(comment))
	  writeRef(definition)
	  TREE

	case tree@Template(parents, self, body) =>
          writeNat(TEMPLATEtree)
	  writeRef(tree.tpe)
          writeRef(tree.symbol)
          writeNat(parents.length)
	  writeRefs(parents)
	  writeRef(self)
	  writeRefs(body)
	  TREE

	case tree@Block(stats, expr) =>
          writeNat(BLOCKtree)
	  writeRef(tree.tpe)
	  writeRef(expr)
	  writeRefs(stats)
	  TREE

	case tree@CaseDef(pat, guard, body) =>
	  writeNat(CASEtree)
	  writeRef(tree.tpe)
	  writeRef(pat)
	  writeRef(guard)
	  writeRef(body)
	  TREE

	case tree@Sequence(trees) =>
          writeNat(SEQUENCEtree)
	  writeRef(tree.tpe)
	  writeRefs(trees)
	  TREE

	case tree@Alternative(trees) =>
	  writeNat(ALTERNATIVEtree)
	  writeRef(tree.tpe)
	  writeRefs(trees)
	  TREE

	case tree@Star(elem) =>
          writeNat(STARtree)
	  writeRef(tree.tpe)
	  writeRef(elem)
	  TREE

	case tree@Bind(name, body) =>
	  writeNat(BINDtree)
	  writeRef(tree.tpe)
	  writeRef(tree.symbol)
	  writeRef(name)
	  writeRef(body)
	  TREE

	case tree@UnApply(fun: Tree, args) =>
	  writeNat(UNAPPLYtree)
	  writeRef(tree.tpe)
	  writeRef(fun)
	  writeRefs(args)
	  TREE

	case tree@ArrayValue(elemtpt, trees) =>
	  writeNat(ARRAYVALUEtree)
	  writeRef(tree.tpe)
	  writeRef(elemtpt)
	  writeRefs(trees)
	  TREE


	case tree@Function(vparams, body) =>
          writeNat(FUNCTIONtree)
	  writeRef(tree.tpe)
	  writeRef(tree.symbol)
	  writeRef(body)
	  writeRefs(vparams)
	  TREE

	case tree@Assign(lhs, rhs) =>
          writeNat(ASSIGNtree)
	  writeRef(tree.tpe)
	  writeRef(lhs)
	  writeRef(rhs)
	  TREE

	case tree@If(cond, thenp, elsep) =>
          writeNat(IFtree)
          writeRef(tree.tpe)
	  writeRef(cond)
	  writeRef(thenp)
	  writeRef(elsep)
	  TREE

	case tree@Match(selector, cases) =>
          writeNat(MATCHtree)
	  writeRef(tree.tpe)
	  writeRef(selector)
	  writeRefs(cases)
	  TREE

	case tree@Return(expr) =>
	  writeNat(RETURNtree)
	  writeRef(tree.tpe)
	  writeRef(tree.symbol)
	  writeRef(expr)
	  TREE

	case tree@Try(block, catches, finalizer) =>
          writeNat(TREtree)
	  writeRef(tree.tpe)
	  writeRef(block)
	  writeRef(finalizer)
	  writeRefs(catches)
	  TREE

	case tree@Throw(expr) =>
	  writeNat(THROWtree)
	  writeRef(tree.tpe)
	  writeRef(expr)
	  TREE

	case tree@New(tpt) =>
	  writeNat(NEWtree)
	  writeRef(tree.tpe)
	  writeRef(tpt)
	  TREE
  
	case tree@Typed(expr, tpt) =>
	  writeNat(TYPEDtree)
	  writeRef(tree.tpe)
	  writeRef(expr)
	  writeRef(tpt)
	  TREE

	case tree@TypeApply(fun, args) =>
	  writeNat(TYPEAPPLYtree)
	  writeRef(tree.tpe)
	  writeRef(fun)
	  writeRefs(args)
	  TREE
	  
	case tree@Apply(fun, args) =>
	  writeNat(APPLYtree)
	  writeRef(tree.tpe)
	  writeRef(fun)
	  writeRefs(args)
	  TREE

	case tree@ApplyDynamic(qual, args) =>
	  writeNat(APPLYDYNAMICtree)
	  writeRef(tree.tpe)
	  writeRef(tree.symbol)
	  writeRef(qual)
	  writeRefs(args)
	  TREE

	case tree@Super(qual, mix) =>
	  writeNat(SUPERtree)
	  writeRef(tree.tpe)
	  writeRef(tree.symbol)
	  writeRef(qual)
	  writeRef(mix)
	  TREE

        case tree@This(qual) =>
	  writeNat(THIStree)
	  writeRef(tree.tpe)
	  writeRef(tree.symbol)
	  writeRef(qual)
	  TREE

        case tree@Select(qualifier, selector) =>
	  writeNat(SELECTtree)
	  writeRef(tree.tpe)
	  writeRef(tree.symbol)
	  writeRef(qualifier)
	  writeRef(selector)
	  TREE

	case tree@Ident(name) =>
	  writeNat(IDENTtree)
	  writeRef(tree.tpe)
	  writeRef(tree.symbol)
	  writeRef(name)
	  TREE

	case tree@Literal(value) =>
	  writeNat(LITERALtree)
	  writeRef(tree.tpe)
	  writeRef(value)
	  TREE

	case tree@TypeTree() =>
	  writeNat(TYPEtree)
	  writeRef(tree.tpe)
	  TREE

	case tree@Annotated(annot, arg) =>
	  writeNat(ANNOTATEDtree)
	  writeRef(tree.tpe)
	  writeRef(annot)
	  writeRef(arg)
	  TREE

	case tree@SingletonTypeTree(ref) =>
	  writeNat(SINGLETONTYPEtree)
	  writeRef(tree.tpe)
	  writeRef(ref)
	  TREE

	case tree@SelectFromTypeTree(qualifier, selector) =>
	  writeNat(SELECTFROMTYPEtree)
	  writeRef(tree.tpe)
	  writeRef(qualifier)
	  writeRef(selector)
	  TREE

	case tree@CompoundTypeTree(templ: Template) =>
	  writeNat(COMPOUNDTYPEtree)
	  writeRef(tree.tpe)
	  writeRef(templ)
	  TREE

	case tree@AppliedTypeTree(tpt, args) =>
	  writeNat(APPLIEDTYPEtree)
	  writeRef(tree.tpe)
	  writeRef(tpt)
	  writeRefs(args)
	  TREE

	case tree@TypeBoundsTree(lo, hi) =>
	  writeNat(TYPEBOUNDStree)
	  writeRef(tree.tpe)
	  writeRef(lo)
	  writeRef(hi)
	  TREE

	case tree@ExistentialTypeTree(tpt, whereClauses) =>
	  writeNat(EXISTENTIALTYPEtree)
	  writeRef(tree.tpe)
	  writeRef(tpt)
	  writeRefs(whereClauses)
	  TREE


	case Modifiers(flags, privateWithin, annotations) =>
	  writeNat((flags >> 32).toInt)
	  writeNat((flags & 0xFFFFFFFF).toInt)
	  writeRef(privateWithin)
          writeRefs(annotations)
	  MODIFIERS

        case AnnotationInfo(atp, args, assocs) =>
          writeRef(atp)
          writeNat(args.length)
          for (arg <- args) writeRef(arg)
          for ((name, arg) <- assocs) {
            writeRef(name);
            writeRef(arg)
          }
          ANNOTINFO

	case arg:AnnotationArgument =>
	  arg.constant match {
	    case Some(c) => writeBody(c)
	    case None => writeBody(arg.intTree)
	  }

        case _ =>
          throw new FatalError("bad entry: " + entry + " " + entry.getClass)
      }
      val startpos = writeIndex
      writeByte(0); writeByte(0)
      patchNat(startpos, writeBody(entry))
      patchNat(startpos + 1, writeIndex - (startpos + 2))
    }

    /** Write byte array */
    def finish {
      assert(writeIndex == 0)
      writeNat(MajorVersion)
      writeNat(MinorVersion)
      writeNat(ep)
      if (settings.debug.value) log("" + ep + " entries")//debug
      for (i <- 0 until ep) writeEntry(entries(i))
      if (settings.Xshowcls.value == rootName.toString) {
        readIndex = 0
        ShowPickled.printFile(this, Console.out)
      }
    }

    override def toString() = "" + rootName + " in " + rootOwner
  }
}