/// <summary>
        /// 将json字符串归一化,将有用的信息保留,让其更加紧凑
        /// </summary>
        public string PretreatmentProc()
        {
            string temp = "";
            //string tempWord = "";

            int i   = 0;
            int end = 0;

            while (i < originData.Length)
            {
                //跳过那些无用的字符 ' ', '\t', '\r' '\n'
                if (!string.IsNullOrEmpty(LexicalAnalysis.isSpecialSymbol(originData, i, ref end)))
                {
                    i = end;
                    continue;
                }

                //跳过注释
                if (!string.IsNullOrEmpty(/*tempWord = */ LexicalAnalysis.isComment(originData, i, ref end)))
                {
                    //Debug.Log(tempWord);
                    i = end;
                    continue;
                }
                temp += originData[i];
                i++;
            }

            return(temp);
        }
        private JsonSymbolItem buildSymbolItem(JsonSymbolItem rLastSymbol, int begin, ref int end)
        {
            if (originData[begin] == '{')
            {
                end = begin + 1;
                return(new JsonSymbolItem()
                {
                    value = "{", type = JsonSymbolType.ObjStart
                });
            }
            else if (originData[begin] == '}')
            {
                end = begin + 1;
                return(new JsonSymbolItem()
                {
                    value = "}", type = JsonSymbolType.ObjEnd
                });
            }
            else if (originData[begin] == '[')
            {
                end = begin + 1;
                return(new JsonSymbolItem()
                {
                    value = "[", type = JsonSymbolType.ArrayStart
                });
            }
            else if (originData[begin] == ']')
            {
                end = begin + 1;
                return(new JsonSymbolItem()
                {
                    value = "]", type = JsonSymbolType.ArrayEnd
                });
            }
            else if (originData[begin] == ',')
            {
                end = begin + 1;
                return(new JsonSymbolItem()
                {
                    value = ",", type = JsonSymbolType.ObjSplit
                });
            }
            else if (originData[begin] == ':')
            {
                end = begin + 1;
                return(new JsonSymbolItem()
                {
                    value = ":", type = JsonSymbolType.ElementSplit
                });
            }

            string tempWord = "";

            //如果是关键字、数字或者字符串
            if (!string.IsNullOrEmpty(tempWord = LexicalAnalysis.isKeyword(originData, begin, ref end)))
            {
                JsonSymbolItem rSymbol = new JsonSymbolItem()
                {
                    value = tempWord, type = JsonSymbolType.Value, node = new JsonData(tempWord)
                };
                LexicalAnalysis.isSpecialSymbol(originData, end, ref end);
                if (originData[end] == ':')
                {
                    rSymbol.type = JsonSymbolType.Key;
                    rSymbol.node = null;
                }
                return(rSymbol);
            }
            if (!string.IsNullOrEmpty(tempWord = LexicalAnalysis.isDigit(originData, begin, ref end)))
            {
                JsonSymbolItem rSymbol = new JsonSymbolItem()
                {
                    value = tempWord, type = JsonSymbolType.Value, node = new JsonData(tempWord)
                };
                LexicalAnalysis.isSpecialSymbol(originData, end, ref end);
                if (originData[end] == ':')
                {
                    rSymbol.type = JsonSymbolType.Key;
                    rSymbol.node = null;
                }
                return(rSymbol);
            }
            if (!string.IsNullOrEmpty(tempWord = LexicalAnalysis.isString(originData, begin, ref end)))
            {
                tempWord = tempWord.Substring(1, tempWord.Length - 2);
                JsonSymbolItem rSymbol = new JsonSymbolItem()
                {
                    value = tempWord, type = JsonSymbolType.Value, node = new JsonData(tempWord)
                };
                LexicalAnalysis.isSpecialSymbol(originData, end, ref end);
                if (originData[end] == ':')
                {
                    rSymbol.type = JsonSymbolType.Key;
                    rSymbol.node = null;
                }
                return(rSymbol);
            }
            //Debug.Log(string.Format("Json parse symbol item error! LastSymbol = {0}",
            //               rLastSymbol != null ? rLastSymbol.value : "null"));
            isValid = false;
            return(null);
        }
        /// <summary>
        /// 解析Json
        /// </summary>
        public JsonNode Parser()
        {
            this.isValid = true;
            int end = 0;
            int i   = 0;

            JsonSymbolItem rCurSymbol  = null;
            JsonSymbolItem rLastSymbol = null;

            Stack <JsonSymbolItem> rNodeStack = new Stack <JsonSymbolItem>();

            while (i < this.originData.Length)
            {
                //跳过那些无用的字符 ' ', '\t', '\r' '\n' 注释
                if (!string.IsNullOrEmpty(LexicalAnalysis.isSpecialSymbol(originData, i, ref end)) || !string.IsNullOrEmpty(LexicalAnalysis.isComment(originData, i, ref end)))
                {
                    i = end;
                    continue;
                }

                rCurSymbol = buildSymbolItem(rLastSymbol, i, ref end);
                if (rCurSymbol != null)
                {
                    switch (rCurSymbol.type)
                    {
                    case JsonSymbolType.Unknown:
                        Model.Log.Error("Json format error.");
                        break;

                    case JsonSymbolType.ObjStart:
                        rCurSymbol.node = new JsonClass();
                        rNodeStack.Push(rCurSymbol);
                        break;

                    case JsonSymbolType.ObjEnd:
                        JsonNode rObject0 = new JsonClass();
                        while (rNodeStack.Count != 0 && rNodeStack.Peek().type != JsonSymbolType.ObjStart)
                        {
                            var rTopSymbol = rNodeStack.Pop();
                            if (rTopSymbol.type == JsonSymbolType.ObjSplit)
                            {
                                continue;
                            }
                            else if (rTopSymbol.type == JsonSymbolType.Element)
                            {
                                rObject0.AddHead(rTopSymbol.node.Key, rTopSymbol.node[rTopSymbol.node.Key]);
                            }
                        }
                        rNodeStack.Pop();
                        var rSymbol0 = new JsonSymbolItem();
                        rSymbol0.type  = JsonSymbolType.Value;
                        rSymbol0.node  = rObject0;
                        rSymbol0.value = rObject0.ToString();
                        Generate_ElementSymbol(ref rNodeStack, rSymbol0);
                        break;

                    case JsonSymbolType.ArrayStart:
                        rCurSymbol.node = new JsonArray();
                        rNodeStack.Push(rCurSymbol);
                        break;

                    case JsonSymbolType.ArrayEnd:
                        JsonNode rArray = new JsonArray();
                        while (rNodeStack.Peek().type != JsonSymbolType.ArrayStart)
                        {
                            var rTopSymbol = rNodeStack.Pop();
                            if (rTopSymbol.type == JsonSymbolType.ObjSplit)
                            {
                                continue;
                            }
                            else if (rTopSymbol.type == JsonSymbolType.Element)
                            {
                                rArray.AddHead(rTopSymbol.node);
                            }
                        }
                        rNodeStack.Pop();
                        var rSymbol = new JsonSymbolItem();
                        rSymbol.type  = JsonSymbolType.Value;
                        rSymbol.node  = rArray;
                        rSymbol.value = rArray.ToString();
                        Generate_ElementSymbol(ref rNodeStack, rSymbol);
                        break;

                    case JsonSymbolType.ObjSplit:
                        rNodeStack.Push(rCurSymbol);
                        break;

                    case JsonSymbolType.ElementSplit:
                        rNodeStack.Push(rCurSymbol);
                        break;

                    case JsonSymbolType.Key:
                        rNodeStack.Push(rCurSymbol);
                        break;

                    case JsonSymbolType.Value:
                        Generate_ElementSymbol(ref rNodeStack, rCurSymbol);
                        break;

                    default:
                        break;
                    }
                    i           = end;
                    rLastSymbol = rCurSymbol;
                    continue;
                }
                i++;
            }
            return(rNodeStack.Peek().node);
        }