root/lang/csharp/IrcSendOnly/syntax.cs

/*=====================================================================
  This file is part of the Microsoft Live Communications Code Samples.

  Copyright (C) 2005, 2006 Microsoft Corporation.  All rights reserved.

This source code is intended only as a supplement to Microsoft
Development Tools and/or on-line documentation.  See these other
materials for detailed information regarding Microsoft code samples.

THIS CODE AND INFORMATION ARE PROVIDED "AS IS" WITHOUT WARRANTY OF ANY
KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
PARTICULAR PURPOSE.
=====================================================================*/

using System;
using System.Collections;
using System.Globalization;
using System.IO;
using System.Text;
using System.Text.RegularExpressions;

namespace JsonApi
{
    internal class Undefined { }

    public class Parser
    {
        private Token token;

        private ArrayList parse_array()
        {
            ArrayList array = new ArrayList();
            Token original = token;

            token = token.Next;
            if (token.Type != Token.Types.Symbol || token.Value != "[")
            {
                token = original;
                return null;
            }
            while (true)
            {
                object value = parse_value();

                token = token.Next;
                if (value == null)
                {
                    break;
                }

                array.Add(value is Undefined ? null : value);

                if (token.Type != Token.Types.Symbol || token.Value != ",")
                {
                    break;
                }
            }
            if (token.Type != Token.Types.Symbol || token.Value != "]")
            {
                token = original;
                return null;
            }
            return array;
        }

        private Hashtable parse_object()
        {
            Hashtable hashtable = new Hashtable(CaseInsensitiveHashCodeProvider.DefaultInvariant, CaseInsensitiveComparer.DefaultInvariant);
            Token original = token;

            token = token.Next;
            if (token.Type != Token.Types.Symbol || token.Value != "{")
            {
                token = original;
                return null;
            }
            while (true)
            {
                token = token.Next;
                if (token.Type != Token.Types.Literal)
                {
                    break;
                }

                string key = token.Value;

                token = token.Next;
                if (token.Type != Token.Types.Symbol || token.Value != ":")
                {
                    token = original;
                    return null;
                }

                object value = parse_value();
                if (value == null)
                {
                    token = original;
                    return null;
                }
                hashtable[key] = value is Undefined ? null : value;

                token = token.Next;
                if (token.Type != Token.Types.Symbol || token.Value != ",")
                {
                    break;
                }
            }
            if (token.Type != Token.Types.Symbol || token.Value != "}")
            {
                token = original;
                return null;
            }
            return hashtable;
        }

        private object parse_value()
        {
            Token original = token;
            object value;

            token = token.Next;
            if (token.Type == Token.Types.Keyword)
            {
                if (token.Value == "false")
                {
                    return false;
                }
                else if (token.Value == "null")
                {
                    return new Undefined();
                }
                else if (token.Value == "true")
                {
                    return true;
                }
            }
            else if (token.Type == Token.Types.Literal)
            {
                return token.Value;
            }
            else if (token.Type == Token.Types.Number)
            {
                return double.Parse(token.Value);
            }
            token = original;
            if ((value = parse_object()) != null)
            {
                return value;
            }
            else if ((value = parse_array()) != null)
            {
                return value;
            }
            return null;
        }

        public Parser(string s)
        {
            // inject symbol to create dummy token
            token = new Token(":" + s);
        }

        public Hashtable Parse()
        {
            Hashtable hashtable = parse_object();
            return token.Type != Token.Types.Error && token.Tail == string.Empty ? hashtable : null;
        }
    }

    public class Token
    {
        private const string REGEX_ESCAPE = @"\\""|\\/|\\\\|\\b|\\f|\\n|\\r|\\t|\\u(?<unicode>[0-9a-fA-F][0-9a-fA-F][0-9a-fA-F][0-9a-fA-F])";
        private const string REGEX_KEYWORD = @"false|null|true";
        private const string REGEX_NUMBER = @"-?(?:0|[1-9]+)(?:\.[1-9]+)?(?:(?:e|E)(?:-|\+)?[1-9]+)?";
        private const string REGEX_SYMBOL = @"{|}|:|,|\[|\]";

        private static Regex regex = new Regex(string.Format(@"^\s*(?:(?<keyword>{0})|""(?<literal>(?:[^""\\]|{1})*)""|(?<number>{2})|(?<symbol>{3}))\s*(?<tail>.*)$", REGEX_KEYWORD, REGEX_ESCAPE, REGEX_NUMBER, REGEX_SYMBOL), RegexOptions.Compiled | RegexOptions.Singleline);

        private Types type;
        private string tail;
        private string value;

        public enum Types { Error, Keyword, Literal, Number, Symbol };

        static private string OnUnescapeLiteral(Match m)
        {
            // check parameter(s)
            if (m == null)
            {
                throw new ArgumentNullException("m");
            }
            if (!m.Success)
            {
                throw new ArgumentException("invalid Match");
            }

            switch (m.Value)
            {
                case @"\""": return "\"";
                case @"\/": return "/";
                case @"\\": return "\\";
                case @"\b": return "\b";
                case @"\f": return "\f";
                case @"\n": return "\n";
                case @"\r": return "\r";
                case @"\t": return "\t";
            }

            Group g = m.Groups["unicode"];
            return g != null && g.Success
                ? new string(new char[] { (char)int.Parse(g.Value, NumberStyles.HexNumber) })
                : string.Empty;
        }

        public Token Next
        {
            get
            {
                return type != Types.Error ? new Token(tail) : this;
            }
        }
        public string Tail
        {
            get { return tail; }
        }
        public Types Type
        {
            get { return type; }
        }
        public string Value
        {
            get { return value; }
        }

        public Token(string s)
        {
            type = Types.Error;
            tail = s;
            value = null;

            if (s != null)
            {
                Group g;
                Match m = regex.Match(s);

                if (m.Success)
                {
                    if ((g = m.Groups["keyword"]) != null && g.Success)
                    {
                        type = Types.Keyword;
                        value = g.Value;
                    }
                    else if ((g = m.Groups["literal"]) != null && g.Success)
                    {
                        type = Types.Literal;
                        value = Regex.Replace(g.Value, REGEX_ESCAPE, new MatchEvaluator(OnUnescapeLiteral));
                    }
                    else if ((g = m.Groups["number"]) != null && g.Success)
                    {
                        type = Types.Number;
                        value = g.Value;
                    }
                    else if ((g = m.Groups["symbol"]) != null && g.Success)
                    {
                        type = Types.Symbol;
                        value = g.Value;
                    }
                    tail = (g = m.Groups["tail"]) != null && g.Success ? g.Value : string.Empty;
                }
            }
        }
    }

    
}