Esempio n. 1
0
        /// <summary>
        /// Returns true if it quoted.
        /// </summary>
        public static bool QuoteValue(string str, StringBuilder sb, bool force = false)
        {
            int  ich = sb.Length;
            bool f   = QuoteValueCore(str, sb, force);

#if DEBUG // Verify the result.
            string v = sb.ToString(ich, sb.Length - ich);

            var curs = new CharCursor(v);
            Contracts.Assert(f == (force || curs.ChCur == '{'));

            var lex = new CmdLexer(curs);
            var res = new StringBuilder();

            // If it was quoted, gathering curly contents should get us the original. Otherwise,
            // the result should be equivalent to the original and should be a single token.
            if (f)
            {
                Contracts.Assert(v.StartsWith("{") && v.EndsWith("}"));
                lex.GatherCurlyContents(res);
            }
            else
            {
                lex.GetToken(res);
            }

            Contracts.Assert(!lex.Error);
            Contracts.Assert(curs.Eof);
            Contracts.Assert(str == res.ToString());
#endif

            return(f);
        }
Esempio n. 2
0
        public static bool NeedsQuoting(StringBuilder sb, int ich)
        {
            Contracts.AssertValue(sb);
            Contracts.Assert(0 <= ich && ich <= sb.Length);

            if (ich >= sb.Length)
            {
                return(true);
            }

            if (sb[ich] == '{')
            {
                return(true);
            }

            // See if we need to quote. If lexing produces a single token with the exact
            // same value, then we don't need to.
            int ichLim = sb.Length;
            int cch    = ichLim - ich;
            var curs   = new CharCursor(sb.ToString(ich, cch));
            var lex    = new CmdLexer(curs);

            lex.GetToken(sb);
            Contracts.Assert(curs.IchCur > 0 || lex.Error);

            try
            {
                if (!lex.Error && curs.Eof && sb.Length == ichLim + cch)
                {
                    // See if the characters match.
                    for (int ichSrc = ich; ; ichSrc++)
                    {
                        if (ichSrc >= ichLim)
                        {
                            return(false);
                        }
                        if (sb[ichSrc] != sb[ichSrc + cch])
                        {
                            break;
                        }
                    }
                }
                return(true);
            }
            finally
            {
                sb.Length = ich + cch;
            }
        }
Esempio n. 3
0
        // Try to quote by just slapping curlies around the string. This will normally be sufficient
        // and produces a much more aesthetic result than escaping everything.
        private static bool TryNaiveQuoting(string str, StringBuilder sb)
        {
            Contracts.AssertNonEmpty(str);

            var curs = new CharCursor("{" + str + "}");
            var lex  = new CmdLexer(curs);
            var res  = new StringBuilder();

            lex.GatherCurlyContents(res);
            if (lex.Error || !curs.Eof || res.Length != str.Length || res.ToString() != str)
            {
                return(false);
            }

            sb.Append("{");
            sb.Append(str);
            sb.Append("}");
            return(true);
        }
Esempio n. 4
0
        public static string UnquoteValue(string str)
        {
            if (!str.StartsWith("{") || !str.EndsWith("}"))
            {
                return(str);
            }

            CharCursor curs = new CharCursor(str);
            CmdLexer   lex  = new CmdLexer(curs);

            // Gather the curly group contents and make sure it consumes everything.
            StringBuilder sb = new StringBuilder();

            lex.GatherCurlyContents(sb);
            if (lex._error || !curs.Eof)
            {
                return(str);
            }

            return(sb.ToString());
        }
Esempio n. 5
0
        // Determines whether str needs quoting. If not, appends the string to sb and returns try.
        // If so, sb's contents are preserved and returns false.
        private static bool TryNoQuoting(string str, StringBuilder sb)
        {
            Contracts.AssertNonEmpty(str);

            if (str[0] == '{')
            {
                return(false);
            }

            int ichDst = sb.Length;

            // See if we need to quote. If lexing produces a single token with the exact
            // same value, then we don't need to.
            var curs = new CharCursor(str);
            var lex  = new CmdLexer(curs);

            lex.GetToken(sb);
            Contracts.Assert(curs.IchCur > 0 || lex.Error);

            if (!lex.Error && curs.Eof && sb.Length == ichDst + str.Length)
            {
                // See if the characters match.
                for (int ichSrc = 0; ; ichSrc++)
                {
                    if (ichSrc >= str.Length)
                    {
                        return(true);
                    }
                    if (sb[ichDst + ichSrc] != str[ichSrc])
                    {
                        break;
                    }
                }
            }

            // Reset the string builder.
            sb.Length = ichDst;
            return(false);
        }
Esempio n. 6
0
        private static void ParseCore(string str, out string kind, out string args)
        {
            kind = args = null;
            if (string.IsNullOrWhiteSpace(str))
            {
                return;
            }
            str = str.Trim();
            int ich = str.IndexOf('{');

            if (ich < 0)
            {
                kind = str;
                return;
            }
            if (ich == 0 || str[str.Length - 1] != '}')
            {
                throw Contracts.Except("Invalid SubComponent string: mismatched braces, or empty component name.");
            }

            kind = str.Substring(0, ich);
            args = CmdLexer.UnquoteValue(str.Substring(ich));
        }