1 // © 2016 and later: Unicode, Inc. and others.
2 // License & terms of use: http://www.unicode.org/copyright.html
3 /*
4 **********************************************************************
5 * Copyright (c) 2003-2011, International Business Machines
6 * Corporation and others.  All Rights Reserved.
7 **********************************************************************
8 * Author: Alan Liu
9 * Created: September 24 2003
10 * Since: ICU 2.8
11 **********************************************************************
12 */
13 #include "ruleiter.h"
14 #include "unicode/parsepos.h"
15 #include "unicode/symtable.h"
16 #include "unicode/unistr.h"
17 #include "unicode/utf16.h"
18 #include "patternprops.h"
19 
20 /* \U87654321 or \ud800\udc00 */
21 #define MAX_U_NOTATION_LEN 12
22 
23 U_NAMESPACE_BEGIN
24 
25 RuleCharacterIterator::RuleCharacterIterator(const UnicodeString& theText, const SymbolTable* theSym,
26                       ParsePosition& thePos) :
27     text(theText),
28     pos(thePos),
29     sym(theSym),
30     buf(0),
31     bufPos(0)
32 {}
33 
34 UBool RuleCharacterIterator::atEnd() const {
35     return buf == 0 && pos.getIndex() == text.length();
36 }
37 
38 UChar32 RuleCharacterIterator::next(int32_t options, UBool& isEscaped, UErrorCode& ec) {
39     if (U_FAILURE(ec)) return DONE;
40 
41     UChar32 c = DONE;
42     isEscaped = FALSE;
43 
44     for (;;) {
45         c = _current();
46         _advance(U16_LENGTH(c));
47 
48         if (c == SymbolTable::SYMBOL_REF && buf == 0 &&
49             (options & PARSE_VARIABLES) != 0 && sym != 0) {
50             UnicodeString name = sym->parseReference(text, pos, text.length());
51             // If name is empty there was an isolated SYMBOL_REF;
52             // return it.  Caller must be prepared for this.
53             if (name.length() == 0) {
54                 break;
55             }
56             bufPos = 0;
57             buf = sym->lookup(name);
58             if (buf == 0) {
59                 ec = U_UNDEFINED_VARIABLE;
60                 return DONE;
61             }
62             // Handle empty variable value
63             if (buf->length() == 0) {
64                 buf = 0;
65             }
66             continue;
67         }
68 
69         if ((options & SKIP_WHITESPACE) != 0 && PatternProps::isWhiteSpace(c)) {
70             continue;
71         }
72 
73         if (c == 0x5C /*'\\'*/ && (options & PARSE_ESCAPES) != 0) {
74             UnicodeString tempEscape;
75             int32_t offset = 0;
76             c = lookahead(tempEscape, MAX_U_NOTATION_LEN).unescapeAt(offset);
77             jumpahead(offset);
78             isEscaped = TRUE;
79             if (c < 0) {
80                 ec = U_MALFORMED_UNICODE_ESCAPE;
81                 return DONE;
82             }
83         }
84 
85         break;
86     }
87 
88     return c;
89 }
90 
91 void RuleCharacterIterator::getPos(RuleCharacterIterator::Pos& p) const {
92     p.buf = buf;
93     p.pos = pos.getIndex();
94     p.bufPos = bufPos;
95 }
96 
97 void RuleCharacterIterator::setPos(const RuleCharacterIterator::Pos& p) {
98     buf = p.buf;
99     pos.setIndex(p.pos);
100     bufPos = p.bufPos;
101 }
102 
103 void RuleCharacterIterator::skipIgnored(int32_t options) {
104     if ((options & SKIP_WHITESPACE) != 0) {
105         for (;;) {
106             UChar32 a = _current();
107             if (!PatternProps::isWhiteSpace(a)) break;
108             _advance(U16_LENGTH(a));
109         }
110     }
111 }
112 
113 UnicodeString& RuleCharacterIterator::lookahead(UnicodeString& result, int32_t maxLookAhead) const {
114     if (maxLookAhead < 0) {
115         maxLookAhead = 0x7FFFFFFF;
116     }
117     if (buf != 0) {
118         buf->extract(bufPos, maxLookAhead, result);
119     } else {
120         text.extract(pos.getIndex(), maxLookAhead, result);
121     }
122     return result;
123 }
124 
125 void RuleCharacterIterator::jumpahead(int32_t count) {
126     _advance(count);
127 }
128 
129 /*
130 UnicodeString& RuleCharacterIterator::toString(UnicodeString& result) const {
131     int32_t b = pos.getIndex();
132     text.extract(0, b, result);
133     return result.append((UChar) 0x7C).append(text, b, 0x7FFFFFFF); // Insert '|' at index
134 }
135 */
136 
137 UChar32 RuleCharacterIterator::_current() const {
138     if (buf != 0) {
139         return buf->char32At(bufPos);
140     } else {
141         int i = pos.getIndex();
142         return (i < text.length()) ? text.char32At(i) : (UChar32)DONE;
143     }
144 }
145 
146 void RuleCharacterIterator::_advance(int32_t count) {
147     if (buf != 0) {
148         bufPos += count;
149         if (bufPos == buf->length()) {
150             buf = 0;
151         }
152     } else {
153         pos.setIndex(pos.getIndex() + count);
154         if (pos.getIndex() > text.length()) {
155             pos.setIndex(text.length());
156         }
157     }
158 }
159 
160 U_NAMESPACE_END
161 
162 //eof
163