public IToken Produce()
        {
            var context = this.Context;
            var text    = context.Text;
            var length  = text.Length;

            var c = text[context.Index];

            if (LexingHelper.IsLatinLetter(c) || c == '_')
            {
                var initialIndex = context.Index;
                var index        = initialIndex + 1;
                var column       = context.Column + 1;

                while (true)
                {
                    if (index == length)
                    {
                        break;
                    }

                    c = text[index];

                    if (
                        LexingHelper.IsInlineWhiteSpaceOrCaretControl(c) ||
                        LexingHelper.IsStandardPunctuationChar(c))
                    {
                        break;
                    }

                    if (c == '_' || LexingHelper.IsLatinLetter(c) || LexingHelper.IsDigit(c))
                    {
                        index++;
                        column++;

                        continue;
                    }

                    return(null);
                }

                var delta = index - initialIndex;
                var str   = text.Substring(initialIndex, delta);

                context.Advance(delta, 0, column);

                return(new TextToken(
                           WordTextClass.Instance,
                           NoneTextDecoration.Instance,
                           str,
                           new Position(context.Line, column), delta));
            }

            return(null);
        }
        public IToken Produce()
        {
            var context = this.Context;
            var text    = context.Text;
            var length  = text.Length;

            var c = text[context.Index];

            if (LexingHelper.IsDigit(c) ||
                LexingHelper.IsLatinLetter(c))
            {
                var initialIndex = context.Index;
                var index        = initialIndex + 1;

                while (true)
                {
                    if (index == length)
                    {
                        if (text[index - 1] == '-')
                        {
                            return(null);
                        }

                        break;
                    }

                    c = text[index];

                    if (c == '-')
                    {
                        if (text[index - 1] == '-')
                        {
                            return(null); // two '-' in a row
                        }

                        index++;
                        continue;
                    }

                    if (c == '=' || LexingHelper.IsInlineWhiteSpaceOrCaretControl(c))
                    {
                        if (text[index - 1] == '-')
                        {
                            return(null);
                        }

                        break;
                    }

                    var valid =
                        LexingHelper.IsDigit(c) ||
                        LexingHelper.IsLatinLetter(c);

                    if (!valid)
                    {
                        return(null);
                    }

                    index++;
                }

                var delta = index - initialIndex;
                var str   = text.Substring(initialIndex, delta);

                var position = new Position(context.Line, context.Column);
                context.Advance(delta, 0, context.Column + delta);

                var token = new TextToken(
                    TermTextClass.Instance,
                    NoneTextDecoration.Instance,
                    str,
                    position,
                    delta);

                return(token);
            }

            return(null);
        }
Exemple #3
0
        public IToken Produce()
        {
            var context = this.Context;
            var text    = context.Text;
            var length  = text.Length;

            var c = text[context.Index];

            if (c == '-')
            {
                var initialIndex = context.Index;
                var index        = initialIndex + 1;
                int delta;
                var gotGoodChars = false;

                while (true)
                {
                    if (index == length)
                    {
                        if (text[index - 1] == '-')
                        {
                            return(null);
                        }

                        break;
                    }

                    c     = text[index];
                    delta = index - initialIndex;

                    if (c == '-')
                    {
                        if (delta == 1)
                        {
                            index++;
                            continue;
                        }

                        if (delta == 2)
                        {
                            if (text[index - 1] == '-')
                            {
                                return(null); // "---" at beginning
                            }

                            index++;
                            continue;
                        }

                        if (text[index - 1] == '-')
                        {
                            return(null); // "--" inside key
                        }

                        index++;
                        continue;
                    }

                    if (LexingHelper.IsDigit(c) ||
                        LexingHelper.IsLatinLetter(c))
                    {
                        gotGoodChars = true;
                        index++;
                        continue;
                    }

                    if (LexingHelper.IsInlineWhiteSpaceOrCaretControl(c))
                    {
                        if (text[index - 1] == '-')
                        {
                            return(null);
                        }

                        break;
                    }

                    return(null);
                }

                if (!gotGoodChars)
                {
                    return(null);
                }

                delta = index - initialIndex;
                var str      = text.Substring(initialIndex, delta);
                var position = new Position(context.Line, context.Column);
                context.Advance(delta, 0, context.Column + delta);
                var token = new TextToken(
                    KeyTextClass.Instance,
                    NoneTextDecoration.Instance,
                    str,
                    position,
                    delta);

                return(token);
            }

            return(null);
        }
Exemple #4
0
 public static bool IsPathFirstChar(char c) =>
 LexingHelper.IsDigit(c) ||
 LexingHelper.IsLatinLetter(c) ||
 c.IsIn('\\', '/', '.', '!', '~', '$', '%', ';', '_');
Exemple #5
0
        public IToken Produce()
        {
            var context = this.Context;
            var text    = context.Text;
            var length  = text.Length;

            var c = text[context.Index];

            if (OpeningDelimiters.Contains(c) ||
                c == '_' ||
                LexingHelper.IsLatinLetter(c))
            {
                char?openingDelimiter = OpeningDelimiters.Contains(c) ? c : (char?)null;

                var initialIndex = context.Index;
                var index        = initialIndex + 1;

                while (true)
                {
                    if (index == length)
                    {
                        if (openingDelimiter.HasValue)
                        {
                            var delta  = index - initialIndex;
                            var column = context.Column + delta;

                            this.ThrowUnclosedIdentifierException(context.Line, column);
                        }
                        break;
                    }

                    c = text[index];

                    if (c == '_' || LexingHelper.IsLatinLetter(c) || LexingHelper.IsDigit(c))
                    {
                        index++;
                        continue;
                    }

                    if (ClosingDelimiters.Contains(c))
                    {
                        if (index - initialIndex > 2)
                        {
                            if (openingDelimiter.HasValue)
                            {
                                if (openingDelimiter.Value == ReverseDelimiters[c])
                                {
                                    index++;

                                    var delta  = index - initialIndex;
                                    var column = context.Column + delta;

                                    var str      = text.Substring(initialIndex + 1, delta - 2);
                                    var position = new Position(context.Line, context.Column);
                                    context.Advance(delta, 0, column);
                                    return(new TextToken(
                                               SqlIdentifierTextClass.Instance,
                                               NoneTextDecoration.Instance,
                                               str,
                                               position,
                                               delta));
                                }
                                else
                                {
                                    var delta  = index - initialIndex;
                                    var column = context.Column + delta;

                                    this.ThrowUnclosedIdentifierException(context.Line, column);
                                }
                            }
                            else
                            {
                                var delta  = index - initialIndex;
                                var column = context.Column + delta;

                                throw new LexingException($"Unexpected delimiter: '{c}'.", new Position(context.Line, column));
                            }
                        }
                        else
                        {
                            var delta  = index - initialIndex;
                            var column = context.Column + delta;
                            throw new LexingException($"Unexpected delimiter: '{c}'.", new Position(context.Line, column));
                        }
                    }
                }
            }

            return(null);
        }