new parser 2

    public string ProcessAlias(string target, string user, string msgText, int idx, string args) {

        if (idx > -1) {
            msgText = dsData.Tables["Alias"].Rows[idx]["Message"].ToString();
        }

        string[] prms = args.Split(',');
        if (args.Trim().Length == 0) {
            prms = new string[0];
        }

        msgText = msgText
            .Replace("{user}", user)
            .Replace("{prev}", ChannelHistory[target].Count > 0 ? ChannelHistory[target][0].User : "");

        Random R = new Random();

        Regex
            regToken = new Regex(@"{([^{}]+)}"),
            regDefault = new Regex(@"{(\d):([^{}]+)}"),
            regUrl = new Regex(@"{(\d):url}"),
            regArg = new Regex(@"{(\d+)}"),
            regRnd = new Regex(@"{rnd:([^{}]+)}"),
            regRng = new Regex(@"{rng:([^{}]+)}"),
            regMisc = new Regex(@"{!([^{}]+)}");

        Match
            mDefault,
            mUrl,
            mArg,
            mRnd,
            mRng,
            mMisc;

        string matchReplace = "";
        int iterations = 6;
        bool hasMatch = true;

        while (hasMatch && iterations > 0) {

            if (regToken.IsMatch(msgText)) {
                int offset = 0;
                foreach (Match mToken in regToken.Matches(msgText)) {
                    matchReplace = "";

                    string matchOriginal = mToken.Value;

                    if (regUrl.IsMatch(matchOriginal)) {
                        mUrl = regUrl.Matches(matchOriginal)[0];

                        if (prms.Length > int.Parse(mUrl.Groups[1].Value)) {
                            matchReplace = HttpUtility.UrlEncode(prms[int.Parse(mUrl.Groups[1].Value)]);
                        }
                        else {
                            matchReplace = " ";
                        }

                    }
                    else if (regDefault.IsMatch(matchOriginal)) {
                        mDefault = regDefault.Matches(matchOriginal)[0];


                        if (prms.Length > int.Parse(mDefault.Groups[1].Value)) {
                            matchReplace = prms[int.Parse(mDefault.Groups[1].Value)];
                        }
                        else {
                            matchReplace = mDefault.Groups[2].Value;
                        }

                    }
                    else if (regArg.IsMatch(matchOriginal)) {
                        mArg = regArg.Matches(matchOriginal)[0];

                        if (prms.Length > int.Parse(mArg.Groups[1].Value)) {
                            matchReplace = prms[int.Parse(mArg.Groups[1].Value)];
                        }
                        else {
                            matchReplace = " ";
                        }

                    }
                    else if (regRnd.IsMatch(matchOriginal)) {
                        mRnd = regRnd.Matches(matchOriginal)[0];

                        if (mRnd.Groups[1].Value.ToLower() == "args") {
                            string[] parts = msgText.Split(',');
                            matchReplace = parts[R.Next(parts.Length)];
                        }
                        else {
                            string[] parts = new string[0];
                            if (mRnd.Groups[1].Value.Contains('|'))
                                parts = mRnd.Groups[1].Value.Split('|');
                            else
                                parts = mRnd.Groups[1].Value.Split(',');

                            matchReplace = parts[R.Next(parts.Length)];
                        }

                    }
                    else if (regRng.IsMatch(matchOriginal)) {
                        mRng = regRng.Matches(matchOriginal)[0];

                        string[] parts = mRng.Groups[1].Value.Split(',');
                        int p1 = 0, p2 = 0;
                        if (parts[0].ToLower().Trim() == "min") {
                            p1 = int.MinValue;
                        }
                        else {
                            p1 = int.Parse(parts[0]);
                        }
                        if (parts[1].ToLower().Trim() == "max") {
                            p2 = int.MaxValue - 1;
                        }
                        else {
                            p2 = int.Parse(parts[1]);
                        }

                        matchReplace = R.Next(Math.Min(p1, p2), Math.Max(p1, p2) + 1).ToString();
                    }
                    else if (regMisc.IsMatch(matchOriginal)) {
                        mMisc = regMisc.Matches(matchOriginal)[0];

                        string name = mMisc.Groups[1].Value;

                        int i = GetRowIndex("Lists", "Name", name, false);

                        if (i > -1) {
                            string listName = dsData.Tables["Lists"].Rows[i]["Name"].ToString();

                            int listIdx = -1;

                            listIdx = R.Next(dsData.Tables[listName].Rows.Count);
                            matchReplace = dsData.Tables[listName].Rows[listIdx][0].ToString();
                        }
                        else {
                            int aliasIdx = -1;
                            for (int x = 0; x < dsData.Tables["Alias"].Rows.Count; x++) {
                                if (dsData.Tables["Alias"].Rows[x]["Keyword"].ToString().ToLower() == name.ToLower()) {
                                    if (dsData.Tables["Alias"].Rows[x]["Channel"].ToString() == target) {
                                        aliasIdx = x;
                                        break;
                                    }
                                    else if (aliasIdx == -1) {
                                        aliasIdx = x;
                                    }
                                }
                            }

                            if (aliasIdx > -1) {
                                matchReplace = dsData.Tables["Alias"].Rows[aliasIdx]["Message"].ToString();
                            }
                        }

                    }

                    if (matchReplace != "") {
                        msgText = msgText.Remove(mToken.Index - offset, mToken.Length).Insert(mToken.Index - offset, matchReplace);
                        offset += mToken.Length - matchReplace.Length;
                    }

                }

            }
            else {
                hasMatch = false;
            }

            iterations--;
        }

        return msgText;
    }