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
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
|
/* __ *\
** ________ ___ / / ___ Scala API **
** / __/ __// _ | / / / _ | (c) 2006-2013, LAMP/EPFL **
** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ **
** /____/\___/_/ |_/____/_/ | | **
** |/ **
\* */
package scala.util.parsing.json
import scala.util.parsing.combinator._
import scala.util.parsing.combinator.syntactical._
import scala.util.parsing.combinator.lexical._
/**
* A marker class for the JSON result types.
*
* @author Derek Chen-Becker <"java"+@+"chen-becker"+"."+"org">
*/
sealed abstract class JSONType {
/**
* This version of toString allows you to provide your own value
* formatter.
*/
def toString (formatter : JSONFormat.ValueFormatter) : String
/**
* Returns a String representation of this JSON value
* using the JSONFormat.defaultFormatter.
*/
override def toString = toString(JSONFormat.defaultFormatter)
}
/**
* This object defines functions that are used when converting JSONType
* values into String representations. Mostly this is concerned with
* proper quoting of strings.
*
* @author Derek Chen-Becker <"java"+@+"chen-becker"+"."+"org">
*/
object JSONFormat {
/**
* This type defines a function that can be used to
* format values into JSON format.
*/
type ValueFormatter = Any => String
/**
* The default formatter used by the library. You can
* provide your own with the toString calls on
* JSONObject and JSONArray instances.
*/
val defaultFormatter : ValueFormatter = (x : Any) => x match {
case s : String => "\"" + quoteString(s) + "\""
case jo : JSONObject => jo.toString(defaultFormatter)
case ja : JSONArray => ja.toString(defaultFormatter)
case other => other.toString
}
/**
* This function can be used to properly quote Strings
* for JSON output.
*/
def quoteString (s : String) : String =
s.map {
case '"' => "\\\""
case '\\' => "\\\\"
case '/' => "\\/"
case '\b' => "\\b"
case '\f' => "\\f"
case '\n' => "\\n"
case '\r' => "\\r"
case '\t' => "\\t"
/* We'll unicode escape any control characters. These include:
* 0x0 -> 0x1f : ASCII Control (C0 Control Codes)
* 0x7f : ASCII DELETE
* 0x80 -> 0x9f : C1 Control Codes
*
* Per RFC4627, section 2.5, we're not technically required to
* encode the C1 codes, but we do to be safe.
*/
case c if ((c >= '\u0000' && c <= '\u001f') || (c >= '\u007f' && c <= '\u009f')) => "\\u%04x".format(c: Int)
case c => c
}.mkString
}
/**
* Represents a JSON Object (map).
*
* @author Derek Chen-Becker <"java"+@+"chen-becker"+"."+"org">
*/
case class JSONObject (obj : Map[String,Any]) extends JSONType {
def toString (formatter : JSONFormat.ValueFormatter) =
"{" + obj.map({ case (k,v) => formatter(k.toString) + " : " + formatter(v) }).mkString(", ") + "}"
}
/**
* Represents a JSON Array (list).
* @author Derek Chen-Becker <"java"+@+"chen-becker"+"."+"org">
*/
case class JSONArray (list : List[Any]) extends JSONType {
def toString (formatter : JSONFormat.ValueFormatter) =
"[" + list.map(formatter).mkString(", ") + "]"
}
/**
* The main JSON Parser.
*
* @author Derek Chen-Becker <"java"+@+"chen-becker"+"."+"org">
*/
class Parser extends StdTokenParsers with ImplicitConversions {
// Fill in abstract defs
type Tokens = Lexer
val lexical = new Tokens
// Configure lexical parsing
lexical.reserved ++= List("true", "false", "null")
lexical.delimiters ++= List("{", "}", "[", "]", ":", ",")
/** Type signature for functions that can parse numeric literals */
type NumericParser = String => Any
// Global default number parsing function
protected var defaultNumberParser : NumericParser = {_.toDouble}
// Per-thread default number parsing function
protected val numberParser = new ThreadLocal[NumericParser]() {
override def initialValue() = defaultNumberParser
}
// Define the grammar
def root = jsonObj | jsonArray
def jsonObj = "{" ~> repsep(objEntry, ",") <~ "}" ^^ { case vals : List[_] => JSONObject(Map(vals : _*)) }
def jsonArray = "[" ~> repsep(value, ",") <~ "]" ^^ { case vals : List[_] => JSONArray(vals) }
def objEntry = stringVal ~ (":" ~> value) ^^ { case x ~ y => (x, y) }
def value: Parser[Any] = (jsonObj | jsonArray | number | "true" ^^^ true | "false" ^^^ false | "null" ^^^ null | stringVal)
def stringVal = accept("string", { case lexical.StringLit(n) => n} )
def number = accept("number", { case lexical.NumericLit(n) => numberParser.get.apply(n)} )
}
|
