public void TextNavigator_ReadTo_2()
        {
            char[]        stop      = { ']', '>' };
            TextNavigator navigator = new TextNavigator("ABC]>DEF");

            Assert.AreEqual("ABC]", navigator.ReadTo(stop));
            Assert.AreEqual(">", navigator.ReadTo(stop));
            Assert.AreEqual("DEF", navigator.ReadTo(stop));
            Assert.IsNull(navigator.ReadTo(stop));
        }
Example #2
0
        public static FileSpecification Parse
        (
            string text
        )
        {
            // Sure.NotNullNorEmpty(text, nameof(text));

            var navigator = new TextNavigator(text);
            var path      = int.Parse
                            (
                navigator.ReadTo(".").ToString()
                            );
            var database   = navigator.ReadTo(".").ToString().EmptyToNull();
            var fileName   = navigator.GetRemainingText().ToString();
            var binaryFile = fileName.StartsWith("@");

            if (binaryFile)
            {
                fileName = fileName.Substring(1);
            }

            string?content  = null;
            var    position = fileName.IndexOf("&", StringComparison.InvariantCulture);

            if (position >= 0)
            {
                content  = fileName.Substring(position + 1);
                fileName = fileName.Substring(0, position);
            }
            var result = new FileSpecification
            {
                BinaryFile = binaryFile,
                Path       = (IrbisPath)path,
                Database   = database,
                FileName   = fileName,
                Content    = content
            };


            return(result);
        }
        public static FileSpecification Parse
        (
            [NotNull] string text
        )
        {
            Sure.NotNullNorEmpty(text, "text");

            TextNavigator navigator  = new TextNavigator(text);
            int           path       = NumericUtility.ParseInt32(navigator.ReadTo("."));
            string        database   = navigator.ReadTo(".").EmptyToNull();
            string        fileName   = navigator.GetRemainingText();
            bool          binaryFile = fileName.StartsWith("@");

            if (binaryFile)
            {
                fileName = fileName.Substring(1);
            }

            string content  = null;
            int    position = fileName.IndexOf("&");

            if (position >= 0)
            {
                content  = fileName.Substring(position + 1);
                fileName = fileName.Substring(0, position);
            }
            FileSpecification result = new FileSpecification
            {
                BinaryFile = binaryFile,
                Path       = (IrbisPath)path,
                Database   = database,
                FileName   = fileName,
                Content    = content
            };


            return(result);
        }
        public void TextNavigator_ReadTo_3()
        {
            TextNavigator navigator = new TextNavigator("314abc>>>hello");
            string        actual    = navigator.ReadTo(">>>");

            Assert.AreEqual("314abc", actual);
            Assert.AreEqual("hello", navigator.GetRemainingText());

            navigator = new TextNavigator("314abc>>hello");
            actual    = navigator.ReadTo(">>>");
            Assert.IsNull(actual);
            Assert.AreEqual("314abc>>hello", navigator.GetRemainingText());

            navigator = new TextNavigator(string.Empty);
            Assert.IsNull(navigator.ReadTo(">>>"));
        }
        public void TextNavigator_ReadTo_1()
        {
            const string  text1     = "'ABC'DEF";
            TextNavigator navigator = new TextNavigator(text1);
            char          open      = navigator.ReadChar();
            string        actual    = navigator.ReadTo(open);

            Assert.AreEqual("ABC'", actual);

            const string text2 = "'ABC";

            navigator = new TextNavigator(text2);
            open      = navigator.ReadChar();
            actual    = navigator.ReadTo(open);
            Assert.AreEqual("ABC", actual);

            navigator = new TextNavigator(string.Empty);
            Assert.IsNull(navigator.ReadTo(open));
        }
Example #6
0
        public static string[] SplitText
        (
            [CanBeNull] string text
        )
        {
            if (string.IsNullOrEmpty(text))
            {
                return(new string[0]);
            }

            List <string> result    = new List <string>();
            TextNavigator navigator = new TextNavigator(text);

            while (!navigator.IsEOF)
            {
                navigator.SkipWhitespace();
                if (navigator.IsEOF)
                {
                    break;
                }

                char   c = navigator.ReadChar();
                string item;
                if (c == CommandLineSettings.ArgumentDelimiter)
                {
                    item = c + navigator.ReadTo
                           (
                        CommandLineSettings.ArgumentDelimiter
                           );
                }
                else
                {
                    item = c + navigator.ReadUntilWhiteSpace();
                }
                result.Add(item);
            }

            return(result.ToArray());
        }
Example #7
0
        public static string RemoveComments
        (
            [CanBeNull] string text
        )
        {
            const char ZERO = '\0';

            if (string.IsNullOrEmpty(text))
            {
                return(text);
            }

            if (!text.Contains("/*"))
            {
                return(text);
            }

            StringBuilder result    = new StringBuilder(text.Length);
            TextNavigator navigator = new TextNavigator(text);
            char          state     = ZERO;

            while (!navigator.IsEOF)
            {
                char c = navigator.ReadChar();

                switch (state)
                {
                case '\'':
                    if (c == '\'')
                    {
                        state = ZERO;
                    }
                    result.Append(c);
                    break;

                case '"':
                    if (c == '"')
                    {
                        state = ZERO;
                    }
                    result.Append(c);
                    break;

                case '|':
                    if (c == '|')
                    {
                        state = ZERO;
                    }
                    result.Append(c);
                    break;

                default:
                    Debug.Assert(state == ZERO, "state == ZERO");

                    if (c == '/')
                    {
                        if (navigator.PeekChar() == '*')
                        {
                            navigator.ReadTo('\r', '\n');
                        }
                        else
                        {
                            result.Append(c);
                        }
                    }
                    else if (c == '\'' || c == '"' || c == '|')
                    {
                        state = c;
                        result.Append(c);
                    }
                    else
                    {
                        result.Append(c);
                    }
                    break;
                }
            }

            return(result.ToString());
        }