2 // This software is now distributed according to
\r
3 // the Lesser Gnu Public License. Please see
\r
4 // http://www.gnu.org/copyleft/lesser.txt for
\r
6 // -- Happy Computing!
\r
8 package com.stevesoft.pat;
\r
12 Shareware: package pat
\r
13 <a href="copyright.html">Copyright 2001, Steven R. Brandt</a>
\r
15 This class is used to store a result from Regex */
\r
16 public class RegRes implements Cloneable {
\r
17 protected int[] marks = null;
\r
18 protected boolean didMatch_ = false;
\r
19 protected StringLike src=null;
\r
21 /** Obtain the text String that was matched against. */
\r
22 public String getString() { return src.toString(); }
\r
23 /** Obtain the source StringLike object. */
\r
24 public StringLike getStringLike() { return src; }
\r
25 protected int charsMatched_=0,matchFrom_=0,numSubs_=0;
\r
26 public String toString() {
\r
27 StringBuffer sb = new StringBuffer();
\r
28 sb.append("match="+matchedFrom()+":"+charsMatched());
\r
29 if(!didMatch()) return sb.toString();
\r
30 for(int i=0;i<numSubs();i++) {
\r
32 sb.append(" sub("+n+")="+matchedFrom(n)+
\r
33 ":"+charsMatched(n));
\r
35 return sb.toString();
\r
38 public RegRes(RegRes r) {
\r
41 public void copyOutOf(RegRes r) {
\r
45 //marks = (Hashtable)r.marks.clone();
\r
46 marks = new int[r.marks.length];
\r
47 for(int i=0;i<marks.length;i++)
\r
48 marks[i]=r.marks[i];
\r
49 //marks = (int[])r.marks.clone();
\r
50 } catch (Throwable t) {}
\r
51 didMatch_ = r.didMatch_;
\r
53 charsMatched_ = r.charsMatched_;
\r
54 matchFrom_ = r.matchFrom_;
\r
55 numSubs_ = r.numSubs_;
\r
57 public Object clone() { return new RegRes(this); }
\r
58 public boolean equals(RegRes r) {
\r
59 if(charsMatched_!=r.charsMatched_
\r
60 || matchFrom_ !=r.matchFrom_
\r
61 || didMatch_ !=r.didMatch_
\r
62 || numSubs_ !=r.numSubs_
\r
63 || !src.unwrap().equals(r.src.unwrap()))
\r
65 if(marks==null && r.marks!=null)
\r
67 if(marks!=null && r.marks==null)
\r
69 for(int i=1;i<=numSubs_;i++) {
\r
70 if(matchedFrom(i) != r.matchedFrom(i))
\r
72 else if(charsMatched(i) != r.charsMatched(i))
\r
77 /** Obtains the match if successful, null otherwise.*/
\r
78 public String stringMatched() {
\r
79 int mf=matchedFrom(), cm = charsMatched();
\r
80 return !didMatch_ || mf<0 || cm<0 ? null :
\r
81 src.substring(mf,mf+cm);
\r
83 /** Obtains the position backreference number i begins to match, or
\r
84 -1 if backreference i was not matched. */
\r
85 public int matchedFrom(int i) {
\r
86 if(marks==null||i>numSubs_) return -1;
\r
87 //Integer in=(Integer)marks.get("left"+i);
\r
88 //return in == null ? -1 : in.intValue();
\r
91 /** Obtains the number of characters matched by backreference i, or
\r
92 -1 if backreference i was not matched. */
\r
93 public int charsMatched(int i) {
\r
94 if(marks==null||i>numSubs_||!didMatch_) return -1;
\r
95 //Integer in = (Integer)marks.get("right"+i);
\r
96 //int i2 = in==null ? -1 : in.intValue();
\r
97 int mf = matchedFrom(i);
\r
98 return mf < 0 ? -1 : marks[i+numSubs_]-matchedFrom(i);
\r
100 /** This is either equal to matchedFrom(i)+charsMatched(i) if the match
\r
101 was successful, or -1 if it was not. */
\r
102 public int matchedTo(int i) {
\r
103 if(marks==null||i>numSubs_||!didMatch_) return -1;
\r
104 return marks[i+numSubs_];
\r
106 /** Obtains a substring matching the nth set
\r
107 of parenthesis from the pattern. See
\r
108 numSubs(void), or null if the nth backrefence did
\r
110 public String stringMatched(int i) {
\r
111 int mf = matchedFrom(i), cm = charsMatched(i);
\r
112 return !didMatch_ || mf<0 || cm<0 ? null :
\r
113 src.substring(mf,mf+cm);
\r
115 /** This returns the part of the string that preceeds the match,
\r
116 or null if the match failed.*/
\r
117 public String left() {
\r
118 int mf = matchedFrom();
\r
119 return !didMatch_ || (mf<0) ? null : src.substring(0,mf);
\r
121 /** This returns the part of the string that follows the ith
\r
122 backreference, or null if the backreference did not match. */
\r
123 public String left(int i) {
\r
124 int mf = matchedFrom(i);
\r
125 return !didMatch_ || (mf<0) ? null : src.substring(0,mf);
\r
127 /** This returns the part of the string that follows the match,
\r
128 or null if the backreference did not match.*/
\r
129 public String right() {
\r
130 int mf = matchedFrom(), cm = charsMatched();
\r
131 return !didMatch_ || mf<0 || cm<0 ? null : src.substring(mf+
\r
134 /** This returns the string to the right of the ith backreference,
\r
135 or null if the backreference did not match. */
\r
136 public String right(int i) {
\r
137 int mf = matchedFrom(i), cm = charsMatched(i);
\r
138 return !didMatch_ || mf<0 || cm<0 ? null :
\r
139 src.substring(mf+cm,src.length());
\r
141 /** After a successful match, this returns the location of
\r
142 the first matching character, or -1 if the match failed.*/
\r
143 public int matchedFrom() { return !didMatch_ ? -1 : matchFrom_; }
\r
144 /** After a successful match, this returns the number of
\r
145 characters in the match, or -1 if the match failed. */
\r
146 public int charsMatched() { return !didMatch_||matchFrom_<0 ? -1 : charsMatched_; }
\r
147 /** This is matchedFrom()+charsMatched() after a successful match,
\r
148 or -1 otherwise. */
\r
149 public int matchedTo() { return !didMatch_ ? -1 : matchFrom_+charsMatched_;}
\r
150 /** This returns the number of
\r
151 backreferences (parenthesis) in the pattern,
\r
152 i.e. the pattern "(ab)" has
\r
153 one, the pattern "(a)(b)" has two, etc. */
\r
154 public int numSubs() { return numSubs_; }
\r
155 /** Contains true if the last match was successful. */
\r
156 public boolean didMatch() { return didMatch_; }
\r
158 /** An older name for matchedFrom. */
\r
159 public int matchFrom() { return matchedFrom(); }
\r
160 /** An older name for stringMatched(). */
\r
161 public String substring() { return stringMatched(); }
\r
162 /** An older name for matchedFrom. */
\r
163 public int matchFrom(int i) { return matchedFrom(i); }
\r
164 /** An older name for stringMatched. */
\r
165 public String substring(int i) { return stringMatched(i); }
\r