Esempio n. 1
0
        public Regex ParseRegexString(char terminator)
        {
            // #/.../

            char ch;
            var  buf = new StringBuilder();

            while (true)
            {
                ch = ReadChar();

                if (IsEof || ch == '\n')
                {
                    throw MakeScannerException("EOF: Unterminated string");
                }

                if (ch == terminator)
                {
                    var ch2 = ReadChar();
                    if (ch2 == terminator)
                    {
                        buf.Append(ch);
                    }
                    else
                    {
                        UnreadChar();
                        break;
                    }
                }
                else
                {
                    buf.Append(ch);
                }
            }

            var options  = RegexOptions.None;
            var wildcard = false;

            while (true)
            {
                ch = ReadChar();
                if (!Char.IsLetter(ch))
                {
                    UnreadChar();
                    break;
                }
                switch (ch)
                {
                case 'i':
                {
                    options |= RegexOptions.IgnoreCase;
                    break;
                }

                case 's':
                {
                    options |= RegexOptions.Singleline;
                    break;
                }

                case 'm':
                {
                    options |= RegexOptions.Multiline;
                    break;
                }

                case 'w':
                {
                    wildcard = true;
                    break;
                }

                default:
                {
                    throw MakeScannerException("invalid regular expresssion option");
                }
                }
            }
            var pattern = buf.ToString();

            if (wildcard)
            {
                pattern = StringExtensions.MakeWildcardRegexString(pattern);
            }
            return(new RegexPlus(pattern, options));
        }
Esempio n. 2
0
        public override void Write(string value)
        {
            var beg = value.IndexOf("!{");

            if (beg == -1)
            {
                WriteString(value);
                return;
            }

            var end = value.IndexOf("}", beg);

            if (end == -1)
            {
                end = value.Length;
            }

            if (!savedOrig)
            {
                fgOrig    = window.ForeColor;
                attrOrig  = window.Attr;
                savedOrig = true;
            }

            var head   = value.Substring(0, beg);
            var middle = value.Substring(beg + 2, end - beg - 2);
            var tail   = value.Substring(end + (end < value.Length ? 1 : 0));

            WriteString(head);

            var parts = StringExtensions.Split(middle);

            foreach (var part in parts)
            {
                if (part.StartsWith("+"))
                {
                    var word = part.Substring(1);
                    switch (word)
                    {
                    case "normal":
                    case "bold":
                    case "italic":
                    case "underline":
                    case "strikeout":
                    case "strike-out":
                    case "reverse":
                    {
                        window.AttrOn(word);
                        break;
                    }

                    default:
                    {
                        window.ForeColor = new ColorType(word);
                        break;
                    }
                    }
                }
                else if (part.StartsWith("-"))
                {
                    var word = part.Substring(1);
                    switch (word)
                    {
                    case "normal":
                    case "bold":
                    case "italic":
                    case "underline":
                    case "strikeout":
                    case "strike-out":
                    case "reverse":
                    {
                        window.AttrOff(word);
                        break;
                    }

                    default:
                    {
                        window.ForeColor = fgOrig;
                        break;
                    }
                    }
                }
                else
                {
                    var word = part;
                    switch (word)
                    {
                    case "normal":
                    case "bold":
                    case "italic":
                    case "underline":
                    case "strikeout":
                    case "strike-out":
                    case "reverse":
                    {
                        window.AttrSet(word);
                        break;
                    }

                    default:
                    {
                        window.ForeColor = new ColorType(word);
                        break;
                    }
                    }
                }
            }

            Write(tail);

            //Application.DoEvents();
        }