1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
|
//
// assembly: System
// namespace: System.Text.RegularExpressions
// file: match.cs
//
// author: Dan Lewis (dlewis@gmx.co.uk)
// (c) 2002
using System;
namespace System.Text.RegularExpressions {
[Serializable]
public class Capture {
public int Index {
get { return index; }
}
public int Length {
get { return length; }
}
public string Value {
get { return text.Substring (index, length); }
}
public override string ToString () {
return Value;
}
// internal members
internal Capture (string text) : this (text, 0, 0) { }
internal Capture (string text, int index, int length) {
this.text = text;
this.index = index;
this.length = length;
}
internal string Text {
get { return text; }
}
// private
internal int index, length;
internal string text;
}
[Serializable]
public class Group : Capture {
public static Group Synchronized (Group inner) {
return inner; // is this enough?
}
public CaptureCollection Captures {
get { return captures; }
}
public bool Success {
get { return success; }
}
// internal
internal Group (string text, int[] caps) : base (text) {
this.captures = new CaptureCollection ();
if (caps == null || caps.Length == 0) {
this.success = false;
return;
}
this.success = true;
this.index = caps[0];
this.length = caps[1];
captures.Add (this);
for (int i = 2; i < caps.Length; i += 2)
captures.Add (new Capture (text, caps[i], caps[i + 1]));
captures.Reverse ();
}
private bool success;
private CaptureCollection captures;
}
[Serializable]
public class Match : Group {
public static Match Empty {
get { return empty; }
}
public static Match Synchronized (Match inner) {
return inner; // FIXME need to sync on machine access
}
public virtual GroupCollection Groups {
get { return groups; }
}
public Match NextMatch () {
if (this == Empty)
return Empty;
int scan_ptr = regex.RightToLeft ? Index : Index + Length;
// next match after an empty match: make sure scan ptr makes progress
if (Length == 0)
scan_ptr += regex.RightToLeft ? -1 : +1;
return machine.Scan (regex, Text, scan_ptr, text_length);
}
public virtual string Result (string replacement) {
return ReplacementEvaluator.Evaluate (replacement, this);
}
// internal
internal Match () : base (null, null) {
this.regex = null;
this.machine = null;
this.text_length = 0;
this.groups = new GroupCollection ();
groups.Add (this);
}
internal Match (Regex regex, IMachine machine, string text, int text_length, int[][] grps) :
base (text, grps[0])
{
this.regex = regex;
this.machine = machine;
this.text_length = text_length;
this.groups = new GroupCollection ();
groups.Add (this);
for (int i = 1; i < grps.Length; ++ i)
groups.Add (new Group (text, grps[i]));
}
internal Regex Regex {
get { return regex; }
}
// private
private Regex regex;
private IMachine machine;
private int text_length;
private GroupCollection groups;
private static Match empty = new Match ();
}
}
|
