using System;
using System.Collections.Generic;
using System.IO;
using System.Text;

namespace incparser
{
    enum LexToken
    {
        TOKEN_NONE,
        TOKEN_INCLUDE,
        TOKEN_DEFINE,
        TOKEN_CONST,
        TOKEN_STRUCT,
        TOKEN_FUNCTAG,
        TOKEN_FUNCENUM,
        TOKEN_ENUM,
        TOKEN_NATIVE,
        TOKEN_STOCK,
        TOKEN_PUBLIC,
        TOKEN_FORWARD,
        TOKEN_QUOTCHAR,
        TOKEN_OPERATOR,
        TOKEN_CHARACTER,
        /*TOKEN_STRING,*/
        TOKEN_LABEL,
        TOKEN_SYMBOL,
        TOKEN_DOCBLOCK,
        TOKEN_EOF,
    }

    class ParseException : System.Exception
    {
        public ParseException(string message) : base(message)
        {
        }
    };
         
    class KeywordToken
    {
        public KeywordToken(string k, LexToken t)
        {
            keyword = k;
            token = t;
        }
        public string keyword;
        public LexToken token;
    };

    class Tokenizer
    {
        private static bool s_initialized = false;
        private static int s_position = 0;
        private static KeywordToken [] s_tokens = null;
        public static KeywordToken[] Tokens = null;

        public static void Initialize()
        {
            if (s_initialized)
            {
                return;
            }
            s_tokens = new KeywordToken[12];
            s_initialized = true;
            s_position = 0;

            AddToken("#include", LexToken.TOKEN_INCLUDE);
            AddToken("#define", LexToken.TOKEN_DEFINE);
            AddToken("native", LexToken.TOKEN_NATIVE);
            AddToken("functag", LexToken.TOKEN_FUNCTAG);
            AddToken("funcenum", LexToken.TOKEN_FUNCENUM);
            AddToken("enum", LexToken.TOKEN_ENUM);
            AddToken("stock", LexToken.TOKEN_STOCK);
            AddToken("public", LexToken.TOKEN_PUBLIC);
            AddToken("forward", LexToken.TOKEN_FORWARD);
            AddToken("const", LexToken.TOKEN_CONST);
            AddToken("struct", LexToken.TOKEN_STRUCT);
            AddToken("operator", LexToken.TOKEN_OPERATOR);

            Tokens = s_tokens;
        }

        private static void AddToken(string lex, LexToken tok)
        {
            s_tokens[s_position] = new KeywordToken(lex, tok);
            s_position++;
        }
    };

    class IncParser
    {
        private string FileName;
        private StringBuilder Contents;
        private bool LexPushed;
        private LexToken _LastToken;
        private string _LexString;
        private char _LexChar;
        private uint LineNo;

        public string LexString
        {
            get
            {
                return _LexString;
            }
        }

        public char LexChar
        {
            get
            {
                return _LexChar;
            }
        }

        public uint GetLineNumber()
        {
            return LineNo;
        }

        public IncParser(string file)
        {
            FileName = file;

            /* Clear out lexer stuff */
            LexPushed = false;
            _LastToken = LexToken.TOKEN_NONE;
            _LexString = null;
            _LexChar = '\0';
            LineNo = 1;

            /* Initialize; this can throw an exception */
            Initialize();
        }

        public void Parse(ParseWriter w)
        {
            w.BeginSection(System.IO.Path.GetFileName(FileName));
            LexToken tok = LexToken.TOKEN_NONE;
            while ((tok = lex()) != LexToken.TOKEN_EOF)
            {
                switch (tok)
                {
                    case LexToken.TOKEN_DOCBLOCK:
                        {
                            w.WritePair("doc", LexString);
                            break;
                        }
                    case LexToken.TOKEN_DEFINE:
                        {
                            PARSE_Define(w);
                            break;
                        }
                    case LexToken.TOKEN_ENUM:
                        {
                            PARSE_Enum(w);
                            break;
                        }
                    case LexToken.TOKEN_FORWARD:
                        {
                            PARSE_Function(tok, w);
                            break;
                        }
                    case LexToken.TOKEN_NATIVE:
                        {
                            PARSE_Function(tok, w);
                            break;
                        }
                    case LexToken.TOKEN_STOCK:
                        {
                            PARSE_Function(tok, w);
                            break;
                        }
                    case LexToken.TOKEN_FUNCTAG:
                        {
                            PARSE_FuncTag(w);
                            break;
                        }
                    case LexToken.TOKEN_FUNCENUM:
                        {
                            PARSE_FuncEnum(w);
                            break;
                        }
                    case LexToken.TOKEN_INCLUDE:
                        {
                            PARSE_Include(w);
                            break;
                        }
                    case LexToken.TOKEN_STRUCT:
                        {
                            PARSE_Struct(w);
                            break;
                        }
                    case LexToken.TOKEN_PUBLIC:
                        {
                            PARSE_Public(w);
                            break;
                        }
                    default:
                        {
                            throw new ParseException("Unrecognized token: " + tok);
                        }
                }
            }
            w.EndSection();
        }

        private void PARSE_Public(ParseWriter w)
        {
            /* Eat up an optional tag */
            MatchToken(LexToken.TOKEN_LABEL);
            
            /* Eat up a name */
            NeedToken(LexToken.TOKEN_SYMBOL);

            if (MatchChar('='))
            {
                ignore_block();
            }

            NeedChar(';');
        }

        private void PARSE_Struct(ParseWriter w)
        {
            /* For now, we completely ignore these (they're not written to the output) */
            NeedToken(LexToken.TOKEN_SYMBOL);
            NeedChar('{');

            bool need_closebrace = true;
            bool more_entries = true;
            do
            {
                if (MatchChar('}'))
                {
                    need_closebrace = false;
                    break;
                }
                MatchToken(LexToken.TOKEN_CONST);
                MatchToken(LexToken.TOKEN_LABEL);
                NeedToken(LexToken.TOKEN_SYMBOL);
                while (MatchChar('['))
                {
                    DiscardUntilChar(']');
                    NeedChar(']');
                }
                more_entries = MatchChar(',');
                MatchToken(LexToken.TOKEN_DOCBLOCK);
                if (!more_entries)
                {
                    break;
                }
            } while (true);
            if (need_closebrace)
            {
                NeedChar('}');
            }
            NeedChar(';');
        }

        private void PARSE_Include(ParseWriter w)
        {
            /* read until the end of the line */
            int index = Contents.ToString().IndexOf('\n');
            string value;
            if (index == -1)
            {
                value = Contents.ToString();
                Contents.Remove(0, value.Length);
            }
            else if (index == 0)
            {
                value = "";
            }
            else
            {
                value = Contents.ToString().Substring(0, index);
                Contents.Remove(0, index);
            }

            /* Strip whitespace */
            value = value.Trim('\r', '\t', ' ');

            /* Write */
            w.BeginSection("include");
            w.WritePair("name", value);
            w.EndSection();
        }

        private void PARSE_FuncEnum(ParseWriter w)
        {
            w.BeginSection("funcenum");

            /* Get the functag name */
            NeedToken(LexToken.TOKEN_SYMBOL);
            w.WritePair("name", LexString);

            NeedChar('{');

            bool need_closebrace = true;
            do
            {
                /* Shortcut out? */
                if (MatchChar('}'))
                {
                    need_closebrace = false;
                    break;
                }

                /* Start function section */
                w.BeginSection("function");

                if (MatchToken(LexToken.TOKEN_DOCBLOCK))
                {
                    w.WritePair("doc", LexString);
                }
                
                /* Get the return tag */
                if (MatchToken(LexToken.TOKEN_LABEL))
                {
                    w.WritePair("return", LexString);
                }

                /* Get function type */
                if (MatchToken(LexToken.TOKEN_PUBLIC))
                {
                    w.WritePair("type", "public");
                }
                else if (MatchToken(LexToken.TOKEN_STOCK))
                {
                    w.WritePair("type", "stock");
                }
                
                /* Parse the parameters */
                ParseParameters(w);

                /* End the section */
                w.EndSection();

                if (!MatchChar(','))
                {
                    break;
                }
            } while (true);

            if (need_closebrace)
            {
                NeedChar('}');
            }
            NeedChar(';');

            w.EndSection();
        }

        private void PARSE_FuncTag(ParseWriter w)
        {
            w.BeginSection("functag");

            /* Get the functag name */
            NeedToken(LexToken.TOKEN_SYMBOL);
            w.WritePair("name", LexString);

            if (MatchToken(LexToken.TOKEN_LABEL))
            {
                w.WritePair("return", LexString);
            }

            if (MatchToken(LexToken.TOKEN_PUBLIC))
            {
                w.WritePair("type", "public");
            }
            else if (MatchToken(LexToken.TOKEN_STOCK))
            {
                w.WritePair("type", "stock");
            }

            ParseParameters(w);
            NeedChar(';');
            
            w.EndSection();
        }

        private void PARSE_Function(LexToken tok, ParseWriter w)
        {
            string tag="", name;

            /* Get the return value */
            if (MatchToken(LexToken.TOKEN_LABEL))
            {
                tag = LexString;
            }

            if (MatchToken(LexToken.TOKEN_OPERATOR))
            {
                /* Check if we're some sort of invalid function */
                DiscardUntilCharOrComment('(', false);
                ParseParameters(null);
                if (tok == LexToken.TOKEN_STOCK)
                {
                    ignore_block();
                }
                else if (tok == LexToken.TOKEN_NATIVE || tok == LexToken.TOKEN_FORWARD)
                {
                    if (MatchChar('='))
                    {
                        DiscardUntilCharOrComment(';', false);
                    }
                    NeedChar(';');
                }
                return;
            }

            /* Get the name */
            NeedToken(LexToken.TOKEN_SYMBOL);
            name = LexString;

            PARSE_Function(tok, w, tag, name);
        }

        private void PARSE_Function(LexToken tok, ParseWriter w, string tag, string name)
        {
            if (tok == LexToken.TOKEN_FORWARD)
            {
                w.BeginSection("forward");
            }
            else if (tok == LexToken.TOKEN_NATIVE)
            {
                w.BeginSection("native");
            }
            else if (tok == LexToken.TOKEN_STOCK)
            {
                w.BeginSection("stock");
            }

            w.WritePair("name", name);

            if (tag.Length > 0)
            {
                w.WritePair("return", tag);
            }

            ParseParameters(w);

            if (tok == LexToken.TOKEN_STOCK)
            {
                ignore_block();
            }
            else
            {
                /* Make sure there's a semicolon */
                if (MatchChar('='))
                {
                    DiscardUntilCharOrComment(';', false);
                }
                NeedChar(';');
            }

            w.EndSection();
        }

        private void ParseParameters(ParseWriter w)
        {
            NeedChar('(');
            string extra;
            do
            {
                if (MatchChar(')'))
                {
                    return;
                }

                /* Start the parameter */
                if (w != null)
                {
                    w.BeginSection("parameter");
                }

                /* Check for a 'const' token */
                if (MatchToken(LexToken.TOKEN_CONST) && w != null)
                {
                    w.WritePair("const", "true");
                }

                /* Check if it's by reference */
                if (MatchChar('&') && w != null)
                {
                    w.WritePair("byref", "true");
                }

                /* Check for a tag */
                if (MatchToken(LexToken.TOKEN_LABEL) && w != null)
                {
                    w.WritePair("tag", LexString);
                }

                /* Get the symbol and write it */
                if (MatchString(0, "...") && w != null)
                {
                    w.WritePair("name", "...");
                }
                else
                {
                    NeedToken(LexToken.TOKEN_SYMBOL);
                    if (w != null)
                    {
                        w.WritePair("name", LexString);
                    }
                }

                /* Check if we have a default value yet */
                bool default_value = false;
                if (MatchChar('='))
                {
                    default_value = true;
                }
                else if (MatchChar('['))
                {
                    extra = "";
                    string temp;
                    do
                    {
                        extra += "[";
                        temp = ConsumeUntilChar(']');
                        if (temp != null)
                        {
                            extra += temp;
                        }
                        extra += "]";
                        NeedChar(']');
                    } while (MatchChar('['));
                    w.WritePair("decoration", extra);
                }

                /* If we have a default value, get it */
                if (default_value || MatchChar('='))
                {
                    if ((extra = ConsumeParamDefValue()) == null)
                    {
                        throw new ParseException("Expected a default value; found none");
                    }
                    if (w != null)
                    {
                        w.WritePair("defval", extra);
                    }
                }

                /* End the parameter */
                if (w != null)
                {
                    w.EndSection();
                }

                if (!MatchChar(','))
                {
                    break;
                }
            } while (true);

            NeedChar(')');
        }

        private void PARSE_Enum(ParseWriter w)
        {
            string name = "";
            if (MatchToken(LexToken.TOKEN_SYMBOL))
            {
                name = LexString;
            }

            w.BeginSection("enum");
            w.WritePair("name", name);
            w.BeginSection("properties");

            NeedChar('{');
            bool more_entries = true;
            bool need_closebrace = true;
            do
            {
                if (MatchChar('}'))
                {
                    need_closebrace = false;
                    break;
                }
                NeedToken(LexToken.TOKEN_SYMBOL);
                name = LexString;
                if (MatchChar('='))
                {
                    DiscardUntilCharOrComment(',', true);
                }
                more_entries = MatchChar(',');
                w.WritePair("name", name);
                if (MatchToken(LexToken.TOKEN_DOCBLOCK))
                {
                    w.WritePair("doc", LexString);
                }
            } while (more_entries);
            if (need_closebrace)
            {
                NeedChar('}');
            }
            NeedChar(';');
            w.EndSection();
            w.EndSection();
        }

        private void PARSE_Define(ParseWriter w)
        {
            /* first, get the symbol name */
            NeedToken(LexToken.TOKEN_SYMBOL);
            string name = LexString;
            string value;

            /* read until we hit the end of a line OR a comment */
            int endpoint = -1;
            for (int i = 0; i < Contents.Length; i++)
            {
                if (Contents[i] == '\n')
                {
                    endpoint = i;
                    break;
                }
                else if (CheckString(i, "/**"))
                {
                    endpoint = i;
                    break;
                }
            }

            if (endpoint < 1)
            {
                value = "";
            }
            else
            {
                value = Contents.ToString().Substring(0, endpoint);
                Contents.Remove(0, endpoint);
            }

            /* Write */
            w.BeginSection("define");
            w.WritePair("name", name);
            w.WritePair("linetext", value);
            w.EndSection();
        }

        /* Reads up to a character and discards all text before it.
         */
        private void DiscardUntilChar(char c)
        {
            int eol = Contents.ToString().IndexOf(c);

            if (eol < 1)
            {
                return;
            }

            Contents.Remove(0, eol);
        }

        /* Same as DiscardUntilChar, except the discarded
         * text is returned first.
         */
        private string ConsumeUntilChar(char c)
        {
            int eol = Contents.ToString().IndexOf(c);

            if (eol < 1)
            {
                return null;
            }

            string rest = Contents.ToString().Substring(0, eol);
            Contents.Remove(0, eol);
            return rest;
        }

        /**
         * Returns a parameter's default value.
         */
        private string ConsumeParamDefValue()
        {
            int eol = FindEndOfExprLine(0);
            if (eol < 1)
            {
                return null;
            }

            string rest = Contents.ToString().Substring(0, eol);
            Contents.Remove(0, eol);
            return rest;
        }

        /**
         * Discards all data up to a certain character, ignoring
         * the contents, unless specified to stop at a doc block comment.
         */
        private void DiscardUntilCharOrComment(char c, bool stop_at_comment)
        {
            for (int i = 0; i < Contents.Length; i++)
            {
                if (Contents[i] == '\n')
                {
                    LineNo++;
                }
                else if (Contents[i] == c)
                {
                    if (i > 0)
                    {
                        Contents.Remove(0, i);
                    }
                    return;
                }
                else if (stop_at_comment && CheckString(i, "/**"))
                {
                    if (i > 0)
                    {
                        Contents.Remove(0, i);
                    }
                    return;
                }
            }
        }

        /**
         * Finds the end of an expression
         */
        private int FindEndOfExprLine(int start)
        {
            for (int i = start; i < Contents.Length; i++)
            {
                if (Contents[i] == '{')
                {
                    if ((i = FindEndOfConsumptionLine('}', start+1)) == -1)
                    {
                        throw new ParseException("Expected token: } (found none)");
                    }
                }
                else if (Contents[i] == ')' || Contents[i] == ',')
                {
                    return i;
                }
            }

            return -1;
        }

        private int FindEndOfConsumptionLine(char c, int start)
        {
            for (int i = start; i < Contents.Length; i++)
            {
                if (Contents[i] == '{')
                {
                    if ((i = FindEndOfConsumptionLine('}', i + 1)) == -1)
                    {
                        throw new ParseException("Expected token: } (found none)");
                    }
                }
                else if (Contents[i] == c)
                {
                    return i;
                }
            }

            return -1;
        }

        private void Initialize()
        {
            /* Open file, read it, and close it */
            StreamReader sr = File.OpenText(FileName);
            Contents = new StringBuilder(sr.ReadToEnd());
            sr.Close();

            /* Strip comments (may throw an exception) */
            preprocess();

            /* Lastly, initialize the tokenizer */
            Tokenizer.Initialize();
        }

        /* Consumes a token iff it matches */
        private bool MatchToken(LexToken token)
        {
            LexToken tok = lex();
            if (tok != token)
            {
                lexpush();
                return false;
            }
            return true;
        }

        /* Consumes a token and aborts the parser if there is no match */
        private void NeedToken(LexToken token)
        {
            if (!MatchToken(token))
            {
                throw new ParseException("Expected token: " + token);
            }
        }

        /* Consumes a character iff it matches */
        private bool MatchChar(char c)
        {
            if (lex() != LexToken.TOKEN_CHARACTER)
            {
                lexpush();
                return false;
            }
            if (_LexChar != c)
            {
                lexpush();
                return false;
            }
            return true;
        }

        /* Consumes a character or aborts the parser if there is no match */
        private void NeedChar(char c)
        {
            if (!MatchChar(c))
            {
                throw new ParseException("Expected character: " + c);
            }
        }
        
        /* Saves the lexer state so we don't reparse unnecessarily */
        private void lexpush()
        {
            if (LexPushed)
            {
                throw new ParseException("Lexer cannot be pushed twice");
            }
            LexPushed = true;
        }

        /* Attempts to match a string against the next stream tokens.
         * On success, the token stream is advanced.
         */
        private bool MatchString(int startPos, string str)
        {
            if (str.Length > Contents.Length - startPos)
            {
                return false;
            }
            for (int i = 0; i < str.Length; i++)
            {
                if (str[i] != Contents[startPos + i])
                {
                    return false;
                }
            }
            Contents.Remove(startPos, str.Length);
            return true;
        }

        /* Attempts to match a string against the next stream tokens */
        private bool CheckString(int startPos, string str)
        {
            if (str.Length > Contents.Length - startPos)
            {
                return false;
            }
            for (int i = 0; i < str.Length; i++)
            {
                if (str[i] != Contents[startPos + i])
                {
                    return false;
                }
            }
            return true;
        }

        /* Ignores a block starting and ending with { and } respectively */
        private void ignore_block()
        {
            /* Hrm, this is tricky.  First, expect an open brace. */
            NeedChar('{');
            /* Consume the entire function by keeping track of braces */
            int numBraces = 1;
            bool in_string = false;
            bool found_end = false;
            for (int i = 0; i < Contents.Length; i++)
            {
                if (Contents[i] == '\n')
                {
                    LineNo++;
                }
                if (!in_string)
                {
                    if (Contents[i] == '"')
                    {
                        in_string = true;
                    }
                    else if (Contents[i] == '{')
                    {
                        numBraces++;
                    }
                    else if (Contents[i] == '}')
                    {
                        if (numBraces == 0)
                        {
                            throw new ParseException("Unable to find a matching open brace");
                        }
                        if (--numBraces == 0)
                        {
                            Contents.Remove(0, i + 1);
                            found_end = true;
                            break;
                        }
                    }
                }
                else
                {
                    /* It is possible to be in a string and at the first character */
                    if (Contents[i] == '"' && Contents[i - 1] != '\\')
                    {
                        in_string = false;
                    }
                }
            }
            if (!found_end)
            {
                throw new ParseException("Unable to find a matching close brace");
            }
        }

        /* Strips all non-doc C and C++ style comments. as well as unused pragmas */
        private void preprocess()
        {
            if (Contents.Length == 1)
            {
                return;
            }

            bool in_comment = false;
            bool is_ml = false;
            bool is_doc = false;
            bool is_newline = true;

            for (int i=0; i<Contents.Length-1; i++)
            {
                if (Contents[i] == '\n')
                {
                    is_newline = true;
                }
                if (!in_comment)
                {
                    if (Contents[i] == '/')
                    {
                        if (Contents[i+1] == '/')
                        {
                            in_comment = true;
                            is_ml = false;
                            is_doc = false;
                        } else if (Contents[i+1] == '*') {
                            /* Detect whether this is a doc comment or not */
                            if (Contents.Length - i >= 3
                                && Contents[i+2] == '*')
                            {
                                is_doc = true;
                            } else {
                                is_doc = false;
                            }
                            in_comment = true;
                            is_ml = true;
                        }
                        if (in_comment && !is_doc)
                        {
                            Contents[i] = ' ';
                            Contents[i+1] = ' ';        /* Just for safety */
                        }
                    }
                    else if (is_newline)
                    {
                        if (Contents[i] == '#')
                        {
                            if (!CheckString(i, "#define")
                                && !CheckString(i, "#include"))
                            {
                                /* Ignore! */
                                Contents[i] = ' ';
                                in_comment = true;
                                is_doc = false;
                                is_ml = false;
                            }
                            is_newline = false;
                        }
                        else if (!Char.IsWhiteSpace(Contents[i]))
                        {
                            is_newline = false;
                        }
                    }
                } else {
                    if (is_ml)
                    {
                        if (Contents[i] == '*' && Contents[i+1] == '/')
                        {
                            if (!is_doc)
                            {
                                Contents[i] = ' ';
                                Contents[i+1] = ' ';
                            }
                            in_comment = false;
                            i++;    /* Don't look at the next character */
                        }
                        else if (!is_doc && Contents[i] != '\n')
                        {
                            /* Erase comment */
                            Contents[i] = ' ';
                        }
                    } else {
                        if (is_newline)
                        {
                            in_comment = false;
                        }
                        else
                        {
                            /* Erase comment */
                            Contents[i] = ' ';
                        }
                    }
                }
            }

            if (in_comment)
            {
                throw new ParseException("Multi-line comment has no terminator");
            }
        }

        /* Strips whitespace */
        private void trim_whitespace_pre()
        {
            int spaces = 0;
            while (spaces < Contents.Length
                   && Contents[spaces] != '\0'
                   && Char.IsWhiteSpace(Contents[spaces]))
            {
                if (Contents[spaces] == '\n')
                {
                    LineNo++;
                }
                spaces++;
            }
            if (spaces > 0)
            {
                Contents.Remove(0, spaces);
            }
        }

        private void preprocess_line()
        {
            trim_whitespace_pre();
        }

        private bool IsSymbolChar(char c, bool first)
        {
            bool valid = (first ? Char.IsLetter(c) : Char.IsLetterOrDigit(c));
            return (valid || (c == '_'));
        }

        private bool IsEscapedChar(char c)
        {
            return (c == 'n'
                    || c == 'r'
                    || c == 't'
                    || c == 'v'
                    || c == '\\'
                    || c == '"');
        }

        private bool IsNotKeywordChar(char c)
        {
            return (Char.IsWhiteSpace(c)
                    || (c == '-' || c == '+')
                    || (c == '/' || c == '*')
                    || (c == '(' || c == ')')
                    || (c == '=' || c == '%')
                    || (c == '>' || c == '<')
                    || (c == '!' || c == '~')
                    );
        }

        /* Consumes one lexical token and gathers information about it */
        private LexToken lex()
        {
            if (LexPushed)
            {
                LexPushed = false;
                return _LastToken;
            }

            /* Number of chars we will be deleting from the input */
            int stripchars = 0;

            /* Clear our state */
            _LastToken = LexToken.TOKEN_NONE;

            /* Remove stuff we don't want from the line */
            preprocess_line();

            if (Contents.Length < 1)
            {
                _LastToken = LexToken.TOKEN_EOF;
                return _LastToken;
            }
            
            /* Get the token list */
            KeywordToken[] tokens = Tokenizer.Tokens;
            for (int i = 0; i < tokens.Length; i++)
            {
                if (!CheckString(0, tokens[i].keyword))
                {
                    continue;
                }
                int len = tokens[i].keyword.Length;
                /* Now check to see what the next token is */
                if (Contents.Length == len
                    || IsNotKeywordChar(Contents[len]))
                {
                    /* We have a token match! */
                    _LastToken = tokens[i].token;
                    _LexString = null;
                    _LexChar = '\0';
                    stripchars = len;
                    break;
                }
            }

            if (_LastToken == LexToken.TOKEN_NONE)
            {
                /* See if we can try to read a symbol */
                if (IsSymbolChar(Contents[0], true))
                {
                    int characters = 1;
                    while (Contents[characters] != '\0'
                           && IsSymbolChar(Contents[characters], false))
                    {
                        characters++;
                    }
                    stripchars = characters;
                    /* We're done! See what's next.. */
                    if (Contents[characters] == ':')
                    {
                        _LastToken = LexToken.TOKEN_LABEL;
                        stripchars++;
                    }
                    else
                    {
                        _LastToken = LexToken.TOKEN_SYMBOL;
                    }
                    _LexString = Contents.ToString().Substring(0, characters);
                    _LexChar = _LexString[0];
                }/*
                else if (Contents[0] == '"')
                {
                    bool reached_end = false;
                    StringBuilder builder = new StringBuilder();
                    for (int i = 1; i < Contents.Length; i++)
                    {
                        if (i < Contents.Length - 1
                            && Contents[i] == '\\'
                            && IsEscapedChar(Contents[i+1]))
                        {
                            i++;
                        }
                        else if (Contents[i] == '"')
                        {
                            reached_end = true;
                            break;
                        }
                        builder.Append(Contents[i]);
                    }
                    if (!reached_end)
                    {
                        throw new ParseException("Expected end of string; none found");
                    }
                    _LexString = builder.ToString();
                    _LexChar = _LexString.Length > 0 ? _LexString[0] : '\0';
                }*/
                else if (Contents[0] == '\'')
                {
                    char c = '\0';
                    if (Contents.Length < 3)
                    {
                        throw new ParseException("Expected end of character; none found");
                    }
                    else if (Contents[1] == '\\')
                    {
                        if (Contents.Length < 4 || !IsEscapedChar(Contents[2]))
                        {
                            throw new ParseException("Expected end of character; none found");
                        }
                        if (Contents[2] == 'r')
                        {
                            c = '\r';
                        }
                        else if (Contents[2] == 'n')
                        {
                            c = '\n';
                        }
                        else if (Contents[2] == 't')
                        {
                            c = '\t';
                        }
                        else if (Contents[2] == 'v')
                        {
                            c = '\v';
                        }
                        else if (Contents[2] == '\\')
                        {
                            c = '\\';
                        }
                        else if (Contents[2] == '"')
                        {
                            c = '"';
                        }
                        stripchars = 4;
                    }
                    else
                    {
                        c = Contents[1];
                        stripchars = 3;
                    }
                    _LexString = c.ToString();
                    _LexChar = c;
                    _LastToken = LexToken.TOKEN_QUOTCHAR;
                }
                else if (CheckString(0, "/**"))
                {
                    int endpoint = 0;
                    for (int i=3; i<Contents.Length-1; i++)
                    {
                        if (Contents[i] == '\n')
                        {
                            LineNo++;
                        }
                        else if (Contents[i] == '*' && Contents[i+1] == '/')
                        {
                            endpoint = i+1;
                            break;
                        }
                    }
                    if (endpoint == 0)
                    {
                        throw new ParseException("Expected end of multi-line comment; found end of file");
                    }
                    /* We have to factor one more character in because we're zero based */
                    endpoint++;
                    _LastToken = LexToken.TOKEN_DOCBLOCK;
                    _LexString = Contents.ToString().Substring(0, endpoint);
                    _LexChar = _LexString[0];
                    stripchars = endpoint;
                }
                else
                {
                    _LastToken = LexToken.TOKEN_CHARACTER;
                    _LexString = Contents[0].ToString();
                    _LexChar = Contents[0];
                    stripchars = 1;
                }
            }

            /* Strip N chars */
            if (stripchars > 0)
            {
                Contents.Remove(0, stripchars);
            }

            return _LastToken;
        }
    }
}
