apró regexp segítség kéne

Szóval, amire rá akartam térni, az a regexek végrehajtási sorrendje.
Szép, hogy van prioritás az elképzelésedben, de ha ezt egy ciklussal oldod meg, akkor gondban leszel, mert hogy oldod meg, hogy a második iteráció ne az első eredményén hajtódjon végre, vagyis "ne lóghassanak egymásra" a találatok?

No, itt egy C# megvalósítás a problémára. Baromi ronda, az eredeti kódot messze nem úgy írtam, hogy publikáljam, ráadásul mire átalakítottam a példa kedvéért, kigyalulva a maradék kb. 1000 sort, még rondább lett :)

using System;
using System.Collections.Generic;
using System.Text;
using System.Text.RegularExpressions;

namespace demo
{

    delegate string RegexReplace(Match m);

    class Program
    {

        public struct RegexReplaceDefinition
        {
            public string RegexString;
            public RegexReplace RegexReplaceMethod;
            public RegexReplaceDefinition(string regex, RegexReplace regexreplace)
            {
                RegexString = regex;
                RegexReplaceMethod = regexreplace;
            }
            public string GetNamedRegex(string name)
            {
                return "(?:(?<" + name + ">)" + RegexString + ")";
            }
        }

        static void Main(string[] args)
        {
            Dictionary<string, RegexReplaceDefinition> regexlist = new Dictionary<string, RegexReplaceDefinition>();
            regexlist.Add("elso", new RegexReplaceDefinition(@"elso", delegate(Match m) { return "ELSO"; }));
            regexlist.Add("masodik", new RegexReplaceDefinition(@"masodik", delegate(Match m) { return "MASODIK"; }));
            StringBuilder sbFullRegex = new StringBuilder();
            foreach (KeyValuePair<string, RegexReplaceDefinition> kvp in regexlist)
                sbFullRegex.Append(kvp.Value.GetNamedRegex(kvp.Key)).Append('|');
            sbFullRegex.Length--;
            string test = "nulladik elso masodik harmadik";
            test = Regex.Replace(test, sbFullRegex.ToString(), delegate(Match m)
            {
                foreach (string name in regexlist.Keys)
                {
                    if (m.Groups[name].Success)
                        return regexlist[name].RegexReplaceMethod(m);
                }
                return m.Value;
            }, RegexOptions.Compiled);
            Console.WriteLine(test);
        }
    }
}

A struct azért van, mert így sokkal egyszerűbb bánni az egésszel (az eredeti kód egyetlen osztályban oldja meg a dolgot, de abban futásidejű C# fordítás és hasonlók vannak, ezért most a példához írtam csak a Main()-t).
Esetedben természetesen a definíciós XML-ből kell olvasni az adatokat a regexlisthez.
A Dictionary "nevesítve" tartalmazza az egyes definíciókat. A definíciók két dologból állnak: a keresőkifejezésből, illetve a cserét lebonyolító függvényből.
A cserét lebonyolító függvényt én speciel config-fájlból szedem, és futásidőben fordíttatom le, de ez most érdektelen, mert fogalmam sincs, hogy lehet-e ilyet csinálni javában, és ha igen, hogyan. A lényeg, hogy egy Match objektumot vár, és egy stringet kell visszaadnia, ez gondolom javában is hasonló.

Miután összeszedted az összes kifejezést, a StringBuildert (lehetne string is, de .NET-ben így gyorsabb) feltöltő ciklus összefűzi az egyes kifejezéseket, egy pipe-pal elválasztva (az utolsót persze leszedi). A GetNamedRegex() a trükk: egyrészt nem gyűjtő zárójelbe teszi a kifejezést, másrészt az elejére beszúrja a keresőkifejezés "nevét".

Most jön maga a csere, ami most már egyetlen regexet használ, az összes egyedi kifejezést prioritási sorrendben egymás után (ha az első teljesül, tovább nem megy). A cserekifejezés egy helyben definiált függvény, ami végigmegy a neveken, és ha megtalálja az ilyen nevű csoportot, akkor meghívja a hozzá tartozó cserélő függvényt. Ha nincs találat – ami elméletileg nem fordulhat elő, ha az egyes regexek hibátlanok –, akkor visszadja magát a találatot (normálisan egyébként exceptiont kéne dobni.)

Korlátok:
- Ha jót akarsz, csak nevesített csoportokat használsz a keresőkifejezésekben, a számozott csoportok ilyen esetben vagy jól (elvárt módon) működnek, vagy nem.
- Vigyázni kell, hogy ne használj a regexekre olyan nevet, mint amilyen nevű csoport bármelyikben előfordul, mert nagy gebasz lesz belőle.
- Ha bármilyen opciót megadsz a regexmotornak (.NET-ben pl. SingleLine stb.), az az összesre igaz.
- Az egyes regexkifejezéseknek önmagukban zártnak kell lenniük, tehát kerülendő pl. a

(?s)...(?-s)

használata, mert fogalmam sincs, hogy mi történik a hatásával a pipe után, helyette viszont jó (ha a motor ismeri) a

(?s:...)

kifejezés.

Ha valami nem tiszta, szólj.