diff --git a/src/Token.as b/src/Token.as
index 774b51f..262ae3f 100644
--- a/src/Token.as
+++ b/src/Token.as
@@ -21,10 +21,10 @@ package
private var drag: Drag;
public var posReal: Point;
private var urff: String;
- private var xml: XML;
+ private var json: Object;
private var filewatcher: FileWatcher;
- public function Token(source:BitmapData, urff: String, x: int, y: int, xml:XML = null)
+ public function Token(source:BitmapData, urff: String, x: int, y: int, json: Object = null)
{
this.posReal = new Point(x, y);
super(x, y, new Image(source));
@@ -32,14 +32,15 @@ package
this.layer = WorldStage.LAYER_TOKENS;
this.drag = null;
this.urff = urff;
- if (xml === null)
- this.xml = XML("");
+
+ if (json === null)
+ this.json = { };
else
- this.xml = xml;
+ this.json = json;
}
public function FDirty():Boolean
{
- return int(xml.@x) !== posReal.x || int(xml.@y) !== posReal.y;
+ return json.x !== posReal.x || json.y !== posReal.y;
}
public function FSelected(): Boolean
{
@@ -139,15 +140,12 @@ package
if (FSelected())
Draw.hitbox(this);
}
-
- public function GenXML(): XML
+ public function GenJSON(): Object
{
- var xml: XML = this.xml.copy();
- xml.@x = int(posReal.x);
- xml.@y = int(posReal.y);
- xml.@path = urff;
- this.xml = xml;
- return xml;
+ this.json.x = int(posReal.x);
+ this.json.y = int(posReal.y);
+ this.json.path = urff;
+ return this.json;
}
}
diff --git a/src/WorldMenu.as b/src/WorldMenu.as
index 36f99df..793756b 100644
--- a/src/WorldMenu.as
+++ b/src/WorldMenu.as
@@ -65,11 +65,11 @@ package
}
public function OpenStage(): void
{
- FileForBrowse().browseForOpen("Find your thing", [new FileFilter("Stages", "*.xml")]);
+ FileForBrowse().browseForOpen("Find your thing", [new FileFilter("Stages", "*.stage")]);
}
private function FileForBrowse(): File
{
- var file: File = new File(File.userDirectory.nativePath + File.separator + "NewStage.xml");
+ var file: File = new File(File.userDirectory.nativePath + File.separator + "NewStage.stage");
file.addEventListener(Event.SELECT, function():void {
FP.world = new WorldStage(file.url, function():World { return new WorldMenu(); });
});
diff --git a/src/WorldStage.as b/src/WorldStage.as
index 05092ac..ea8030a 100644
--- a/src/WorldStage.as
+++ b/src/WorldStage.as
@@ -42,6 +42,7 @@ package
import net.flashpunk.utils.Key;
import net.flashpunk.World;
import net.flashpunk.utils.Input;
+ import com.adobe.serialization.json.JSON;
/**
* ...
* @author jjp
@@ -355,12 +356,12 @@ package
zoom = 1;
}
- // persistence (save/load/XML generation)
+ // persistence (save/load/json generation)
public function Save(): void
{
var stream: FileStream = new FileStream();
stream.open(new File(UabFromUrf(urff)), FileMode.WRITE);
- stream.writeUTFBytes(GenXML().toXMLString());
+ stream.writeUTFBytes(JSON.encode(GenJSON()));
stream.close();
ShowMsg("Saved.");
}
@@ -371,24 +372,24 @@ package
{
var stream: FileStream = new FileStream();
stream.open(file, FileMode.READ);
- var xml: XML = XML(stream.readUTFBytes(file.size));
+ var json: Object = JSON.decode(stream.readUTFBytes(file.size));
var itoken:int = 0;
- var rgtoken:Object = { ctokenLoaded: 0, ctoken: xml.children().length(), rgtoken: [] };
- for each (var xmlToken: XML in xml.children())
+ var rgtoken:Object = { ctokenLoaded: 0, ctoken: json.tokens.length, rgtoken: [] };
+ for each (var jsonToken:Object in json.tokens)
{
- LoadToken(xmlToken, itoken, rgtoken);
+ LoadToken(jsonToken, itoken, rgtoken);
itoken = itoken + 1;
}
ShowMsg("Loaded.");
}
}
- private function LoadToken(xml: XML, itoken: int, rgtoken:Object): void
+ private function LoadToken(json: Object, itoken: int, rgtoken:Object): void
{
- trace("loading " + xml.@path);
- Imgdir.LoadBmp(new File(UabFromUrf(xml.@path)),
+ trace("loading " + json.path);
+ Imgdir.LoadBmp(new File(UabFromUrf(json.path)),
function(bmp: BitmapData, file: File):void {
- trace("loadtoken: " + xml.@path);
- var token: Token = new Token(bmp, xml.@path.toString(), int(xml.@x), int(xml.@y), xml);
+ trace("loadtoken: " + json.path);
+ var token: Token = new Token(bmp, json.path, json.x, json.y, json);
FixupTokens(rgtoken, token, itoken);
},
function():void
@@ -410,15 +411,15 @@ package
}
}
}
- public function GenXML():XML
+ public function GenJSON(): Object
{
- var xml: XML = XML("");
- var rgtoken:Array = [];
+ var jsonTokens: Array = [];
+ var json: Object = { "tokens": jsonTokens };
+ var rgtoken: Array = [];
this.getLayer(LAYER_TOKENS, rgtoken);
for each(var token: Token in rgtoken)
- xml.appendChild(token.GenXML());
-
- return xml;
+ jsonTokens.push(token.GenJSON());
+ return json;
}
}
}
\ No newline at end of file
diff --git a/src/com/adobe/serialization/json/JSON.as b/src/com/adobe/serialization/json/JSON.as
new file mode 100644
index 0000000..4ba6c5b
--- /dev/null
+++ b/src/com/adobe/serialization/json/JSON.as
@@ -0,0 +1,86 @@
+/*
+ Copyright (c) 2008, Adobe Systems Incorporated
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are
+ met:
+
+ * Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+
+ * Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+ * Neither the name of Adobe Systems Incorporated nor the names of its
+ contributors may be used to endorse or promote products derived from
+ this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+ IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+package com.adobe.serialization.json
+{
+
+ /**
+ * This class provides encoding and decoding of the JSON format.
+ *
+ * Example usage:
+ *
+ * // create a JSON string from an internal object
+ * JSON.encode( myObject );
+ *
+ * // read a JSON string into an internal object
+ * var myObject:Object = JSON.decode( jsonString );
+ *
+ */
+ public class JSON
+ {
+ /**
+ * Encodes a object into a JSON string.
+ *
+ * @param o The object to create a JSON string for
+ * @return the JSON string representing o
+ * @langversion ActionScript 3.0
+ * @playerversion Flash 9.0
+ * @tiptext
+ */
+ public static function encode( o:Object ):String
+ {
+ return new JSONEncoder( o ).getString();
+ }
+
+ /**
+ * Decodes a JSON string into a native object.
+ *
+ * @param s The JSON string representing the object
+ * @param strict Flag indicating if the decoder should strictly adhere
+ * to the JSON standard or not. The default of true
+ * throws errors if the format does not match the JSON syntax exactly.
+ * Pass false
to allow for non-properly-formatted JSON
+ * strings to be decoded with more leniancy.
+ * @return A native object as specified by s
+ * @throw JSONParseError
+ * @langversion ActionScript 3.0
+ * @playerversion Flash 9.0
+ * @tiptext
+ */
+ public static function decode( s:String, strict:Boolean = true ):*
+ {
+ return new JSONDecoder( s, strict ).getValue();
+ }
+
+ }
+
+}
\ No newline at end of file
diff --git a/src/com/adobe/serialization/json/JSONDecoder.as b/src/com/adobe/serialization/json/JSONDecoder.as
new file mode 100644
index 0000000..f435227
--- /dev/null
+++ b/src/com/adobe/serialization/json/JSONDecoder.as
@@ -0,0 +1,327 @@
+/*
+ Copyright (c) 2008, Adobe Systems Incorporated
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are
+ met:
+
+ * Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+
+ * Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+ * Neither the name of Adobe Systems Incorporated nor the names of its
+ contributors may be used to endorse or promote products derived from
+ this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+ IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+package com.adobe.serialization.json
+{
+
+ public class JSONDecoder
+ {
+
+ /**
+ * Flag indicating if the parser should be strict about the format
+ * of the JSON string it is attempting to decode.
+ */
+ private var strict:Boolean;
+
+ /** The value that will get parsed from the JSON string */
+ private var value:*;
+
+ /** The tokenizer designated to read the JSON string */
+ private var tokenizer:JSONTokenizer;
+
+ /** The current token from the tokenizer */
+ private var token:JSONToken;
+
+ /**
+ * Constructs a new JSONDecoder to parse a JSON string
+ * into a native object.
+ *
+ * @param s The JSON string to be converted
+ * into a native object
+ * @param strict Flag indicating if the JSON string needs to
+ * strictly match the JSON standard or not.
+ * @langversion ActionScript 3.0
+ * @playerversion Flash 9.0
+ * @tiptext
+ */
+ public function JSONDecoder( s:String, strict:Boolean )
+ {
+ this.strict = strict;
+ tokenizer = new JSONTokenizer( s, strict );
+
+ nextToken();
+ value = parseValue();
+
+ // Make sure the input stream is empty
+ if ( strict && nextToken() != null )
+ {
+ tokenizer.parseError( "Unexpected characters left in input stream" );
+ }
+ }
+
+ /**
+ * Gets the internal object that was created by parsing
+ * the JSON string passed to the constructor.
+ *
+ * @return The internal object representation of the JSON
+ * string that was passed to the constructor
+ * @langversion ActionScript 3.0
+ * @playerversion Flash 9.0
+ * @tiptext
+ */
+ public function getValue():*
+ {
+ return value;
+ }
+
+ /**
+ * Returns the next token from the tokenzier reading
+ * the JSON string
+ */
+ private function nextToken():JSONToken
+ {
+ return token = tokenizer.getNextToken();
+ }
+
+ /**
+ * Attempt to parse an array.
+ */
+ private function parseArray():Array
+ {
+ // create an array internally that we're going to attempt
+ // to parse from the tokenizer
+ var a:Array = new Array();
+
+ // grab the next token from the tokenizer to move
+ // past the opening [
+ nextToken();
+
+ // check to see if we have an empty array
+ if ( token.type == JSONTokenType.RIGHT_BRACKET )
+ {
+ // we're done reading the array, so return it
+ return a;
+ }
+ // in non-strict mode an empty array is also a comma
+ // followed by a right bracket
+ else if ( !strict && token.type == JSONTokenType.COMMA )
+ {
+ // move past the comma
+ nextToken();
+
+ // check to see if we're reached the end of the array
+ if ( token.type == JSONTokenType.RIGHT_BRACKET )
+ {
+ return a;
+ }
+ else
+ {
+ tokenizer.parseError( "Leading commas are not supported. Expecting ']' but found " + token.value );
+ }
+ }
+
+ // deal with elements of the array, and use an "infinite"
+ // loop because we could have any amount of elements
+ while ( true )
+ {
+ // read in the value and add it to the array
+ a.push( parseValue() );
+
+ // after the value there should be a ] or a ,
+ nextToken();
+
+ if ( token.type == JSONTokenType.RIGHT_BRACKET )
+ {
+ // we're done reading the array, so return it
+ return a;
+ }
+ else if ( token.type == JSONTokenType.COMMA )
+ {
+ // move past the comma and read another value
+ nextToken();
+
+ // Allow arrays to have a comma after the last element
+ // if the decoder is not in strict mode
+ if ( !strict )
+ {
+ // Reached ",]" as the end of the array, so return it
+ if ( token.type == JSONTokenType.RIGHT_BRACKET )
+ {
+ return a;
+ }
+ }
+ }
+ else
+ {
+ tokenizer.parseError( "Expecting ] or , but found " + token.value );
+ }
+ }
+ return null;
+ }
+
+ /**
+ * Attempt to parse an object.
+ */
+ private function parseObject():Object
+ {
+ // create the object internally that we're going to
+ // attempt to parse from the tokenizer
+ var o:Object = new Object();
+
+ // store the string part of an object member so
+ // that we can assign it a value in the object
+ var key:String
+
+ // grab the next token from the tokenizer
+ nextToken();
+
+ // check to see if we have an empty object
+ if ( token.type == JSONTokenType.RIGHT_BRACE )
+ {
+ // we're done reading the object, so return it
+ return o;
+ }
+ // in non-strict mode an empty object is also a comma
+ // followed by a right bracket
+ else if ( !strict && token.type == JSONTokenType.COMMA )
+ {
+ // move past the comma
+ nextToken();
+
+ // check to see if we're reached the end of the object
+ if ( token.type == JSONTokenType.RIGHT_BRACE )
+ {
+ return o;
+ }
+ else
+ {
+ tokenizer.parseError( "Leading commas are not supported. Expecting '}' but found " + token.value );
+ }
+ }
+
+ // deal with members of the object, and use an "infinite"
+ // loop because we could have any amount of members
+ while ( true )
+ {
+ if ( token.type == JSONTokenType.STRING )
+ {
+ // the string value we read is the key for the object
+ key = String( token.value );
+
+ // move past the string to see what's next
+ nextToken();
+
+ // after the string there should be a :
+ if ( token.type == JSONTokenType.COLON )
+ {
+ // move past the : and read/assign a value for the key
+ nextToken();
+ o[key] = parseValue();
+
+ // move past the value to see what's next
+ nextToken();
+
+ // after the value there's either a } or a ,
+ if ( token.type == JSONTokenType.RIGHT_BRACE )
+ {
+ // we're done reading the object, so return it
+ return o;
+ }
+ else if ( token.type == JSONTokenType.COMMA )
+ {
+ // skip past the comma and read another member
+ nextToken();
+
+ // Allow objects to have a comma after the last member
+ // if the decoder is not in strict mode
+ if ( !strict )
+ {
+ // Reached ",}" as the end of the object, so return it
+ if ( token.type == JSONTokenType.RIGHT_BRACE )
+ {
+ return o;
+ }
+ }
+ }
+ else
+ {
+ tokenizer.parseError( "Expecting } or , but found " + token.value );
+ }
+ }
+ else
+ {
+ tokenizer.parseError( "Expecting : but found " + token.value );
+ }
+ }
+ else
+ {
+ tokenizer.parseError( "Expecting string but found " + token.value );
+ }
+ }
+ return null;
+ }
+
+ /**
+ * Attempt to parse a value
+ */
+ private function parseValue():Object
+ {
+ // Catch errors when the input stream ends abruptly
+ if ( token == null )
+ {
+ tokenizer.parseError( "Unexpected end of input" );
+ }
+
+ switch ( token.type )
+ {
+ case JSONTokenType.LEFT_BRACE:
+ return parseObject();
+
+ case JSONTokenType.LEFT_BRACKET:
+ return parseArray();
+
+ case JSONTokenType.STRING:
+ case JSONTokenType.NUMBER:
+ case JSONTokenType.TRUE:
+ case JSONTokenType.FALSE:
+ case JSONTokenType.NULL:
+ return token.value;
+
+ case JSONTokenType.NAN:
+ if ( !strict )
+ {
+ return token.value;
+ }
+ else
+ {
+ tokenizer.parseError( "Unexpected " + token.value );
+ }
+
+ default:
+ tokenizer.parseError( "Unexpected " + token.value );
+
+ }
+
+ return null;
+ }
+ }
+}
diff --git a/src/com/adobe/serialization/json/JSONEncoder.as b/src/com/adobe/serialization/json/JSONEncoder.as
new file mode 100644
index 0000000..b75e8e2
--- /dev/null
+++ b/src/com/adobe/serialization/json/JSONEncoder.as
@@ -0,0 +1,312 @@
+/*
+ Copyright (c) 2008, Adobe Systems Incorporated
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are
+ met:
+
+ * Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+
+ * Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+ * Neither the name of Adobe Systems Incorporated nor the names of its
+ contributors may be used to endorse or promote products derived from
+ this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+ IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+package com.adobe.serialization.json
+{
+
+ import flash.utils.describeType;
+
+ public class JSONEncoder {
+
+ /** The string that is going to represent the object we're encoding */
+ private var jsonString:String;
+
+ /**
+ * Creates a new JSONEncoder.
+ *
+ * @param o The object to encode as a JSON string
+ * @langversion ActionScript 3.0
+ * @playerversion Flash 9.0
+ * @tiptext
+ */
+ public function JSONEncoder( value:* ) {
+ jsonString = convertToString( value );
+
+ }
+
+ /**
+ * Gets the JSON string from the encoder.
+ *
+ * @return The JSON string representation of the object
+ * that was passed to the constructor
+ * @langversion ActionScript 3.0
+ * @playerversion Flash 9.0
+ * @tiptext
+ */
+ public function getString():String {
+ return jsonString;
+ }
+
+ /**
+ * Converts a value to it's JSON string equivalent.
+ *
+ * @param value The value to convert. Could be any
+ * type (object, number, array, etc)
+ */
+ private function convertToString( value:* ):String {
+
+ // determine what value is and convert it based on it's type
+ if ( value is String ) {
+
+ // escape the string so it's formatted correctly
+ return escapeString( value as String );
+
+ } else if ( value is Number ) {
+
+ // only encode numbers that finate
+ return isFinite( value as Number) ? value.toString() : "null";
+
+ } else if ( value is Boolean ) {
+
+ // convert boolean to string easily
+ return value ? "true" : "false";
+
+ } else if ( value is Array ) {
+
+ // call the helper method to convert an array
+ return arrayToString( value as Array );
+
+ } else if ( value is Object && value != null ) {
+
+ // call the helper method to convert an object
+ return objectToString( value );
+ }
+ return "null";
+ }
+
+ /**
+ * Escapes a string accoding to the JSON specification.
+ *
+ * @param str The string to be escaped
+ * @return The string with escaped special characters
+ * according to the JSON specification
+ */
+ private function escapeString( str:String ):String {
+ // create a string to store the string's jsonstring value
+ var s:String = "";
+ // current character in the string we're processing
+ var ch:String;
+ // store the length in a local variable to reduce lookups
+ var len:Number = str.length;
+
+ // loop over all of the characters in the string
+ for ( var i:int = 0; i < len; i++ ) {
+
+ // examine the character to determine if we have to escape it
+ ch = str.charAt( i );
+ switch ( ch ) {
+
+ case '"': // quotation mark
+ s += "\\\"";
+ break;
+
+ //case '/': // solidus
+ // s += "\\/";
+ // break;
+
+ case '\\': // reverse solidus
+ s += "\\\\";
+ break;
+
+ case '\b': // bell
+ s += "\\b";
+ break;
+
+ case '\f': // form feed
+ s += "\\f";
+ break;
+
+ case '\n': // newline
+ s += "\\n";
+ break;
+
+ case '\r': // carriage return
+ s += "\\r";
+ break;
+
+ case '\t': // horizontal tab
+ s += "\\t";
+ break;
+
+ default: // everything else
+
+ // check for a control character and escape as unicode
+ if ( ch < ' ' ) {
+ // get the hex digit(s) of the character (either 1 or 2 digits)
+ var hexCode:String = ch.charCodeAt( 0 ).toString( 16 );
+
+ // ensure that there are 4 digits by adjusting
+ // the # of zeros accordingly.
+ var zeroPad:String = hexCode.length == 2 ? "00" : "000";
+
+ // create the unicode escape sequence with 4 hex digits
+ s += "\\u" + zeroPad + hexCode;
+ } else {
+
+ // no need to do any special encoding, just pass-through
+ s += ch;
+
+ }
+ } // end switch
+
+ } // end for loop
+
+ return "\"" + s + "\"";
+ }
+
+ /**
+ * Converts an array to it's JSON string equivalent
+ *
+ * @param a The array to convert
+ * @return The JSON string representation of a
+ */
+ private function arrayToString( a:Array ):String {
+ // create a string to store the array's jsonstring value
+ var s:String = "";
+
+ // loop over the elements in the array and add their converted
+ // values to the string
+ for ( var i:int = 0; i < a.length; i++ ) {
+ // when the length is 0 we're adding the first element so
+ // no comma is necessary
+ if ( s.length > 0 ) {
+ // we've already added an element, so add the comma separator
+ s += ","
+ }
+
+ // convert the value to a string
+ s += convertToString( a[i] );
+ }
+
+ // KNOWN ISSUE: In ActionScript, Arrays can also be associative
+ // objects and you can put anything in them, ie:
+ // myArray["foo"] = "bar";
+ //
+ // These properties aren't picked up in the for loop above because
+ // the properties don't correspond to indexes. However, we're
+ // sort of out luck because the JSON specification doesn't allow
+ // these types of array properties.
+ //
+ // So, if the array was also used as an associative object, there
+ // may be some values in the array that don't get properly encoded.
+ //
+ // A possible solution is to instead encode the Array as an Object
+ // but then it won't get decoded correctly (and won't be an
+ // Array instance)
+
+ // close the array and return it's string value
+ return "[" + s + "]";
+ }
+
+ /**
+ * Converts an object to it's JSON string equivalent
+ *
+ * @param o The object to convert
+ * @return The JSON string representation of o
+ */
+ private function objectToString( o:Object ):String
+ {
+ // create a string to store the object's jsonstring value
+ var s:String = "";
+
+ // determine if o is a class instance or a plain object
+ var classInfo:XML = describeType( o );
+ if ( classInfo.@name.toString() == "Object" )
+ {
+ // the value of o[key] in the loop below - store this
+ // as a variable so we don't have to keep looking up o[key]
+ // when testing for valid values to convert
+ var value:Object;
+
+ // loop over the keys in the object and add their converted
+ // values to the string
+ for ( var key:String in o )
+ {
+ // assign value to a variable for quick lookup
+ value = o[key];
+
+ // don't add function's to the JSON string
+ if ( value is Function )
+ {
+ // skip this key and try another
+ continue;
+ }
+
+ // when the length is 0 we're adding the first item so
+ // no comma is necessary
+ if ( s.length > 0 ) {
+ // we've already added an item, so add the comma separator
+ s += ","
+ }
+
+ s += escapeString( key ) + ":" + convertToString( value );
+ }
+ }
+ else // o is a class instance
+ {
+ // Loop over all of the variables and accessors in the class and
+ // serialize them along with their values.
+ for each ( var v:XML in classInfo..*.(
+ name() == "variable"
+ ||
+ (
+ name() == "accessor"
+ // Issue #116 - Make sure accessors are readable
+ && attribute( "access" ).charAt( 0 ) == "r" )
+ ) )
+ {
+ // Issue #110 - If [Transient] metadata exists, then we should skip
+ if ( v.metadata && v.metadata.( @name == "Transient" ).length() > 0 )
+ {
+ continue;
+ }
+
+ // When the length is 0 we're adding the first item so
+ // no comma is necessary
+ if ( s.length > 0 ) {
+ // We've already added an item, so add the comma separator
+ s += ","
+ }
+
+ s += escapeString( v.@name.toString() ) + ":"
+ + convertToString( o[ v.@name ] );
+ }
+
+ }
+
+ return "{" + s + "}";
+ }
+
+
+ }
+
+}
diff --git a/src/com/adobe/serialization/json/JSONParseError.as b/src/com/adobe/serialization/json/JSONParseError.as
new file mode 100644
index 0000000..734d243
--- /dev/null
+++ b/src/com/adobe/serialization/json/JSONParseError.as
@@ -0,0 +1,87 @@
+/*
+ Copyright (c) 2008, Adobe Systems Incorporated
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are
+ met:
+
+ * Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+
+ * Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+ * Neither the name of Adobe Systems Incorporated nor the names of its
+ contributors may be used to endorse or promote products derived from
+ this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+ IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+package com.adobe.serialization.json {
+
+ /**
+ *
+ *
+ */
+ public class JSONParseError extends Error {
+
+ /** The location in the string where the error occurred */
+ private var _location:int;
+
+ /** The string in which the parse error occurred */
+ private var _text:String;
+
+ /**
+ * Constructs a new JSONParseError.
+ *
+ * @param message The error message that occured during parsing
+ * @langversion ActionScript 3.0
+ * @playerversion Flash 9.0
+ * @tiptext
+ */
+ public function JSONParseError( message:String = "", location:int = 0, text:String = "") {
+ super( message );
+ name = "JSONParseError";
+ _location = location;
+ _text = text;
+ }
+
+ /**
+ * Provides read-only access to the location variable.
+ *
+ * @return The location in the string where the error occurred
+ * @langversion ActionScript 3.0
+ * @playerversion Flash 9.0
+ * @tiptext
+ */
+ public function get location():int {
+ return _location;
+ }
+
+ /**
+ * Provides read-only access to the text variable.
+ *
+ * @return The string in which the error occurred
+ * @langversion ActionScript 3.0
+ * @playerversion Flash 9.0
+ * @tiptext
+ */
+ public function get text():String {
+ return _text;
+ }
+ }
+
+}
\ No newline at end of file
diff --git a/src/com/adobe/serialization/json/JSONToken.as b/src/com/adobe/serialization/json/JSONToken.as
new file mode 100644
index 0000000..1f32c04
--- /dev/null
+++ b/src/com/adobe/serialization/json/JSONToken.as
@@ -0,0 +1,104 @@
+/*
+ Copyright (c) 2008, Adobe Systems Incorporated
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are
+ met:
+
+ * Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+
+ * Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+ * Neither the name of Adobe Systems Incorporated nor the names of its
+ contributors may be used to endorse or promote products derived from
+ this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+ IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+package com.adobe.serialization.json {
+
+ public class JSONToken {
+
+ private var _type:int;
+ private var _value:Object;
+
+ /**
+ * Creates a new JSONToken with a specific token type and value.
+ *
+ * @param type The JSONTokenType of the token
+ * @param value The value of the token
+ * @langversion ActionScript 3.0
+ * @playerversion Flash 9.0
+ * @tiptext
+ */
+ public function JSONToken( type:int = -1 /* JSONTokenType.UNKNOWN */, value:Object = null ) {
+ _type = type;
+ _value = value;
+ }
+
+ /**
+ * Returns the type of the token.
+ *
+ * @see com.adobe.serialization.json.JSONTokenType
+ * @langversion ActionScript 3.0
+ * @playerversion Flash 9.0
+ * @tiptext
+ */
+ public function get type():int {
+ return _type;
+ }
+
+ /**
+ * Sets the type of the token.
+ *
+ * @see com.adobe.serialization.json.JSONTokenType
+ * @langversion ActionScript 3.0
+ * @playerversion Flash 9.0
+ * @tiptext
+ */
+ public function set type( value:int ):void {
+ _type = value;
+ }
+
+ /**
+ * Gets the value of the token
+ *
+ * @see com.adobe.serialization.json.JSONTokenType
+ * @langversion ActionScript 3.0
+ * @playerversion Flash 9.0
+ * @tiptext
+ */
+ public function get value():Object {
+ return _value;
+ }
+
+ /**
+ * Sets the value of the token
+ *
+ * @see com.adobe.serialization.json.JSONTokenType
+ * @langversion ActionScript 3.0
+ * @playerversion Flash 9.0
+ * @tiptext
+ */
+ public function set value ( v:Object ):void {
+ _value = v;
+ }
+
+ }
+
+}
\ No newline at end of file
diff --git a/src/com/adobe/serialization/json/JSONTokenType.as b/src/com/adobe/serialization/json/JSONTokenType.as
new file mode 100644
index 0000000..5611639
--- /dev/null
+++ b/src/com/adobe/serialization/json/JSONTokenType.as
@@ -0,0 +1,69 @@
+/*
+ Copyright (c) 2008, Adobe Systems Incorporated
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are
+ met:
+
+ * Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+
+ * Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+ * Neither the name of Adobe Systems Incorporated nor the names of its
+ contributors may be used to endorse or promote products derived from
+ this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+ IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+package com.adobe.serialization.json {
+
+ /**
+ * Class containing constant values for the different types
+ * of tokens in a JSON encoded string.
+ */
+ public class JSONTokenType {
+
+ public static const UNKNOWN:int = -1;
+
+ public static const COMMA:int = 0;
+
+ public static const LEFT_BRACE:int = 1;
+
+ public static const RIGHT_BRACE:int = 2;
+
+ public static const LEFT_BRACKET:int = 3;
+
+ public static const RIGHT_BRACKET:int = 4;
+
+ public static const COLON:int = 6;
+
+ public static const TRUE:int = 7;
+
+ public static const FALSE:int = 8;
+
+ public static const NULL:int = 9;
+
+ public static const STRING:int = 10;
+
+ public static const NUMBER:int = 11;
+
+ public static const NAN:int = 12;
+
+ }
+
+}
\ No newline at end of file
diff --git a/src/com/adobe/serialization/json/JSONTokenizer.as b/src/com/adobe/serialization/json/JSONTokenizer.as
new file mode 100644
index 0000000..3be41bc
--- /dev/null
+++ b/src/com/adobe/serialization/json/JSONTokenizer.as
@@ -0,0 +1,702 @@
+/*
+ Copyright (c) 2008, Adobe Systems Incorporated
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are
+ met:
+
+ * Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+
+ * Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+ * Neither the name of Adobe Systems Incorporated nor the names of its
+ contributors may be used to endorse or promote products derived from
+ this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+ IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+package com.adobe.serialization.json {
+
+ public class JSONTokenizer {
+
+ /**
+ * Flag indicating if the tokenizer should only recognize
+ * standard JSON tokens. Setting to false
allows
+ * tokens such as NaN and allows numbers to be formatted as
+ * hex, etc.
+ */
+ private var strict:Boolean;
+
+ /** The object that will get parsed from the JSON string */
+ private var obj:Object;
+
+ /** The JSON string to be parsed */
+ private var jsonString:String;
+
+ /** The current parsing location in the JSON string */
+ private var loc:int;
+
+ /** The current character in the JSON string during parsing */
+ private var ch:String;
+
+ /**
+ * The regular expression used to make sure the string does not
+ * contain invalid control characters.
+ */
+ private var controlCharsRegExp:RegExp = /[\x00-\x1F]/;
+
+ /**
+ * Constructs a new JSONDecoder to parse a JSON string
+ * into a native object.
+ *
+ * @param s The JSON string to be converted
+ * into a native object
+ */
+ public function JSONTokenizer( s:String, strict:Boolean )
+ {
+ jsonString = s;
+ this.strict = strict;
+ loc = 0;
+
+ // prime the pump by getting the first character
+ nextChar();
+ }
+
+ /**
+ * Gets the next token in the input sting and advances
+ * the character to the next character after the token
+ */
+ public function getNextToken():JSONToken
+ {
+ var token:JSONToken = new JSONToken();
+
+ // skip any whitespace / comments since the last
+ // token was read
+ skipIgnored();
+
+ // examine the new character and see what we have...
+ switch ( ch )
+ {
+ case '{':
+ token.type = JSONTokenType.LEFT_BRACE;
+ token.value = '{';
+ nextChar();
+ break
+
+ case '}':
+ token.type = JSONTokenType.RIGHT_BRACE;
+ token.value = '}';
+ nextChar();
+ break
+
+ case '[':
+ token.type = JSONTokenType.LEFT_BRACKET;
+ token.value = '[';
+ nextChar();
+ break
+
+ case ']':
+ token.type = JSONTokenType.RIGHT_BRACKET;
+ token.value = ']';
+ nextChar();
+ break
+
+ case ',':
+ token.type = JSONTokenType.COMMA;
+ token.value = ',';
+ nextChar();
+ break
+
+ case ':':
+ token.type = JSONTokenType.COLON;
+ token.value = ':';
+ nextChar();
+ break;
+
+ case 't': // attempt to read true
+ var possibleTrue:String = "t" + nextChar() + nextChar() + nextChar();
+
+ if ( possibleTrue == "true" )
+ {
+ token.type = JSONTokenType.TRUE;
+ token.value = true;
+ nextChar();
+ }
+ else
+ {
+ parseError( "Expecting 'true' but found " + possibleTrue );
+ }
+
+ break;
+
+ case 'f': // attempt to read false
+ var possibleFalse:String = "f" + nextChar() + nextChar() + nextChar() + nextChar();
+
+ if ( possibleFalse == "false" )
+ {
+ token.type = JSONTokenType.FALSE;
+ token.value = false;
+ nextChar();
+ }
+ else
+ {
+ parseError( "Expecting 'false' but found " + possibleFalse );
+ }
+
+ break;
+
+ case 'n': // attempt to read null
+ var possibleNull:String = "n" + nextChar() + nextChar() + nextChar();
+
+ if ( possibleNull == "null" )
+ {
+ token.type = JSONTokenType.NULL;
+ token.value = null;
+ nextChar();
+ }
+ else
+ {
+ parseError( "Expecting 'null' but found " + possibleNull );
+ }
+
+ break;
+
+ case 'N': // attempt to read NaN
+ var possibleNaN:String = "N" + nextChar() + nextChar();
+
+ if ( possibleNaN == "NaN" )
+ {
+ token.type = JSONTokenType.NAN;
+ token.value = NaN;
+ nextChar();
+ }
+ else
+ {
+ parseError( "Expecting 'NaN' but found " + possibleNaN );
+ }
+
+ break;
+
+ case '"': // the start of a string
+ token = readString();
+ break;
+
+ default:
+ // see if we can read a number
+ if ( isDigit( ch ) || ch == '-' )
+ {
+ token = readNumber();
+ }
+ else if ( ch == '' )
+ {
+ // check for reading past the end of the string
+ return null;
+ }
+ else
+ {
+ // not sure what was in the input string - it's not
+ // anything we expected
+ parseError( "Unexpected " + ch + " encountered" );
+ }
+ }
+
+ return token;
+ }
+
+ /**
+ * Attempts to read a string from the input string. Places
+ * the character location at the first character after the
+ * string. It is assumed that ch is " before this method is called.
+ *
+ * @return the JSONToken with the string value if a string could
+ * be read. Throws an error otherwise.
+ */
+ private function readString():JSONToken
+ {
+ // Rather than examine the string character-by-character, it's
+ // faster to use indexOf to try to and find the closing quote character
+ // and then replace escape sequences after the fact.
+
+ // Start at the current input stream position
+ var quoteIndex:int = loc;
+ do
+ {
+ // Find the next quote in the input stream
+ quoteIndex = jsonString.indexOf( "\"", quoteIndex );
+
+ if ( quoteIndex >= 0 )
+ {
+ // We found the next double quote character in the string, but we need
+ // to make sure it is not part of an escape sequence.
+
+ // Keep looping backwards while the previous character is a backslash
+ var backspaceCount:int = 0;
+ var backspaceIndex:int = quoteIndex - 1;
+ while ( jsonString.charAt( backspaceIndex ) == "\\" )
+ {
+ backspaceCount++;
+ backspaceIndex--;
+ }
+
+ // If we have an even number of backslashes, that means this is the ending quote
+ if ( backspaceCount % 2 == 0 )
+ {
+ break;
+ }
+
+ // At this point, the quote was determined to be part of an escape sequence
+ // so we need to move past the quote index to look for the next one
+ quoteIndex++;
+ }
+ else // There are no more quotes in the string and we haven't found the end yet
+ {
+ parseError( "Unterminated string literal" );
+ }
+ } while ( true );
+
+ // Unescape the string
+ // the token for the string we'll try to read
+ var token:JSONToken = new JSONToken();
+ token.type = JSONTokenType.STRING;
+ // Attach resulting string to the token to return it
+ token.value = unescapeString( jsonString.substr( loc, quoteIndex - loc ) );
+
+ // Move past the closing quote in the input string. This updates the next
+ // character in the input stream to be the character one after the closing quote
+ loc = quoteIndex + 1;
+ nextChar();
+
+ return token;
+ }
+
+ /**
+ * Convert all JavaScript escape characters into normal characters
+ *
+ * @param input The input string to convert
+ * @return Original string with escape characters replaced by real characters
+ */
+ public function unescapeString( input:String ):String
+ {
+ // Issue #104 - If the string contains any unescaped control characters, this
+ // is an error in strict mode
+ if ( strict && controlCharsRegExp.test( input ) )
+ {
+ parseError( "String contains unescaped control character (0x00-0x1F)" );
+ }
+
+ var result:String = "";
+ var backslashIndex:int = 0;
+ var nextSubstringStartPosition:int = 0;
+ var len:int = input.length;
+ do
+ {
+ // Find the next backslash in the input
+ backslashIndex = input.indexOf( '\\', nextSubstringStartPosition );
+
+ if ( backslashIndex >= 0 )
+ {
+ result += input.substr( nextSubstringStartPosition, backslashIndex - nextSubstringStartPosition );
+
+ // Move past the backslash and next character (all escape sequences are
+ // two characters, except for \u, which will advance this further)
+ nextSubstringStartPosition = backslashIndex + 2;
+
+ // Check the next character so we know what to escape
+ var afterBackslashIndex:int = backslashIndex + 1;
+ var escapedChar:String = input.charAt( afterBackslashIndex );
+ switch ( escapedChar )
+ {
+ // Try to list the most common expected cases first to improve performance
+
+ case '"': result += '"'; break; // quotation mark
+ case '\\': result += '\\'; break; // reverse solidus
+ case 'n': result += '\n'; break; // newline
+ case 'r': result += '\r'; break; // carriage return
+ case 't': result += '\t'; break; // horizontal tab
+
+ // Convert a unicode escape sequence to it's character value
+ case 'u':
+
+ // Save the characters as a string we'll convert to an int
+ var hexValue:String = "";
+
+ // Make sure there are enough characters in the string leftover
+ if ( nextSubstringStartPosition + 4 > len )
+ {
+ parseError( "Unexpected end of input. Expecting 4 hex digits after \\u." );
+ }
+
+ // Try to find 4 hex characters
+ for ( var i:int = nextSubstringStartPosition; i < nextSubstringStartPosition + 4; i++ )
+ {
+ // get the next character and determine
+ // if it's a valid hex digit or not
+ var possibleHexChar:String = input.charAt( i );
+ if ( !isHexDigit( possibleHexChar ) )
+ {
+ parseError( "Excepted a hex digit, but found: " + possibleHexChar );
+ }
+
+ // Valid hex digit, add it to the value
+ hexValue += possibleHexChar;
+ }
+
+ // Convert hexValue to an integer, and use that
+ // integer value to create a character to add
+ // to our string.
+ result += String.fromCharCode( parseInt( hexValue, 16 ) );
+ // Move past the 4 hex digits that we just read
+ nextSubstringStartPosition += 4;
+ break;
+
+ case 'f': result += '\f'; break; // form feed
+ case '/': result += '/'; break; // solidus
+ case 'b': result += '\b'; break; // bell
+ default: result += '\\' + escapedChar; // Couldn't unescape the sequence, so just pass it through
+ }
+ }
+ else
+ {
+ // No more backslashes to replace, append the rest of the string
+ result += input.substr( nextSubstringStartPosition );
+ break;
+ }
+
+ } while ( nextSubstringStartPosition < len );
+
+ return result;
+ }
+
+ /**
+ * Attempts to read a number from the input string. Places
+ * the character location at the first character after the
+ * number.
+ *
+ * @return The JSONToken with the number value if a number could
+ * be read. Throws an error otherwise.
+ */
+ private function readNumber():JSONToken
+ {
+ // the string to accumulate the number characters
+ // into that we'll convert to a number at the end
+ var input:String = "";
+
+ // check for a negative number
+ if ( ch == '-' )
+ {
+ input += '-';
+ nextChar();
+ }
+
+ // the number must start with a digit
+ if ( !isDigit( ch ) )
+ {
+ parseError( "Expecting a digit" );
+ }
+
+ // 0 can only be the first digit if it
+ // is followed by a decimal point
+ if ( ch == '0' )
+ {
+ input += ch;
+ nextChar();
+
+ // make sure no other digits come after 0
+ if ( isDigit( ch ) )
+ {
+ parseError( "A digit cannot immediately follow 0" );
+ }
+ // unless we have 0x which starts a hex number, but this
+ // doesn't match JSON spec so check for not strict mode.
+ else if ( !strict && ch == 'x' )
+ {
+ // include the x in the input
+ input += ch;
+ nextChar();
+
+ // need at least one hex digit after 0x to
+ // be valid
+ if ( isHexDigit( ch ) )
+ {
+ input += ch;
+ nextChar();
+ }
+ else
+ {
+ parseError( "Number in hex format require at least one hex digit after \"0x\"" );
+ }
+
+ // consume all of the hex values
+ while ( isHexDigit( ch ) )
+ {
+ input += ch;
+ nextChar();
+ }
+ }
+ }
+ else
+ {
+ // read numbers while we can
+ while ( isDigit( ch ) )
+ {
+ input += ch;
+ nextChar();
+ }
+ }
+
+ // check for a decimal value
+ if ( ch == '.' )
+ {
+ input += '.';
+ nextChar();
+
+ // after the decimal there has to be a digit
+ if ( !isDigit( ch ) )
+ {
+ parseError( "Expecting a digit" );
+ }
+
+ // read more numbers to get the decimal value
+ while ( isDigit( ch ) )
+ {
+ input += ch;
+ nextChar();
+ }
+ }
+
+ // check for scientific notation
+ if ( ch == 'e' || ch == 'E' )
+ {
+ input += "e"
+ nextChar();
+ // check for sign
+ if ( ch == '+' || ch == '-' )
+ {
+ input += ch;
+ nextChar();
+ }
+
+ // require at least one number for the exponent
+ // in this case
+ if ( !isDigit( ch ) )
+ {
+ parseError( "Scientific notation number needs exponent value" );
+ }
+
+ // read in the exponent
+ while ( isDigit( ch ) )
+ {
+ input += ch;
+ nextChar();
+ }
+ }
+
+ // convert the string to a number value
+ var num:Number = Number( input );
+
+ if ( isFinite( num ) && !isNaN( num ) )
+ {
+ // the token for the number that we've read
+ var token:JSONToken = new JSONToken();
+ token.type = JSONTokenType.NUMBER;
+ token.value = num;
+ return token;
+ }
+ else
+ {
+ parseError( "Number " + num + " is not valid!" );
+ }
+
+ return null;
+ }
+
+ /**
+ * Reads the next character in the input
+ * string and advances the character location.
+ *
+ * @return The next character in the input string, or
+ * null if we've read past the end.
+ */
+ private function nextChar():String
+ {
+ return ch = jsonString.charAt( loc++ );
+ }
+
+ /**
+ * Advances the character location past any
+ * sort of white space and comments
+ */
+ private function skipIgnored():void
+ {
+ var originalLoc:int;
+
+ // keep trying to skip whitespace and comments as long
+ // as we keep advancing past the original location
+ do
+ {
+ originalLoc = loc;
+ skipWhite();
+ skipComments();
+ }
+ while ( originalLoc != loc );
+ }
+
+ /**
+ * Skips comments in the input string, either
+ * single-line or multi-line. Advances the character
+ * to the first position after the end of the comment.
+ */
+ private function skipComments():void
+ {
+ if ( ch == '/' )
+ {
+ // Advance past the first / to find out what type of comment
+ nextChar();
+ switch ( ch )
+ {
+ case '/': // single-line comment, read through end of line
+
+ // Loop over the characters until we find
+ // a newline or until there's no more characters left
+ do
+ {
+ nextChar();
+ }
+ while ( ch != '\n' && ch != '' )
+
+ // move past the \n
+ nextChar();
+
+ break;
+
+ case '*': // multi-line comment, read until closing */
+
+ // move past the opening *
+ nextChar();
+
+ // try to find a trailing */
+ while ( true )
+ {
+ if ( ch == '*' )
+ {
+ // check to see if we have a closing /
+ nextChar();
+ if ( ch == '/')
+ {
+ // move past the end of the closing */
+ nextChar();
+ break;
+ }
+ }
+ else
+ {
+ // move along, looking if the next character is a *
+ nextChar();
+ }
+
+ // when we're here we've read past the end of
+ // the string without finding a closing */, so error
+ if ( ch == '' )
+ {
+ parseError( "Multi-line comment not closed" );
+ }
+ }
+
+ break;
+
+ // Can't match a comment after a /, so it's a parsing error
+ default:
+ parseError( "Unexpected " + ch + " encountered (expecting '/' or '*' )" );
+ }
+ }
+
+ }
+
+
+ /**
+ * Skip any whitespace in the input string and advances
+ * the character to the first character after any possible
+ * whitespace.
+ */
+ private function skipWhite():void
+ {
+ // As long as there are spaces in the input
+ // stream, advance the current location pointer
+ // past them
+ while ( isWhiteSpace( ch ) )
+ {
+ nextChar();
+ }
+
+ }
+
+ /**
+ * Determines if a character is whitespace or not.
+ *
+ * @return True if the character passed in is a whitespace
+ * character
+ */
+ private function isWhiteSpace( ch:String ):Boolean
+ {
+ // Check for the whitespace defined in the spec
+ if ( ch == ' ' || ch == '\t' || ch == '\n' || ch == '\r' )
+ {
+ return true;
+ }
+ // If we're not in strict mode, we also accept non-breaking space
+ else if ( !strict && ch.charCodeAt( 0 ) == 160 )
+ {
+ return true;
+ }
+
+ return false;
+ }
+
+ /**
+ * Determines if a character is a digit [0-9].
+ *
+ * @return True if the character passed in is a digit
+ */
+ private function isDigit( ch:String ):Boolean
+ {
+ return ( ch >= '0' && ch <= '9' );
+ }
+
+ /**
+ * Determines if a character is a hex digit [0-9A-Fa-f].
+ *
+ * @return True if the character passed in is a hex digit
+ */
+ private function isHexDigit( ch:String ):Boolean
+ {
+ return ( isDigit( ch ) || ( ch >= 'A' && ch <= 'F' ) || ( ch >= 'a' && ch <= 'f' ) );
+ }
+
+ /**
+ * Raises a parsing error with a specified message, tacking
+ * on the error location and the original string.
+ *
+ * @param message The message indicating why the error occurred
+ */
+ public function parseError( message:String ):void
+ {
+ throw new JSONParseError( message, loc, jsonString );
+ }
+ }
+
+}
diff --git a/todo.txt b/todo.txt
index fd7a823..e91efbb 100644
--- a/todo.txt
+++ b/todo.txt
@@ -1,7 +1,6 @@
- decide on a license
- push to github
-- JSON output?
-- fixed-sized factories
+- human-readable JSON output
- finalize "library" notion
- text objects
@@ -18,4 +17,6 @@ DONE:
- show 0,0, maybe some other griddy options
- fix scrollwheel sensitivity
- create a readme
-- quit to menu
\ No newline at end of file
+- quit to menu
+- fixed-sized factories
+- JSON output?
\ No newline at end of file