Pastebin launched a little side project called HostCabi.net, check it out ;-)Don't like ads? PRO users don't see any ads ;-)
Guest

JSON Parser

By: a guest on Apr 16th, 2010  |  syntax: C#  |  size: 5.65 KB  |  hits: 309  |  expires: Never
download  |  raw  |  embed  |  report abuse  |  print
Text below is selected. Please press Ctrl+C to copy to your clipboard. (⌘+C on Mac)
  1. private static JsonStructure Parse(string jsonText, bool throwException)
  2. {
  3.     var result = default(JsonStructure);
  4.     var structureStack = new Stack<JsonStructure>();
  5.     var keyStack = new Stack<string>();
  6.     var current = default(JsonStructure);
  7.     var currentState = ParserState.Begin;
  8.     var invalidToken = false;
  9.     var key = default(string);
  10.     var value = default(object);
  11.  
  12.     foreach (var token in Lexer.Tokenize(jsonText))
  13.     {
  14.         switch (currentState)
  15.         {
  16.             case ParserState.Begin:
  17.                 switch (token.Type)
  18.                 {
  19.                     case TokenType.OpenBrace:
  20.                         currentState = ParserState.ObjectKey;
  21.                         current = result = new JsonObject();
  22.                         break;
  23.                     case TokenType.OpenBracket:
  24.                         currentState = ParserState.ArrayValue;
  25.                         current = result = new JsonArray();
  26.                         break;
  27.                     default:
  28.                         invalidToken = true;
  29.                         break;
  30.                 }
  31.                 break;
  32.             case ParserState.ObjectKey:
  33.                 switch (token.Type)
  34.                 {
  35.                     case TokenType.StringLiteral:
  36.                         currentState = ParserState.ColonSeperator;
  37.                         key = (string)token.Value;
  38.                         break;
  39.                     default:
  40.                         invalidToken = true;
  41.                         break;
  42.                 }
  43.                 break;
  44.             case ParserState.ColonSeperator:
  45.                 switch (token.Type)
  46.                 {
  47.                     case TokenType.Colon:
  48.                         currentState = ParserState.ObjectValue;
  49.                         break;
  50.                     default:
  51.                         invalidToken = true;
  52.                         break;
  53.                 }
  54.                 break;
  55.             case ParserState.ObjectValue:
  56.             case ParserState.ArrayValue:
  57.                 switch (token.Type)
  58.                 {
  59.                     case TokenType.NumberLiteral:
  60.                     case TokenType.StringLiteral:
  61.                     case TokenType.BooleanLiteral:
  62.                     case TokenType.NullLiteral:
  63.                         currentState = ParserState.ItemEnd;
  64.                         value = token.Value;
  65.                         break;
  66.                     case TokenType.OpenBrace:
  67.                         structureStack.Push(current);
  68.                         keyStack.Push(key);
  69.                         currentState = ParserState.ObjectKey;
  70.                         current = new JsonObject();
  71.                         break;
  72.                     case TokenType.OpenBracket:
  73.                         structureStack.Push(current);
  74.                         currentState = ParserState.ArrayValue;
  75.                         current = new JsonArray();
  76.                         break;
  77.                     default:
  78.                         invalidToken = true;
  79.                         break;
  80.                 }
  81.                 break;
  82.             case ParserState.ItemEnd:
  83.                 var jsonObject = (current as JsonObject);
  84.                 if (jsonObject != null)
  85.                 {
  86.                     jsonObject.Add(key, value);
  87.                     currentState = ParserState.ObjectKey;
  88.                 }
  89.                 var jsonArray = (current as JsonArray);
  90.                 if (jsonArray != null)
  91.                 {
  92.                     jsonArray.Add(value);
  93.                     currentState = ParserState.ArrayValue;
  94.                 }
  95.                 switch (token.Type)
  96.                 {
  97.                     case TokenType.CloseBrace:
  98.                     case TokenType.CloseBracket:
  99.                         currentState = ParserState.End;
  100.                         break;
  101.                     case TokenType.Comma:
  102.                         break;
  103.                     default:
  104.                         invalidToken = true;
  105.                         break;
  106.                 }
  107.                 break;
  108.             case ParserState.End:
  109.                 switch (token.Type)
  110.                 {
  111.                     case TokenType.CloseBrace:
  112.                     case TokenType.CloseBracket:
  113.                     case TokenType.Comma:
  114.                         var previous = structureStack.Pop();
  115.                         var previousJsonObject = (previous as JsonObject);
  116.                         if (previousJsonObject != null)
  117.                         {
  118.                             currentState = ParserState.ObjectKey;
  119.                             previousJsonObject.Add(keyStack.Pop(), current);
  120.                         }
  121.                         var previousJsonArray = (previous as JsonArray);
  122.                         if (previousJsonArray != null)
  123.                         {
  124.                             currentState = ParserState.ArrayValue;
  125.                             previousJsonArray.Add(current);
  126.                         }
  127.                         current = previous;
  128.                         if (token.Type != TokenType.Comma)
  129.                         {
  130.                             currentState = ParserState.End;
  131.                         }
  132.                         break;
  133.                     default:
  134.                         invalidToken = true;
  135.                         break;
  136.                 }
  137.                 break;
  138.             default:
  139.                 break;
  140.         }
  141.  
  142.         if (invalidToken)
  143.         {
  144.             if (throwException)
  145.             {
  146.                 throw new JsonException(token);
  147.             }
  148.             return null;
  149.         }
  150.     }
  151.     return result;
  152. }