1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
|
/* __ *\
** ________ ___ / / ___ Scala API **
** / __/ __// _ | / / / _ | (c) 2002-2006, LAMP/EPFL **
** __\ \/ /__/ __ |/ /__/ __ | **
** /____/\___/_/ |_/____/_/ | | **
** |/ **
\* */
// $Id$
package scala.reflect;
object Print extends Function1[Any, String] {
def apply (any: Any): String = {
if (any.isInstanceOf[TypedCode[Any]])
apply(any.asInstanceOf[TypedCode[Any]])
else if (any.isInstanceOf[Code])
apply(any.asInstanceOf[Code])
else if (any.isInstanceOf[Symbol])
apply(any.asInstanceOf[Symbol])
else if (any.isInstanceOf[Type])
apply(any.asInstanceOf[Type])
else "UnknownAny"
}
def apply (typedCode: TypedCode[Any]): String =
Print(typedCode.code);
def apply (code: Code): String = code match {
case reflect.Ident(sym) => Print(sym)
case reflect.Select(qual, sym) => Print(qual) + "." + Print(sym)
case reflect.Literal(value) => value match {
case s:String => "\"" + s + "\""
case _ => value.toString
}
case reflect.Apply(fun, args) => Print(fun) + args.map(Print).mkString("(", ", ", ")")
case reflect.TypeApply(fun, args) => Print(fun) + args.map(Print).mkString("[", ", ", "]")
case reflect.Function(params, body) => params.map(Print).mkString("(", ", ", ")") + " => " + Print(body)
case reflect.This(sym) => Print(sym)
case reflect.Block(stats, expr) => (stats ::: List(expr)).map(Print).mkString("{\n", ";\n", "\n}")
case reflect.New(tpt) => "new " + Print(tpt)
case reflect.If(condition, trueCase, falseCase) => "if (" + Print(condition) + ") " + Print(trueCase) + " else " + Print(falseCase)
case reflect.Assign(destination: Code, source: Code) => Print(destination) + " = " + Print(source)
case reflect.Target(sym, body) => "target " + Print(sym) + " {\n" + Print(body) + "\n}"
case reflect.Goto(target) => "goto " + Print(target)
case _ => "???"
}
def apply (symbol: Symbol): String = symbol match {
case reflect.Class(name) => name.substring(name.lastIndexOf('.')+1)
case reflect.Method(name, datatype) => name.substring(name.lastIndexOf('.')+1) //+ ": " + datatype
case reflect.Field(name, datatype) => name.substring(name.lastIndexOf('.')+1) //+ ": " + datatype
case reflect.TypeField(name, datatype) => name.substring(name.lastIndexOf('.')+1) //+ ": " + datatype
case reflect.LocalValue(owner, name, datatype) => name.substring(name.lastIndexOf('.')+1) //+ ": " + datatype
case reflect.LocalMethod(owner, name, datatype) => name.substring(name.lastIndexOf('.')+1) //+ ": " + datatype
case reflect.NoSymbol => "NoSymbol"
case reflect.RootSymbol => "RootSymbol"
case reflect.LabelSymbol(name) => name
case _ => "???"
}
def apply (datatype: Type): String = datatype match {
case reflect.NoPrefix => "NoPrefix"
case reflect.NoType => "NoType"
case reflect.NamedType(name) => "(named: " + name + ")"
case reflect.PrefixedType(prefix, symbol) => "(" + Print(prefix) + "." + Print(symbol) + ")"
case reflect.SingleType(prefix, symbol) => "(" + Print(prefix) + "." + Print(symbol) + ")"
case reflect.ThisType(clazz) => "(" + Print(clazz) + ".this.type)"
case reflect.AppliedType(datatype, args) => Print(datatype) + args.map(Print).mkString("[", ", ", "]")
case reflect.TypeBounds(lo, hi) => "[" + Print(lo) + " ... " + Print(hi) + "]"
case reflect.MethodType(formals, resultType) => formals.map(Print).mkString("(", ", ", ")") + " => " + Print(resultType)
case reflect.PolyType(typeParams, typeBounds, resultType) =>
(List.map2(typeParams, typeBounds)
((tp, tb) => "[" + Print(tb._1) + " :> " + Print(tp) + " :> " + Print(tb._2) + "]")).
mkString("[", ", ", "]") + " -> " + Print(resultType)
case _ => "???"
}
}
|
