помогите с регулярками.

[Smogg]

В общем, есть строка из слов и всякого другого. Где-то посередине находится курсор (ака каретка). и нужно определить что первое слово справа и первое слово слева от курсора записаны на одном языке.

Я что-то написал, но что именно - понимаю смутно...

    class Class1
    {

        public enum LayResult { Ambiguous, Russ, Engl };
         Regex rxRus, rxEng, rxLeft, rxRight;

        public Class1() {
             rxLeft = new Regex("([a-zA-Zа-яА-ЯёЁ]+)(?[^a-zA-Zа-яА-ЯёЁ]{0,4})$");
             rxRight = new Regex("^(?[^a-zA-Zа-яА-ЯёЁ]){0,4}([a-zA-Zа-яА-ЯёЁ]+)");
             rxRus = new Regex("^([а-яА-ЯёЁ]+)$");
             rxEng = new Regex("^([a-zA-Z]+)$");
        }
            
        ~Class1() { }

        public LayResult TestText(/*ref*/ String sTst, int pos)
        {
            LayResult res = LayResult.Ambiguous;
            // проверка на корректность длины строки 
            if (sTst.Length < pos)
                return res;         

            // выделяем подстроку влево:

            String strLeft, strRight;
            if (pos > 50)
            {
                strLeft = sTst.Substring(pos - 50, 50);
            }
            else
                strLeft = sTst.Substring(0, pos);

            // выделяем подстроку вправо:
            
            if (sTst.Length - pos > 50)
            {
                strRight = sTst.Substring(pos, 50);
            }
            else
                strRight = sTst.Substring(pos);

            MatchCollection mcLft = rxLeft.Matches(strLeft);
            MatchCollection mcRgh = rxRight.Matches(strRight);

            if (mcLft.Count > 0)
            {
                strLeft = mcLft[0].Value;
            }
            else
                strLeft = "";
            if (mcRgh.Count > 0)
            {
                strRight = mcRgh[0].Value;
            }
            else
                strRight = "";
            LayResult layLft = CheckLay(ref strLeft);
            LayResult layRght = CheckLay(ref strRight);
            if ((layLft == LayResult.Russ) && (layRght == LayResult.Russ))
            {
                return LayResult.Russ;
            }

            if ((layLft == LayResult.Engl) && (layRght == LayResult.Engl))
            {
                return LayResult.Engl;
            }

            return res;
        }
        private LayResult CheckLay(ref String s)
        {
            if (s.Length < 1)
                return LayResult.Ambiguous;

            MatchCollection mc = rxRus.Matches(s);
            
            if (mc.Count > 0)
                return LayResult.Russ;

            mc = rxEng.Matches(s);

            if (mc.Count > 0)
                return LayResult.Engl;

            return LayResult.Ambiguous;
        }        
    }

То есть, когда каретка находится в центре слова, то эти регулярки
_____rxLeft = new Regex("([a-zA-Zа-яА-ЯёЁ]+)[^a-zA-Zа-яА-ЯёЁ]{0,4}$");
_____rxRight = new Regex("^[^a-zA-Zа-яА-ЯёЁ]{0,4}([a-zA-Zа-яА-ЯёЁ]+)");

правильно выделяют именно буквы:
"tes|sting" -> "tes" + "sting";

А если каретка находится между словами, то захватываются и небуквенные символы:
"при___|__мер" -> "при___" + "__мер";

Или есть другой, более правильный способ решения? А то мне кажется, что создавать копии строчек слева/справа от курсора , на которые уже натравливать регулярности - не совсем экономично.
// Эх, а еще страдал, что в Къюте регулярки мутные. Оказывается, что как раз там-то они - сама точность и ясность.

[Smogg]

Ну, как обычно, всем спасибо за интерес и моральную поддержку

Решение такое

  // если за последовательным набором букв [a-zA-Zа-яА-ЯёЁ] следует от 0 до четырех не-букв [^a-zA-Zа-яА-ЯёЁ], // (^) - неспроста, 
  // после которых идет конец строки ($), то регулярное выражение истинно
rxLeft = new Regex("[a-zA-Zа-яА-ЯёЁ]+(?=[^a-zA-Zа-яА-ЯёЁ]{0,4}$)");
  // если последовательному набору букв [a-zA-Zа-яА-ЯёЁ] прдшествет от 0 до четырех не-букв [^a-zA-Zа-яА-ЯёЁ], // (^) - !
  // стоящих сразу в начале строки (:), то регулярное выражение истинно
rxRight = new Regex("(?<=^[^a-zA-Zа-яА-ЯёЁ]{0,4})[a-zA-Zа-яА-ЯёЁ]+");

// прикольная это все таки вещь - регулярность, если разобраться))