2 * CDE - Common Desktop Environment
4 * Copyright (c) 1993-2012, The Open Group. All rights reserved.
6 * These libraries and programs are free software; you can
7 * redistribute them and/or modify them under the terms of the GNU
8 * Lesser General Public License as published by the Free Software
9 * Foundation; either version 2 of the License, or (at your option)
12 * These libraries and programs are distributed in the hope that
13 * they will be useful, but WITHOUT ANY WARRANTY; without even the
14 * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
15 * PURPOSE. See the GNU Lesser General Public License for more
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with these librararies and programs; if not, write
20 * to the Free Software Foundation, Inc., 51 Franklin Street, Fifth
21 * Floor, Boston, MA 02110-1301 USA
23 /* $XConsortium: Markup.C /main/1 1996/07/29 16:56:39 cde-hp $ */
24 // Copyright (c) 1995 James Clark
25 // See the file COPYING for copying permission.
28 #pragma implementation
33 #include "InputSource.h"
39 namespace SP_NAMESPACE {
42 MarkupItem::MarkupItem()
43 : type(Markup::delimiter), index(0)
47 MarkupItem::~MarkupItem()
50 case Markup::entityStart:
56 case Markup::sdLiteral:
62 MarkupItem::MarkupItem(const MarkupItem &item)
63 : type(item.type), index(item.index)
66 case Markup::entityStart:
67 origin = new ConstPtr<Origin>(*item.origin);
70 text = new Text(*item.text);
72 case Markup::sdLiteral:
73 sdText = new SdText(*item.sdText);
75 case Markup::delimiter:
83 void MarkupItem::operator=(const MarkupItem &item)
86 case Markup::entityStart:
87 if (item.type == Markup::entityStart) {
88 *origin = *item.origin;
94 if (item.type == Markup::literal) {
100 case Markup::sdLiteral:
101 if (item.type == Markup::sdLiteral) {
102 *sdText = *item.sdText;
111 case Markup::entityStart:
112 origin = new ConstPtr<Origin>(*item.origin);
114 case Markup::literal:
115 text = new Text(*item.text);
117 case Markup::sdLiteral:
118 sdText = new SdText(*item.sdText);
120 case Markup::delimiter:
123 nChars = item.nChars;
132 void Markup::resize(size_t n)
134 size_t chopChars = 0;
135 for (size_t i = n; i < items_.size(); i++)
136 switch (items_[i].type) {
137 case Markup::reservedName:
138 case Markup::sdReservedName:
140 case Markup::nameToken:
142 case Markup::attributeValue:
144 case Markup::comment:
145 case Markup::shortref:
146 chopChars += items_[i].nChars;
150 chars_.resize(chars_.size() - chopChars);
153 void Markup::addDelim(Syntax::DelimGeneral d)
155 items_.resize(items_.size() + 1);
156 MarkupItem &item = items_.back();
157 item.type = Markup::delimiter;
161 void Markup::addReservedName(Syntax::ReservedName rn, const InputSource *in)
163 items_.resize(items_.size() + 1);
164 MarkupItem &item = items_.back();
165 size_t length = in->currentTokenLength();
166 item.nChars = length;
167 item.type = Markup::reservedName;
169 chars_.append(in->currentTokenStart(), length);
172 void Markup::addReservedName(Syntax::ReservedName rn, const StringC &str)
174 items_.resize(items_.size() + 1);
175 MarkupItem &item = items_.back();
176 item.nChars = str.size();
177 item.type = Markup::reservedName;
179 chars_.append(str.data(), str.size());
182 void Markup::addSdReservedName(Sd::ReservedName rn, const InputSource *in)
184 items_.resize(items_.size() + 1);
185 MarkupItem &item = items_.back();
186 size_t length = in->currentTokenLength();
187 item.nChars = length;
188 item.type = Markup::sdReservedName;
190 chars_.append(in->currentTokenStart(), length);
193 void Markup::addSdReservedName(Sd::ReservedName rn,
194 const Char *str, size_t length)
196 items_.resize(items_.size() + 1);
197 MarkupItem &item = items_.back();
198 item.nChars = length;
199 item.type = Markup::sdReservedName;
201 chars_.append(str, length);
204 void Markup::addS(Char c)
206 if (items_.size() > 0) {
207 MarkupItem &item = items_.back();
208 if (item.type == Markup::s) {
214 items_.resize(items_.size() + 1);
215 MarkupItem &item = items_.back();
216 item.type = Markup::s;
221 void Markup::addS(const InputSource *in)
223 items_.resize(items_.size() + 1);
224 MarkupItem &item = items_.back();
225 size_t length = in->currentTokenLength();
226 item.nChars = length;
227 item.type = Markup::s;
228 chars_.append(in->currentTokenStart(), length);
231 void Markup::addCommentStart()
233 items_.resize(items_.size() + 1);
234 MarkupItem &item = items_.back();
235 item.type = Markup::comment;
239 void Markup::addRefEndRe()
241 items_.resize(items_.size() + 1);
242 MarkupItem &item = items_.back();
243 item.type = Markup::refEndRe;
246 void Markup::addCommentChar(Char c)
248 items_.back().nChars += 1;
252 void Markup::addName(const InputSource *in)
254 items_.resize(items_.size() + 1);
255 MarkupItem &item = items_.back();
256 size_t length = in->currentTokenLength();
257 item.nChars = length;
258 item.type = Markup::name;
259 chars_.append(in->currentTokenStart(), length);
262 void Markup::addName(const Char *str, size_t length)
264 items_.resize(items_.size() + 1);
265 MarkupItem &item = items_.back();
266 item.nChars = length;
267 item.type = Markup::name;
268 chars_.append(str, length);
271 void Markup::addNumber(const InputSource *in)
273 items_.resize(items_.size() + 1);
274 MarkupItem &item = items_.back();
275 size_t length = in->currentTokenLength();
276 item.nChars = length;
277 item.type = Markup::number;
278 chars_.append(in->currentTokenStart(), length);
281 void Markup::addNameToken(const InputSource *in)
283 items_.resize(items_.size() + 1);
284 MarkupItem &item = items_.back();
285 size_t length = in->currentTokenLength();
286 item.nChars = length;
287 item.type = Markup::nameToken;
288 chars_.append(in->currentTokenStart(), length);
291 void Markup::addAttributeValue(const InputSource *in)
293 items_.resize(items_.size() + 1);
294 MarkupItem &item = items_.back();
295 size_t length = in->currentTokenLength();
296 item.nChars = length;
297 item.type = Markup::attributeValue;
298 chars_.append(in->currentTokenStart(), length);
301 void Markup::addShortref(const InputSource *in)
303 items_.resize(items_.size() + 1);
304 MarkupItem &item = items_.back();
305 size_t length = in->currentTokenLength();
306 item.nChars = length;
307 item.type = Markup::shortref;
308 chars_.append(in->currentTokenStart(), length);
311 void Markup::addEntityStart(const Ptr<EntityOrigin> &origin)
313 items_.resize(items_.size() + 1);
314 MarkupItem &item = items_.back();
315 item.type = Markup::entityStart;
316 item.origin = new ConstPtr<Origin>(origin.pointer());
319 void Markup::addEntityEnd()
321 items_.resize(items_.size() + 1);
322 items_.back().type = Markup::entityEnd;
325 void Markup::addLiteral(const Text &text)
327 items_.resize(items_.size() + 1);
328 MarkupItem &item = items_.back();
329 item.type = Markup::literal;
330 item.text = new Text(text);
333 void Markup::addSdLiteral(const SdText &sdText)
335 items_.resize(items_.size() + 1);
336 MarkupItem &item = items_.back();
337 item.type = Markup::sdLiteral;
338 item.sdText = new SdText(sdText);
341 void Markup::changeToAttributeValue(size_t i)
343 ASSERT(items_[i].type == Markup::name);
344 items_[i].type = Markup::attributeValue;
347 void Markup::swap(Markup &to)
349 chars_.swap(to.chars_);
350 items_.swap(to.items_);
353 MarkupIter::MarkupIter(const Markup &m)
354 : chars_(m.chars_.data()),
355 items_(m.items_.begin()),
356 nItems_(m.items_.size()),
362 void MarkupIter::advance(Location &loc,
363 const ConstPtr<Syntax> &syntax)
365 switch (items_[index_].type) {
366 case Markup::delimiter:
367 loc += syntax->delimGeneral(delimGeneral()).size();
369 case Markup::refEndRe:
372 case Markup::reservedName:
373 case Markup::sdReservedName:
375 case Markup::nameToken:
377 case Markup::attributeValue:
379 case Markup::shortref:
380 loc += items_[index_].nChars;
381 charIndex_ += items_[index_].nChars;
383 case Markup::comment:
384 loc += items_[index_].nChars + (2 * syntax->delimGeneral(Syntax::dCOM).size());
385 charIndex_ += items_[index_].nChars;
387 case Markup::entityStart:
388 loc = Location(*items_[index_].origin, 0);
390 case Markup::entityEnd:
392 ConstPtr<Origin> origin(loc.origin());
393 loc = origin->parent();
394 loc += origin->refLength();
397 case Markup::literal:
399 const Text &text = *items_[index_].text;
400 text.endDelimLocation(loc);
402 text.delimType(lita);
404 += syntax->delimGeneral(lita ? Syntax::dLITA : Syntax::dLIT).size();
407 case Markup::sdLiteral:
409 const SdText &text = *items_[index_].sdText;
410 loc = text.endDelimLocation();
418 void MarkupIter::advance()
420 switch (items_[index_].type) {
421 case Markup::reservedName:
422 case Markup::sdReservedName:
424 case Markup::nameToken:
426 case Markup::attributeValue:
428 case Markup::comment:
429 case Markup::shortref:
430 charIndex_ += items_[index_].nChars;