Replace all whitespace checks to use JsonUtils.IsWhiteSpace()

mythz · mythz · commit 332331421cf6 · 2017-05-22T20:35:51.000-04:00
diff --git a/src/ServiceStack.Text/Common/DeserializeTypeRefJson.cs b/src/ServiceStack.Text/Common/DeserializeTypeRefJson.cs
@@ -60,7 +60,7 @@ internal static object StringToType(
                 return null;
 
             //if (!Serializer.EatMapStartChar(strType, ref index))
-            for (; index < strType.Length; index++) { var c = strType[index]; if (c >= JsonTypeSerializer.WhiteSpaceFlags.Length || !JsonTypeSerializer.WhiteSpaceFlags[c]) break; } //Whitespace inline
+            for (; index < strType.Length; index++) { var c = strType[index]; if (!JsonUtils.IsWhiteSpace(c)) break; } //Whitespace inline
             if (strType[index++] != JsWriter.MapStartChar)
                 throw DeserializeTypeRef.CreateSerializationError(type, strType);
 
@@ -78,7 +78,7 @@ internal static object StringToType(
                 var propertyName = JsonTypeSerializer.ParseJsonString(strType, ref index);
 
                 //Serializer.EatMapKeySeperator(strType, ref index);
-                for (; index < strType.Length; index++) { var c = strType[index]; if (c >= JsonTypeSerializer.WhiteSpaceFlags.Length || !JsonTypeSerializer.WhiteSpaceFlags[c]) break; } //Whitespace inline
+                for (; index < strType.Length; index++) { var c = strType[index]; if (!JsonUtils.IsWhiteSpace(c)) break; } //Whitespace inline
                 if (strType.Length != index) index++;
 
                 var propertyValueStr = Serializer.EatValue(strType, ref index);
@@ -152,13 +152,13 @@ internal static object StringToType(
                         }
 
                         //Serializer.EatItemSeperatorOrMapEndChar(strType, ref index);
-                        for (; index < strType.Length; index++) { var c = strType[index]; if (c >= JsonTypeSerializer.WhiteSpaceFlags.Length || !JsonTypeSerializer.WhiteSpaceFlags[c]) break; } //Whitespace inline
+                        for (; index < strType.Length; index++) { var c = strType[index]; if (!JsonUtils.IsWhiteSpace(c)) break; } //Whitespace inline
                         if (index != strType.Length)
                         {
                             var success = strType[index] == JsWriter.ItemSeperator || strType[index] == JsWriter.MapEndChar;
                             index++;
                             if (success)
-                                for (; index < strType.Length; index++) { var c = strType[index]; if (c >= JsonTypeSerializer.WhiteSpaceFlags.Length || !JsonTypeSerializer.WhiteSpaceFlags[c]) break; } //Whitespace inline
+                                for (; index < strType.Length; index++) { var c = strType[index]; if (!JsonUtils.IsWhiteSpace(c)) break; } //Whitespace inline
                         }
 
                         continue;
@@ -195,13 +195,13 @@ internal static object StringToType(
                 }
 
                 //Serializer.EatItemSeperatorOrMapEndChar(strType, ref index);
-                for (; index < strType.Length; index++) { var c = strType[index]; if (c >= JsonTypeSerializer.WhiteSpaceFlags.Length || !JsonTypeSerializer.WhiteSpaceFlags[c]) break; } //Whitespace inline
+                for (; index < strType.Length; index++) { var c = strType[index]; if (!JsonUtils.IsWhiteSpace(c)) break; } //Whitespace inline
                 if (index != strType.Length)
                 {
                     var success = strType[index] == JsWriter.ItemSeperator || strType[index] == JsWriter.MapEndChar;
                     index++;
                     if (success)
-                        for (; index < strType.Length; index++) { var c = strType[index]; if (c >= JsonTypeSerializer.WhiteSpaceFlags.Length || !JsonTypeSerializer.WhiteSpaceFlags[c]) break; } //Whitespace inline
+                        for (; index < strType.Length; index++) { var c = strType[index]; if (!JsonUtils.IsWhiteSpace(c)) break; } //Whitespace inline
                 }
 
             }
diff --git a/src/ServiceStack.Text/Json/JsonTypeSerializer.cs b/src/ServiceStack.Text/Json/JsonTypeSerializer.cs
@@ -4,6 +4,7 @@
 using System;
 using System.Globalization;
 using System.IO;
+using System.Runtime.CompilerServices;
 using System.Text;
 using ServiceStack.Text.Common;
 using ServiceStack.Text.Pools;
@@ -35,16 +36,6 @@ internal static string GetTypeAttrInObject(string typeAttr)
             return string.Format("{{\"{0}\":", typeAttr);
         }
 
-        public static readonly bool[] WhiteSpaceFlags = new bool[' ' + 1];
-
-        static JsonTypeSerializer()
-        {
-            foreach (var c in JsonUtils.WhiteSpaceChars)
-            {
-                WhiteSpaceFlags[c] = true;
-            }
-        }
-
         public WriteObjectDelegate GetWriteFn<T>()
         {
             return JsonWriter<T>.WriteFn();
@@ -343,7 +334,7 @@ public string ParseString(string value)
 
         public static bool IsEmptyMap(string value, int i = 1)
         {
-            for (; i < value.Length; i++) { var c = value[i]; if (c >= WhiteSpaceFlags.Length || !WhiteSpaceFlags[c]) break; } //Whitespace inline
+            for (; i < value.Length; i++) { var c = value[i]; if (!JsonUtils.IsWhiteSpace(c)) break; } //Whitespace inline
             if (value.Length == i) return true;
             return value[i++] == JsWriter.MapEndChar;
         }
@@ -393,7 +384,7 @@ public string UnescapeSafeString(string value)
 
         internal static string ParseJsonString(string json, ref int index)
         {
-            for (; index < json.Length; index++) { var ch = json[index]; if (ch >= WhiteSpaceFlags.Length || !WhiteSpaceFlags[ch]) break; } //Whitespace inline
+            for (; index < json.Length; index++) { var ch = json[index]; if (!JsonUtils.IsWhiteSpace(ch)) break; } //Whitespace inline
 
             return UnEscapeJsonString(json, ref index);
         }
@@ -558,14 +549,14 @@ public string EatTypeValue(string value, ref int i)
 
         public bool EatMapStartChar(string value, ref int i)
         {
-            for (; i < value.Length; i++) { var c = value[i]; if (c >= WhiteSpaceFlags.Length || !WhiteSpaceFlags[c]) break; } //Whitespace inline
+            for (; i < value.Length; i++) { var c = value[i]; if (!JsonUtils.IsWhiteSpace(c)) break; } //Whitespace inline
             return value[i++] == JsWriter.MapStartChar;
         }
 
         public string EatMapKey(string value, ref int i)
         {
             var valueLength = value.Length;
-            for (; i < value.Length; i++) { var c = value[i]; if (c >= WhiteSpaceFlags.Length || !WhiteSpaceFlags[c]) break; } //Whitespace inline
+            for (; i < value.Length; i++) { var c = value[i]; if (!JsonUtils.IsWhiteSpace(c)) break; } //Whitespace inline
 
             var tokenStartPos = i;
             var valueChar = value[i];
@@ -589,7 +580,7 @@ public string EatMapKey(string value, ref int i)
 
                 if (valueChar == JsWriter.ItemSeperator
                     //If it doesn't have quotes it's either a keyword or number so also has a ws boundary
-                    || (valueChar < WhiteSpaceFlags.Length && WhiteSpaceFlags[valueChar])
+                    || (JsonUtils.IsWhiteSpace(valueChar))
                 )
                 {
                     break;
@@ -601,14 +592,14 @@ public string EatMapKey(string value, ref int i)
 
         public bool EatMapKeySeperator(string value, ref int i)
         {
-            for (; i < value.Length; i++) { var c = value[i]; if (c >= WhiteSpaceFlags.Length || !WhiteSpaceFlags[c]) break; } //Whitespace inline
+            for (; i < value.Length; i++) { var c = value[i]; if (!JsonUtils.IsWhiteSpace(c)) break; } //Whitespace inline
             if (value.Length == i) return false;
             return value[i++] == JsWriter.MapKeySeperator;
         }
 
         public bool EatItemSeperatorOrMapEndChar(string value, ref int i)
         {
-            for (; i < value.Length; i++) { var c = value[i]; if (c >= WhiteSpaceFlags.Length || !WhiteSpaceFlags[c]) break; } //Whitespace inline
+            for (; i < value.Length; i++) { var c = value[i]; if (!JsonUtils.IsWhiteSpace(c)) break; } //Whitespace inline
 
             if (i == value.Length) return false;
 
@@ -619,23 +610,23 @@ public bool EatItemSeperatorOrMapEndChar(string value, ref int i)
 
             if (success)
             {
-                for (; i < value.Length; i++) { var c = value[i]; if (c >= WhiteSpaceFlags.Length || !WhiteSpaceFlags[c]) break; } //Whitespace inline
+                for (; i < value.Length; i++) { var c = value[i]; if (!JsonUtils.IsWhiteSpace(c)) break; } //Whitespace inline
             }
 
             return success;
         }
 
         public void EatWhitespace(string value, ref int i)
         {
-            for (; i < value.Length; i++) { var c = value[i]; if (c >= WhiteSpaceFlags.Length || !WhiteSpaceFlags[c]) break; } //Whitespace inline
+            for (; i < value.Length; i++) { var c = value[i]; if (!JsonUtils.IsWhiteSpace(c)) break; } //Whitespace inline
         }
 
         public string EatValue(string value, ref int i)
         {
             var valueLength = value.Length;
             if (i == valueLength) return null;
 
-            for (; i < value.Length; i++) { var c = value[i]; if (c >= WhiteSpaceFlags.Length || !WhiteSpaceFlags[c]) break; } //Whitespace inline
+            for (; i < value.Length; i++) { var c = value[i]; if (!JsonUtils.IsWhiteSpace(c)) break; } //Whitespace inline
             if (i == valueLength) return null;
 
             var tokenStartPos = i;
@@ -715,7 +706,7 @@ public string EatValue(string value, ref int i)
                 if (valueChar == JsWriter.ItemSeperator
                     || valueChar == JsWriter.MapEndChar
                     //If it doesn't have quotes it's either a keyword or number so also has a ws boundary
-                    || (valueChar < WhiteSpaceFlags.Length && WhiteSpaceFlags[valueChar])
+                    || JsonUtils.IsWhiteSpace(valueChar)
                 )
                 {
                     break;
diff --git a/src/ServiceStack.Text/Json/JsonUtils.cs b/src/ServiceStack.Text/Json/JsonUtils.cs
@@ -1,6 +1,7 @@
 //Copyright (c) Service Stack LLC. All Rights Reserved.
 //License: https://raw.github.com/ServiceStack/ServiceStack/master/license.txt
 
+using System;
 using System.IO;
 using System.Runtime.CompilerServices;
 
@@ -18,11 +19,12 @@ public static class JsonUtils
         public const string True = "true";
         public const string False = "false";
 
-        private const char TabChar = '\t';
-        private const char CarriageReturnChar = '\r';
-        private const char LineFeedChar = '\n';
-        private const char FormFeedChar = '\f';
-        private const char BackspaceChar = '\b';
+        public const char SpaceChar = ' ';
+        public const char TabChar = '\t';
+        public const char CarriageReturnChar = '\r';
+        public const char LineFeedChar = '\n';
+        public const char FormFeedChar = '\f';
+        public const char BackspaceChar = '\b';
 
         /// <summary>
         /// Micro-optimization keep pre-built char arrays saving a .ToCharArray() + function call (see .net implementation of .Write(string))
@@ -37,6 +39,12 @@ public static class JsonUtils
 
         public static readonly char[] WhiteSpaceChars = { ' ', TabChar, CarriageReturnChar, LineFeedChar };
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool IsWhiteSpace(char c)
+        {
+            return c == ' ' || (c >= '\x0009' && c <= '\x000d') || c == '\x00a0' || c == '\x0085';
+        }
+
         public static void WriteString(TextWriter writer, string value)
         {
             if (value == null)

Original file line number	Diff line number	Diff line change
`@@ -60,7 +60,7 @@ internal static object StringToType(`
`60`	`60`	`return null;`
`61`	`61`
`62`	`62`	`//if (!Serializer.EatMapStartChar(strType, ref index))`
`63`		`- for (; index < strType.Length; index++) { var c = strType[index]; if (c >= JsonTypeSerializer.WhiteSpaceFlags.Length \|\| !JsonTypeSerializer.WhiteSpaceFlags[c]) break; } //Whitespace inline`
	`63`	`+ for (; index < strType.Length; index++) { var c = strType[index]; if (!JsonUtils.IsWhiteSpace(c)) break; } //Whitespace inline`
`64`	`64`	`if (strType[index++] != JsWriter.MapStartChar)`
`65`	`65`	`throw DeserializeTypeRef.CreateSerializationError(type, strType);`
`66`	`66`
`@@ -78,7 +78,7 @@ internal static object StringToType(`
`78`	`78`	`var propertyName = JsonTypeSerializer.ParseJsonString(strType, ref index);`
`79`	`79`
`80`	`80`	`//Serializer.EatMapKeySeperator(strType, ref index);`
`81`		`- for (; index < strType.Length; index++) { var c = strType[index]; if (c >= JsonTypeSerializer.WhiteSpaceFlags.Length \|\| !JsonTypeSerializer.WhiteSpaceFlags[c]) break; } //Whitespace inline`
	`81`	`+ for (; index < strType.Length; index++) { var c = strType[index]; if (!JsonUtils.IsWhiteSpace(c)) break; } //Whitespace inline`
`82`	`82`	`if (strType.Length != index) index++;`
`83`	`83`
`84`	`84`	`var propertyValueStr = Serializer.EatValue(strType, ref index);`
`@@ -152,13 +152,13 @@ internal static object StringToType(`
`152`	`152`	`}`
`153`	`153`
`154`	`154`	`//Serializer.EatItemSeperatorOrMapEndChar(strType, ref index);`
`155`		`- for (; index < strType.Length; index++) { var c = strType[index]; if (c >= JsonTypeSerializer.WhiteSpaceFlags.Length \|\| !JsonTypeSerializer.WhiteSpaceFlags[c]) break; } //Whitespace inline`
	`155`	`+ for (; index < strType.Length; index++) { var c = strType[index]; if (!JsonUtils.IsWhiteSpace(c)) break; } //Whitespace inline`
`156`	`156`	`if (index != strType.Length)`
`157`	`157`	`{`
`158`	`158`	`var success = strType[index] == JsWriter.ItemSeperator \|\| strType[index] == JsWriter.MapEndChar;`
`159`	`159`	`index++;`
`160`	`160`	`if (success)`
`161`		`- for (; index < strType.Length; index++) { var c = strType[index]; if (c >= JsonTypeSerializer.WhiteSpaceFlags.Length \|\| !JsonTypeSerializer.WhiteSpaceFlags[c]) break; } //Whitespace inline`
	`161`	`+ for (; index < strType.Length; index++) { var c = strType[index]; if (!JsonUtils.IsWhiteSpace(c)) break; } //Whitespace inline`
`162`	`162`	`}`
`163`	`163`
`164`	`164`	`continue;`
`@@ -195,13 +195,13 @@ internal static object StringToType(`
`195`	`195`	`}`
`196`	`196`
`197`	`197`	`//Serializer.EatItemSeperatorOrMapEndChar(strType, ref index);`
`198`		`- for (; index < strType.Length; index++) { var c = strType[index]; if (c >= JsonTypeSerializer.WhiteSpaceFlags.Length \|\| !JsonTypeSerializer.WhiteSpaceFlags[c]) break; } //Whitespace inline`
	`198`	`+ for (; index < strType.Length; index++) { var c = strType[index]; if (!JsonUtils.IsWhiteSpace(c)) break; } //Whitespace inline`
`199`	`199`	`if (index != strType.Length)`
`200`	`200`	`{`
`201`	`201`	`var success = strType[index] == JsWriter.ItemSeperator \|\| strType[index] == JsWriter.MapEndChar;`
`202`	`202`	`index++;`
`203`	`203`	`if (success)`
`204`		`- for (; index < strType.Length; index++) { var c = strType[index]; if (c >= JsonTypeSerializer.WhiteSpaceFlags.Length \|\| !JsonTypeSerializer.WhiteSpaceFlags[c]) break; } //Whitespace inline`
	`204`	`+ for (; index < strType.Length; index++) { var c = strType[index]; if (!JsonUtils.IsWhiteSpace(c)) break; } //Whitespace inline`
`205`	`205`	`}`
`206`	`206`
`207`	`207`	`}`
Original file line number	Diff line number	Diff line change
`@@ -4,6 +4,7 @@`
`4`	`4`	`using System;`
`5`	`5`	`using System.Globalization;`
`6`	`6`	`using System.IO;`
	`7`	`+using System.Runtime.CompilerServices;`
`7`	`8`	`using System.Text;`
`8`	`9`	`using ServiceStack.Text.Common;`
`9`	`10`	`using ServiceStack.Text.Pools;`
`@@ -35,16 +36,6 @@ internal static string GetTypeAttrInObject(string typeAttr)`
`35`	`36`	`return string.Format("{{\"{0}\":", typeAttr);`
`36`	`37`	`}`
`37`	`38`
`38`		`- public static readonly bool[] WhiteSpaceFlags = new bool[' ' + 1];`
`39`		`-`
`40`		`- static JsonTypeSerializer()`
`41`		`- {`
`42`		`- foreach (var c in JsonUtils.WhiteSpaceChars)`
`43`		`- {`
`44`		`- WhiteSpaceFlags[c] = true;`
`45`		`- }`
`46`		`- }`
`47`		`-`
`48`	`39`	`public WriteObjectDelegate GetWriteFn<T>()`
`49`	`40`	`{`
`50`	`41`	`return JsonWriter<T>.WriteFn();`
`@@ -343,7 +334,7 @@ public string ParseString(string value)`
`343`	`334`
`344`	`335`	`public static bool IsEmptyMap(string value, int i = 1)`
`345`	`336`	`{`
`346`		`- for (; i < value.Length; i++) { var c = value[i]; if (c >= WhiteSpaceFlags.Length \|\| !WhiteSpaceFlags[c]) break; } //Whitespace inline`
	`337`	`+ for (; i < value.Length; i++) { var c = value[i]; if (!JsonUtils.IsWhiteSpace(c)) break; } //Whitespace inline`
`347`	`338`	`if (value.Length == i) return true;`
`348`	`339`	`return value[i++] == JsWriter.MapEndChar;`
`349`	`340`	`}`
`@@ -393,7 +384,7 @@ public string UnescapeSafeString(string value)`
`393`	`384`
`394`	`385`	`internal static string ParseJsonString(string json, ref int index)`
`395`	`386`	`{`
`396`		`- for (; index < json.Length; index++) { var ch = json[index]; if (ch >= WhiteSpaceFlags.Length \|\| !WhiteSpaceFlags[ch]) break; } //Whitespace inline`
	`387`	`+ for (; index < json.Length; index++) { var ch = json[index]; if (!JsonUtils.IsWhiteSpace(ch)) break; } //Whitespace inline`
`397`	`388`
`398`	`389`	`return UnEscapeJsonString(json, ref index);`
`399`	`390`	`}`
`@@ -558,14 +549,14 @@ public string EatTypeValue(string value, ref int i)`
`558`	`549`
`559`	`550`	`public bool EatMapStartChar(string value, ref int i)`
`560`	`551`	`{`
`561`		`- for (; i < value.Length; i++) { var c = value[i]; if (c >= WhiteSpaceFlags.Length \|\| !WhiteSpaceFlags[c]) break; } //Whitespace inline`
	`552`	`+ for (; i < value.Length; i++) { var c = value[i]; if (!JsonUtils.IsWhiteSpace(c)) break; } //Whitespace inline`
`562`	`553`	`return value[i++] == JsWriter.MapStartChar;`
`563`	`554`	`}`
`564`	`555`
`565`	`556`	`public string EatMapKey(string value, ref int i)`
`566`	`557`	`{`
`567`	`558`	`var valueLength = value.Length;`
`568`		`- for (; i < value.Length; i++) { var c = value[i]; if (c >= WhiteSpaceFlags.Length \|\| !WhiteSpaceFlags[c]) break; } //Whitespace inline`
	`559`	`+ for (; i < value.Length; i++) { var c = value[i]; if (!JsonUtils.IsWhiteSpace(c)) break; } //Whitespace inline`
`569`	`560`
`570`	`561`	`var tokenStartPos = i;`
`571`	`562`	`var valueChar = value[i];`
`@@ -589,7 +580,7 @@ public string EatMapKey(string value, ref int i)`
`589`	`580`
`590`	`581`	`if (valueChar == JsWriter.ItemSeperator`
`591`	`582`	`//If it doesn't have quotes it's either a keyword or number so also has a ws boundary`
`592`		`- \|\| (valueChar < WhiteSpaceFlags.Length && WhiteSpaceFlags[valueChar])`
	`583`	`+ \|\| (JsonUtils.IsWhiteSpace(valueChar))`
`593`	`584`	`)`
`594`	`585`	`{`
`595`	`586`	`break;`
`@@ -601,14 +592,14 @@ public string EatMapKey(string value, ref int i)`
`601`	`592`
`602`	`593`	`public bool EatMapKeySeperator(string value, ref int i)`
`603`	`594`	`{`
`604`		`- for (; i < value.Length; i++) { var c = value[i]; if (c >= WhiteSpaceFlags.Length \|\| !WhiteSpaceFlags[c]) break; } //Whitespace inline`
	`595`	`+ for (; i < value.Length; i++) { var c = value[i]; if (!JsonUtils.IsWhiteSpace(c)) break; } //Whitespace inline`
`605`	`596`	`if (value.Length == i) return false;`
`606`	`597`	`return value[i++] == JsWriter.MapKeySeperator;`
`607`	`598`	`}`
`608`	`599`
`609`	`600`	`public bool EatItemSeperatorOrMapEndChar(string value, ref int i)`
`610`	`601`	`{`
`611`		`- for (; i < value.Length; i++) { var c = value[i]; if (c >= WhiteSpaceFlags.Length \|\| !WhiteSpaceFlags[c]) break; } //Whitespace inline`
	`602`	`+ for (; i < value.Length; i++) { var c = value[i]; if (!JsonUtils.IsWhiteSpace(c)) break; } //Whitespace inline`
`612`	`603`
`613`	`604`	`if (i == value.Length) return false;`
`614`	`605`
`@@ -619,23 +610,23 @@ public bool EatItemSeperatorOrMapEndChar(string value, ref int i)`
`619`	`610`
`620`	`611`	`if (success)`
`621`	`612`	`{`
`622`		`- for (; i < value.Length; i++) { var c = value[i]; if (c >= WhiteSpaceFlags.Length \|\| !WhiteSpaceFlags[c]) break; } //Whitespace inline`
	`613`	`+ for (; i < value.Length; i++) { var c = value[i]; if (!JsonUtils.IsWhiteSpace(c)) break; } //Whitespace inline`
`623`	`614`	`}`
`624`	`615`
`625`	`616`	`return success;`
`626`	`617`	`}`
`627`	`618`
`628`	`619`	`public void EatWhitespace(string value, ref int i)`
`629`	`620`	`{`
`630`		`- for (; i < value.Length; i++) { var c = value[i]; if (c >= WhiteSpaceFlags.Length \|\| !WhiteSpaceFlags[c]) break; } //Whitespace inline`
	`621`	`+ for (; i < value.Length; i++) { var c = value[i]; if (!JsonUtils.IsWhiteSpace(c)) break; } //Whitespace inline`
`631`	`622`	`}`
`632`	`623`
`633`	`624`	`public string EatValue(string value, ref int i)`
`634`	`625`	`{`
`635`	`626`	`var valueLength = value.Length;`
`636`	`627`	`if (i == valueLength) return null;`
`637`	`628`
`638`		`- for (; i < value.Length; i++) { var c = value[i]; if (c >= WhiteSpaceFlags.Length \|\| !WhiteSpaceFlags[c]) break; } //Whitespace inline`
	`629`	`+ for (; i < value.Length; i++) { var c = value[i]; if (!JsonUtils.IsWhiteSpace(c)) break; } //Whitespace inline`
`639`	`630`	`if (i == valueLength) return null;`
`640`	`631`
`641`	`632`	`var tokenStartPos = i;`
`@@ -715,7 +706,7 @@ public string EatValue(string value, ref int i)`
`715`	`706`	`if (valueChar == JsWriter.ItemSeperator`
`716`	`707`	`\|\| valueChar == JsWriter.MapEndChar`
`717`	`708`	`//If it doesn't have quotes it's either a keyword or number so also has a ws boundary`
`718`		`- \|\| (valueChar < WhiteSpaceFlags.Length && WhiteSpaceFlags[valueChar])`
	`709`	`+ \|\| JsonUtils.IsWhiteSpace(valueChar)`
`719`	`710`	`)`
`720`	`711`	`{`
`721`	`712`	`break;`