Example #1
0
        private IGlobToken ReadLiteralToken(GlobStringReader reader)
        {
            AcceptCurrentChar(reader);

            while (!reader.HasReachedEnd)
            {
                var peekChar = reader.PeekChar();
                var isValid  = GlobStringReader.IsNotStartOfToken(peekChar) && !GlobStringReader.IsPathSeperator(peekChar);

                if (isValid)
                {
                    if (reader.ReadChar())
                    {
                        AcceptCurrentChar(reader);
                    }
                    else
                    {
                        // potentially hit end of string.
                        break;
                    }
                }
                else
                {
                    // we have hit a character that may not be a valid literal (could be unsupported, or start of a token for instance).
                    break;
                }
            }

            return(new LiteralToken(GetBufferAndReset()));
        }
Example #2
0
        public IList <IGlobToken> Tokenise(string globText, bool allowInvalidPathCharcaters)
        {
            var tokens = new List <IGlobToken>();

            using (var reader = new GlobStringReader(globText))
            {
                while (reader.ReadChar())
                {
                    if (reader.IsBeginningOfRangeOrList)
                    {
                        tokens.Add(ReadRangeOrListToken(reader));
                    }
                    else if (reader.IsSingleCharacterMatch)
                    {
                        tokens.Add(ReadSingleCharacterMatchToken());
                    }
                    else if (reader.IsWildcardCharacterMatch)
                    {
                        tokens.Add(ReadWildcardToken());
                    }
                    else if (reader.IsPathSeperator())
                    {
                        var sepToken = ReadPathSeperatorToken(reader);
                        tokens.Add(sepToken);
                    }
                    else if (reader.IsBeginningOfDirectoryWildcard)
                    {
                        if (tokens.Count > 0)
                        {
                            var lastToken = tokens[tokens.Count - 1] as PathSeperatorToken;

                            if (lastToken != null)
                            {
                                tokens.Remove(lastToken);
                                tokens.Add(ReadDirectoryWildcardToken(reader, lastToken));
                                continue;
                            }
                        }

                        tokens.Add(ReadDirectoryWildcardToken(reader, null));
                    }
                    else
                    {
                        tokens.Add(ReadLiteralToken(reader, allowInvalidPathCharcaters));

                        ////else if (reader.IsValidLiteralCharacter())
                        ////{
                        //// literal
                        //tokens.Add(ReadLiteralToken(reader));
                    }
                }
            }

            _currentBufferText.Clear();

            return(tokens);
        }
Example #3
0
        private IGlobToken ReadDirectoryWildcardToken(GlobStringReader reader)
        {
            reader.ReadChar();

            if (GlobStringReader.IsPathSeperator(reader.PeekChar()))
            {
                reader.ReadChar();
                return(new WildcardDirectoryToken(reader.CurrentChar));
            }

            return(new WildcardDirectoryToken(null)); // this shouldn't happen unless a pattern ends with ** which is weird. **sometext is not legal.
        }
Example #4
0
        public IList <IGlobToken> Tokenise(string globText)
        {
            var    tokens = new List <IGlobToken>();
            string starstartpeak;

            using (var reader = new GlobStringReader(globText))
            {
                while (reader.ReadChar())
                {
                    if (reader.IsBeginningOfRangeOrList)
                    {
                        tokens.Add(ReadRangeOrListToken(reader));
                    }
                    else if (reader.IsSingleCharacterMatch)
                    {
                        tokens.Add(ReadSingleCharacterMatchToken());
                    }
                    else if (reader.IsWildcardCharacterMatch)
                    {
                        tokens.Add(ReadWildcardToken());
                    }
                    else if (reader.IsPathSeperator())
                    {
                        tokens.Add(ReadPathSeperatorToken(reader));
                    }
                    else if (reader.IsBeginningOfDirectoryWildcard)
                    {
                        tokens.Add(ReadDirectoryWildcardToken(reader));
                    }
                    else if (reader.IsValidLiteralCharacter())
                    {
                        // literal
                        tokens.Add(ReadLiteralToken(reader));
                    }
                }
            }

            _currentBufferText.Clear();

            return(tokens);
        }