Chameleon

Chameleon Svn Source Tree

Root/branches/xZenu/src/modules/TinyXML/tinyxmlparser.cpp

Source at commit 1307 created 12 years 8 months ago.
By meklort, Add TinyXML as a module
1/*␊
2www.sourceforge.net/projects/tinyxml␊
3Original code by Lee Thomason (www.grinninglizard.com)␊
4␊
5This software is provided 'as-is', without any express or implied ␊
6warranty. In no event will the authors be held liable for any ␊
7damages arising from the use of this software.␊
8␊
9Permission is granted to anyone to use this software for any ␊
10purpose, including commercial applications, and to alter it and ␊
11redistribute it freely, subject to the following restrictions:␊
12␊
131. The origin of this software must not be misrepresented; you must ␊
14not claim that you wrote the original software. If you use this␊
15software in a product, an acknowledgment in the product documentation␊
16would be appreciated but is not required.␊
17␊
182. Altered source versions must be plainly marked as such, and ␊
19must not be misrepresented as being the original software.␊
20␊
213. This notice may not be removed or altered from any source ␊
22distribution.␊
23*/␊
24␊
25#include <ctype.h>␊
26#include <stddef.h>␊
27␊
28#include "tinyxml.h"␊
29␊
30//#define DEBUG_PARSER␊
31#if defined( DEBUG_PARSER )␊
32#␉if defined( DEBUG ) && defined( _MSC_VER )␊
33#␉␉include <windows.h>␊
34#␉␉define TIXML_LOG OutputDebugString␊
35#␉else␊
36#␉␉define TIXML_LOG printf␊
37#␉endif␊
38#endif␊
39␊
40// Note tha "PutString" hardcodes the same list. This␊
41// is less flexible than it appears. Changing the entries␊
42// or order will break putstring.␉␊
43TiXmlBase::Entity TiXmlBase::entity[ TiXmlBase::NUM_ENTITY ] = ␊
44{␊
45␉{ "&amp;", 5, '&' },␊
46␉{ "&lt;", 4, '<' },␊
47␉{ "&gt;", 4, '>' },␊
48␉{ "&quot;", 6, '\"' },␊
49␉{ "&apos;", 6, '\'' }␊
50};␊
51␊
52// Bunch of unicode info at:␊
53//␉␉http://www.unicode.org/faq/utf_bom.html␊
54// Including the basic of this table, which determines the #bytes in the␊
55// sequence from the lead byte. 1 placed for invalid sequences --␊
56// although the result will be junk, pass it through as much as possible.␊
57// Beware of the non-characters in UTF-8:␉␊
58//␉␉␉␉ef bb bf (Microsoft "lead bytes")␊
59//␉␉␉␉ef bf be␊
60//␉␉␉␉ef bf bf ␊
61␊
62const unsigned char TIXML_UTF_LEAD_0 = 0xefU;␊
63const unsigned char TIXML_UTF_LEAD_1 = 0xbbU;␊
64const unsigned char TIXML_UTF_LEAD_2 = 0xbfU;␊
65␊
66const int TiXmlBase::utf8ByteTable[256] = ␊
67{␊
68␉//␉0␉1␉2␉3␉4␉5␉6␉7␉8␉9␉a␉b␉c␉d␉e␉f␊
69␉␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉// 0x00␊
70␉␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉// 0x10␊
71␉␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉// 0x20␊
72␉␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉// 0x30␊
73␉␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉// 0x40␊
74␉␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉// 0x50␊
75␉␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉// 0x60␊
76␉␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉// 0x70␉End of ASCII range␊
77␉␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉// 0x80 0x80 to 0xc1 invalid␊
78␉␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉// 0x90 ␊
79␉␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉// 0xa0 ␊
80␉␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉// 0xb0 ␊
81␉␉1,␉1,␉2,␉2,␉2,␉2,␉2,␉2,␉2,␉2,␉2,␉2,␉2,␉2,␉2,␉2,␉// 0xc0 0xc2 to 0xdf 2 byte␊
82␉␉2,␉2,␉2,␉2,␉2,␉2,␉2,␉2,␉2,␉2,␉2,␉2,␉2,␉2,␉2,␉2,␉// 0xd0␊
83␉␉3,␉3,␉3,␉3,␉3,␉3,␉3,␉3,␉3,␉3,␉3,␉3,␉3,␉3,␉3,␉3,␉// 0xe0 0xe0 to 0xef 3 byte␊
84␉␉4,␉4,␉4,␉4,␉4,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1,␉1␉// 0xf0 0xf0 to 0xf4 4 byte, 0xf5 and higher invalid␊
85};␊
86␊
87␊
88void TiXmlBase::ConvertUTF32ToUTF8( unsigned long input, char* output, int* length )␊
89{␊
90␉const unsigned long BYTE_MASK = 0xBF;␊
91␉const unsigned long BYTE_MARK = 0x80;␊
92␉const unsigned long FIRST_BYTE_MARK[7] = { 0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC };␊
93␊
94␉if (input < 0x80) ␊
95␉␉*length = 1;␊
96␉else if ( input < 0x800 )␊
97␉␉*length = 2;␊
98␉else if ( input < 0x10000 )␊
99␉␉*length = 3;␊
100␉else if ( input < 0x200000 )␊
101␉␉*length = 4;␊
102␉else␊
103␉␉{ *length = 0; return; }␉// This code won't covert this correctly anyway.␊
104␊
105␉output += *length;␊
106␊
107␉// Scary scary fall throughs.␊
108␉switch (*length) ␊
109␉{␊
110␉␉case 4:␊
111␉␉␉--output; ␊
112␉␉␉*output = (char)((input | BYTE_MARK) & BYTE_MASK); ␊
113␉␉␉input >>= 6;␊
114␉␉case 3:␊
115␉␉␉--output; ␊
116␉␉␉*output = (char)((input | BYTE_MARK) & BYTE_MASK); ␊
117␉␉␉input >>= 6;␊
118␉␉case 2:␊
119␉␉␉--output; ␊
120␉␉␉*output = (char)((input | BYTE_MARK) & BYTE_MASK); ␊
121␉␉␉input >>= 6;␊
122␉␉case 1:␊
123␉␉␉--output; ␊
124␉␉␉*output = (char)(input | FIRST_BYTE_MARK[*length]);␊
125␉}␊
126}␊
127␊
128␊
129/*static*/ int TiXmlBase::IsAlpha( unsigned char anyByte, TiXmlEncoding /*encoding*/ )␊
130{␊
131␉// This will only work for low-ascii, everything else is assumed to be a valid␊
132␉// letter. I'm not sure this is the best approach, but it is quite tricky trying␊
133␉// to figure out alhabetical vs. not across encoding. So take a very ␊
134␉// conservative approach.␊
135␊
136//␉if ( encoding == TIXML_ENCODING_UTF8 )␊
137//␉{␊
138␉␉if ( anyByte < 127 )␊
139␉␉␉return isalpha( anyByte );␊
140␉␉else␊
141␉␉␉return 1;␉// What else to do? The unicode set is huge...get the english ones right.␊
142//␉}␊
143//␉else␊
144//␉{␊
145//␉␉return isalpha( anyByte );␊
146//␉}␊
147}␊
148␊
149␊
150/*static*/ int TiXmlBase::IsAlphaNum( unsigned char anyByte, TiXmlEncoding /*encoding*/ )␊
151{␊
152␉// This will only work for low-ascii, everything else is assumed to be a valid␊
153␉// letter. I'm not sure this is the best approach, but it is quite tricky trying␊
154␉// to figure out alhabetical vs. not across encoding. So take a very ␊
155␉// conservative approach.␊
156␊
157//␉if ( encoding == TIXML_ENCODING_UTF8 )␊
158//␉{␊
159␉␉if ( anyByte < 127 )␊
160␉␉␉return isalnum( anyByte );␊
161␉␉else␊
162␉␉␉return 1;␉// What else to do? The unicode set is huge...get the english ones right.␊
163//␉}␊
164//␉else␊
165//␉{␊
166//␉␉return isalnum( anyByte );␊
167//␉}␊
168}␊
169␊
170␊
171class TiXmlParsingData␊
172{␊
173␉friend class TiXmlDocument;␊
174 public:␊
175␉void Stamp( const char* now, TiXmlEncoding encoding );␊
176␊
177␉const TiXmlCursor& Cursor() const␉{ return cursor; }␊
178␊
179 private:␊
180␉// Only used by the document!␊
181␉TiXmlParsingData( const char* start, int _tabsize, int row, int col )␊
182␉{␊
183␉␉assert( start );␊
184␉␉stamp = start;␊
185␉␉tabsize = _tabsize;␊
186␉␉cursor.row = row;␊
187␉␉cursor.col = col;␊
188␉}␊
189␊
190␉TiXmlCursor␉␉cursor;␊
191␉const char*␉␉stamp;␊
192␉int␉␉␉␉tabsize;␊
193};␊
194␊
195␊
196void TiXmlParsingData::Stamp( const char* now, TiXmlEncoding encoding )␊
197{␊
198␉assert( now );␊
199␊
200␉// Do nothing if the tabsize is 0.␊
201␉if ( tabsize < 1 )␊
202␉{␊
203␉␉return;␊
204␉}␊
205␊
206␉// Get the current row, column.␊
207␉int row = cursor.row;␊
208␉int col = cursor.col;␊
209␉const char* p = stamp;␊
210␉assert( p );␊
211␊
212␉while ( p < now )␊
213␉{␊
214␉␉// Treat p as unsigned, so we have a happy compiler.␊
215␉␉const unsigned char* pU = (const unsigned char*)p;␊
216␊
217␉␉// Code contributed by Fletcher Dunn: (modified by lee)␊
218␉␉switch (*pU) {␊
219␉␉␉case 0:␊
220␉␉␉␉// We *should* never get here, but in case we do, don't␊
221␉␉␉␉// advance past the terminating null character, ever␊
222␉␉␉␉return;␊
223␊
224␉␉␉case '\r':␊
225␉␉␉␉// bump down to the next line␊
226␉␉␉␉++row;␊
227␉␉␉␉col = 0;␉␉␉␉␊
228␉␉␉␉// Eat the character␊
229␉␉␉␉++p;␊
230␊
231␉␉␉␉// Check for \r\n sequence, and treat this as a single character␊
232␉␉␉␉if (*p == '\n') {␊
233␉␉␉␉␉++p;␊
234␉␉␉␉}␊
235␉␉␉␉break;␊
236␊
237␉␉␉case '\n':␊
238␉␉␉␉// bump down to the next line␊
239␉␉␉␉++row;␊
240␉␉␉␉col = 0;␊
241␊
242␉␉␉␉// Eat the character␊
243␉␉␉␉++p;␊
244␊
245␉␉␉␉// Check for \n\r sequence, and treat this as a single␊
246␉␉␉␉// character. (Yes, this bizarre thing does occur still␊
247␉␉␉␉// on some arcane platforms...)␊
248␉␉␉␉if (*p == '\r') {␊
249␉␉␉␉␉++p;␊
250␉␉␉␉}␊
251␉␉␉␉break;␊
252␊
253␉␉␉case '\t':␊
254␉␉␉␉// Eat the character␊
255␉␉␉␉++p;␊
256␊
257␉␉␉␉// Skip to next tab stop␊
258␉␉␉␉col = (col / tabsize + 1) * tabsize;␊
259␉␉␉␉break;␊
260␊
261␉␉␉case TIXML_UTF_LEAD_0:␊
262␉␉␉␉if ( encoding == TIXML_ENCODING_UTF8 )␊
263␉␉␉␉{␊
264␉␉␉␉␉if ( *(p+1) && *(p+2) )␊
265␉␉␉␉␉{␊
266␉␉␉␉␉␉// In these cases, don't advance the column. These are␊
267␉␉␉␉␉␉// 0-width spaces.␊
268␉␉␉␉␉␉if ( *(pU+1)==TIXML_UTF_LEAD_1 && *(pU+2)==TIXML_UTF_LEAD_2 )␊
269␉␉␉␉␉␉␉p += 3;␉␊
270␉␉␉␉␉␉else if ( *(pU+1)==0xbfU && *(pU+2)==0xbeU )␊
271␉␉␉␉␉␉␉p += 3;␉␊
272␉␉␉␉␉␉else if ( *(pU+1)==0xbfU && *(pU+2)==0xbfU )␊
273␉␉␉␉␉␉␉p += 3;␉␊
274␉␉␉␉␉␉else␊
275␉␉␉␉␉␉␉{ p +=3; ++col; }␉// A normal character.␊
276␉␉␉␉␉}␊
277␉␉␉␉}␊
278␉␉␉␉else␊
279␉␉␉␉{␊
280␉␉␉␉␉++p;␊
281␉␉␉␉␉++col;␊
282␉␉␉␉}␊
283␉␉␉␉break;␊
284␊
285␉␉␉default:␊
286␉␉␉␉if ( encoding == TIXML_ENCODING_UTF8 )␊
287␉␉␉␉{␊
288␉␉␉␉␉// Eat the 1 to 4 byte utf8 character.␊
289␉␉␉␉␉int step = TiXmlBase::utf8ByteTable[*((const unsigned char*)p)];␊
290␉␉␉␉␉if ( step == 0 )␊
291␉␉␉␉␉␉step = 1;␉␉// Error case from bad encoding, but handle gracefully.␊
292␉␉␉␉␉p += step;␊
293␊
294␉␉␉␉␉// Just advance one column, of course.␊
295␉␉␉␉␉++col;␊
296␉␉␉␉}␊
297␉␉␉␉else␊
298␉␉␉␉{␊
299␉␉␉␉␉++p;␊
300␉␉␉␉␉++col;␊
301␉␉␉␉}␊
302␉␉␉␉break;␊
303␉␉}␊
304␉}␊
305␉cursor.row = row;␊
306␉cursor.col = col;␊
307␉assert( cursor.row >= -1 );␊
308␉assert( cursor.col >= -1 );␊
309␉stamp = p;␊
310␉assert( stamp );␊
311}␊
312␊
313␊
314const char* TiXmlBase::SkipWhiteSpace( const char* p, TiXmlEncoding encoding )␊
315{␊
316␉if ( !p || !*p )␊
317␉{␊
318␉␉return 0;␊
319␉}␊
320␉if ( encoding == TIXML_ENCODING_UTF8 )␊
321␉{␊
322␉␉while ( *p )␊
323␉␉{␊
324␉␉␉const unsigned char* pU = (const unsigned char*)p;␊
325␉␉␉␊
326␉␉␉// Skip the stupid Microsoft UTF-8 Byte order marks␊
327␉␉␉if (␉*(pU+0)==TIXML_UTF_LEAD_0␊
328␉␉␉␉ && *(pU+1)==TIXML_UTF_LEAD_1 ␊
329␉␉␉␉ && *(pU+2)==TIXML_UTF_LEAD_2 )␊
330␉␉␉{␊
331␉␉␉␉p += 3;␊
332␉␉␉␉continue;␊
333␉␉␉}␊
334␉␉␉else if(*(pU+0)==TIXML_UTF_LEAD_0␊
335␉␉␉␉ && *(pU+1)==0xbfU␊
336␉␉␉␉ && *(pU+2)==0xbeU )␊
337␉␉␉{␊
338␉␉␉␉p += 3;␊
339␉␉␉␉continue;␊
340␉␉␉}␊
341␉␉␉else if(*(pU+0)==TIXML_UTF_LEAD_0␊
342␉␉␉␉ && *(pU+1)==0xbfU␊
343␉␉␉␉ && *(pU+2)==0xbfU )␊
344␉␉␉{␊
345␉␉␉␉p += 3;␊
346␉␉␉␉continue;␊
347␉␉␉}␊
348␊
349␉␉␉if ( IsWhiteSpace( *p ) )␉␉// Still using old rules for white space.␊
350␉␉␉␉++p;␊
351␉␉␉else␊
352␉␉␉␉break;␊
353␉␉}␊
354␉}␊
355␉else␊
356␉{␊
357␉␉while ( *p && IsWhiteSpace( *p ) )␊
358␉␉␉++p;␊
359␉}␊
360␊
361␉return p;␊
362}␊
363␊
364#ifdef TIXML_USE_STL␊
365/*static*/ bool TiXmlBase::StreamWhiteSpace( std::istream * in, TIXML_STRING * tag )␊
366{␊
367␉for( ;; )␊
368␉{␊
369␉␉if ( !in->good() ) return false;␊
370␊
371␉␉int c = in->peek();␊
372␉␉// At this scope, we can't get to a document. So fail silently.␊
373␉␉if ( !IsWhiteSpace( c ) || c <= 0 )␊
374␉␉␉return true;␊
375␊
376␉␉*tag += (char) in->get();␊
377␉}␊
378}␊
379␊
380/*static*/ bool TiXmlBase::StreamTo( std::istream * in, int character, TIXML_STRING * tag )␊
381{␊
382␉//assert( character > 0 && character < 128 );␉// else it won't work in utf-8␊
383␉while ( in->good() )␊
384␉{␊
385␉␉int c = in->peek();␊
386␉␉if ( c == character )␊
387␉␉␉return true;␊
388␉␉if ( c <= 0 )␉␉// Silent failure: can't get document at this scope␊
389␉␉␉return false;␊
390␊
391␉␉in->get();␊
392␉␉*tag += (char) c;␊
393␉}␊
394␉return false;␊
395}␊
396#endif␊
397␊
398// One of TinyXML's more performance demanding functions. Try to keep the memory overhead down. The␊
399// "assign" optimization removes over 10% of the execution time.␊
400//␊
401const char* TiXmlBase::ReadName( const char* p, TIXML_STRING * name, TiXmlEncoding encoding )␊
402{␊
403␉// Oddly, not supported on some comilers,␊
404␉//name->clear();␊
405␉// So use this:␊
406␉*name = "";␊
407␉assert( p );␊
408␊
409␉// Names start with letters or underscores.␊
410␉// Of course, in unicode, tinyxml has no idea what a letter *is*. The␊
411␉// algorithm is generous.␊
412␉//␊
413␉// After that, they can be letters, underscores, numbers,␊
414␉// hyphens, or colons. (Colons are valid ony for namespaces,␊
415␉// but tinyxml can't tell namespaces from names.)␊
416␉if ( p && *p ␊
417␉␉ && ( IsAlpha( (unsigned char) *p, encoding ) || *p == '_' ) )␊
418␉{␊
419␉␉const char* start = p;␊
420␉␉while(␉␉p && *p␊
421␉␉␉␉&&␉(␉␉IsAlphaNum( (unsigned char ) *p, encoding ) ␊
422␉␉␉␉␉␉ || *p == '_'␊
423␉␉␉␉␉␉ || *p == '-'␊
424␉␉␉␉␉␉ || *p == '.'␊
425␉␉␉␉␉␉ || *p == ':' ) )␊
426␉␉{␊
427␉␉␉//(*name) += *p; // expensive␊
428␉␉␉++p;␊
429␉␉}␊
430␉␉if ( p-start > 0 ) {␊
431␉␉␉name->assign( start, p-start );␊
432␉␉}␊
433␉␉return p;␊
434␉}␊
435␉return 0;␊
436}␊
437␊
438const char* TiXmlBase::GetEntity( const char* p, char* value, int* length, TiXmlEncoding encoding )␊
439{␊
440␉// Presume an entity, and pull it out.␊
441 TIXML_STRING ent;␊
442␉int i;␊
443␉*length = 0;␊
444␊
445␉if ( *(p+1) && *(p+1) == '#' && *(p+2) )␊
446␉{␊
447␉␉unsigned long ucs = 0;␊
448␉␉ptrdiff_t delta = 0;␊
449␉␉unsigned mult = 1;␊
450␊
451␉␉if ( *(p+2) == 'x' )␊
452␉␉{␊
453␉␉␉// Hexadecimal.␊
454␉␉␉if ( !*(p+3) ) return 0;␊
455␊
456␉␉␉const char* q = p+3;␊
457␉␉␉q = strchr( q, ';' );␊
458␊
459␉␉␉if ( !q || !*q ) return 0;␊
460␊
461␉␉␉delta = q-p;␊
462␉␉␉--q;␊
463␊
464␉␉␉while ( *q != 'x' )␊
465␉␉␉{␊
466␉␉␉␉if ( *q >= '0' && *q <= '9' )␊
467␉␉␉␉␉ucs += mult * (*q - '0');␊
468␉␉␉␉else if ( *q >= 'a' && *q <= 'f' )␊
469␉␉␉␉␉ucs += mult * (*q - 'a' + 10);␊
470␉␉␉␉else if ( *q >= 'A' && *q <= 'F' )␊
471␉␉␉␉␉ucs += mult * (*q - 'A' + 10 );␊
472␉␉␉␉else ␊
473␉␉␉␉␉return 0;␊
474␉␉␉␉mult *= 16;␊
475␉␉␉␉--q;␊
476␉␉␉}␊
477␉␉}␊
478␉␉else␊
479␉␉{␊
480␉␉␉// Decimal.␊
481␉␉␉if ( !*(p+2) ) return 0;␊
482␊
483␉␉␉const char* q = p+2;␊
484␉␉␉q = strchr( q, ';' );␊
485␊
486␉␉␉if ( !q || !*q ) return 0;␊
487␊
488␉␉␉delta = q-p;␊
489␉␉␉--q;␊
490␊
491␉␉␉while ( *q != '#' )␊
492␉␉␉{␊
493␉␉␉␉if ( *q >= '0' && *q <= '9' )␊
494␉␉␉␉␉ucs += mult * (*q - '0');␊
495␉␉␉␉else ␊
496␉␉␉␉␉return 0;␊
497␉␉␉␉mult *= 10;␊
498␉␉␉␉--q;␊
499␉␉␉}␊
500␉␉}␊
501␉␉if ( encoding == TIXML_ENCODING_UTF8 )␊
502␉␉{␊
503␉␉␉// convert the UCS to UTF-8␊
504␉␉␉ConvertUTF32ToUTF8( ucs, value, length );␊
505␉␉}␊
506␉␉else␊
507␉␉{␊
508␉␉␉*value = (char)ucs;␊
509␉␉␉*length = 1;␊
510␉␉}␊
511␉␉return p + delta + 1;␊
512␉}␊
513␊
514␉// Now try to match it.␊
515␉for( i=0; i<NUM_ENTITY; ++i )␊
516␉{␊
517␉␉if ( strncmp( entity[i].str, p, entity[i].strLength ) == 0 )␊
518␉␉{␊
519␉␉␉assert( strlen( entity[i].str ) == entity[i].strLength );␊
520␉␉␉*value = entity[i].chr;␊
521␉␉␉*length = 1;␊
522␉␉␉return ( p + entity[i].strLength );␊
523␉␉}␊
524␉}␊
525␊
526␉// So it wasn't an entity, its unrecognized, or something like that.␊
527␉*value = *p;␉// Don't put back the last one, since we return it!␊
528␉//*length = 1;␉// Leave unrecognized entities - this doesn't really work.␊
529␉␉␉␉␉// Just writes strange XML.␊
530␉return p+1;␊
531}␊
532␊
533␊
534bool TiXmlBase::StringEqual( const char* p,␊
535␉␉␉␉␉␉␉ const char* tag,␊
536␉␉␉␉␉␉␉ bool ignoreCase,␊
537␉␉␉␉␉␉␉ TiXmlEncoding encoding )␊
538{␊
539␉assert( p );␊
540␉assert( tag );␊
541␉if ( !p || !*p )␊
542␉{␊
543␉␉assert( 0 );␊
544␉␉return false;␊
545␉}␊
546␊
547␉const char* q = p;␊
548␊
549␉if ( ignoreCase )␊
550␉{␊
551␉␉while ( *q && *tag && ToLower( *q, encoding ) == ToLower( *tag, encoding ) )␊
552␉␉{␊
553␉␉␉++q;␊
554␉␉␉++tag;␊
555␉␉}␊
556␊
557␉␉if ( *tag == 0 )␊
558␉␉␉return true;␊
559␉}␊
560␉else␊
561␉{␊
562␉␉while ( *q && *tag && *q == *tag )␊
563␉␉{␊
564␉␉␉++q;␊
565␉␉␉++tag;␊
566␉␉}␊
567␊
568␉␉if ( *tag == 0 )␉␉// Have we found the end of the tag, and everything equal?␊
569␉␉␉return true;␊
570␉}␊
571␉return false;␊
572}␊
573␊
574const char* TiXmlBase::ReadText(␉const char* p, ␊
575␉␉␉␉␉␉␉␉␉TIXML_STRING * text, ␊
576␉␉␉␉␉␉␉␉␉bool trimWhiteSpace, ␊
577␉␉␉␉␉␉␉␉␉const char* endTag, ␊
578␉␉␉␉␉␉␉␉␉bool caseInsensitive,␊
579␉␉␉␉␉␉␉␉␉TiXmlEncoding encoding )␊
580{␊
581 *text = "";␊
582␉if ( !trimWhiteSpace␉␉␉// certain tags always keep whitespace␊
583␉␉ || !condenseWhiteSpace )␉// if true, whitespace is always kept␊
584␉{␊
585␉␉// Keep all the white space.␊
586␉␉while (␉ p && *p␊
587␉␉␉␉&& !StringEqual( p, endTag, caseInsensitive, encoding )␊
588␉␉␉ )␊
589␉␉{␊
590␉␉␉int len;␊
591␉␉␉char cArr[4] = { 0, 0, 0, 0 };␊
592␉␉␉p = GetChar( p, cArr, &len, encoding );␊
593␉␉␉text->append( cArr, len );␊
594␉␉}␊
595␉}␊
596␉else␊
597␉{␊
598␉␉bool whitespace = false;␊
599␊
600␉␉// Remove leading white space:␊
601␉␉p = SkipWhiteSpace( p, encoding );␊
602␉␉while (␉ p && *p␊
603␉␉␉␉&& !StringEqual( p, endTag, caseInsensitive, encoding ) )␊
604␉␉{␊
605␉␉␉if ( *p == '\r' || *p == '\n' )␊
606␉␉␉{␊
607␉␉␉␉whitespace = true;␊
608␉␉␉␉++p;␊
609␉␉␉}␊
610␉␉␉else if ( IsWhiteSpace( *p ) )␊
611␉␉␉{␊
612␉␉␉␉whitespace = true;␊
613␉␉␉␉++p;␊
614␉␉␉}␊
615␉␉␉else␊
616␉␉␉{␊
617␉␉␉␉// If we've found whitespace, add it before the␊
618␉␉␉␉// new character. Any whitespace just becomes a space.␊
619␉␉␉␉if ( whitespace )␊
620␉␉␉␉{␊
621␉␉␉␉␉(*text) += ' ';␊
622␉␉␉␉␉whitespace = false;␊
623␉␉␉␉}␊
624␉␉␉␉int len;␊
625␉␉␉␉char cArr[4] = { 0, 0, 0, 0 };␊
626␉␉␉␉p = GetChar( p, cArr, &len, encoding );␊
627␉␉␉␉if ( len == 1 )␊
628␉␉␉␉␉(*text) += cArr[0];␉// more efficient␊
629␉␉␉␉else␊
630␉␉␉␉␉text->append( cArr, len );␊
631␉␉␉}␊
632␉␉}␊
633␉}␊
634␉if ( p && *p )␊
635␉␉p += strlen( endTag );␊
636␉return ( p && *p ) ? p : 0;␊
637}␊
638␊
639#ifdef TIXML_USE_STL␊
640␊
641void TiXmlDocument::StreamIn( std::istream * in, TIXML_STRING * tag )␊
642{␊
643␉// The basic issue with a document is that we don't know what we're␊
644␉// streaming. Read something presumed to be a tag (and hope), then␊
645␉// identify it, and call the appropriate stream method on the tag.␊
646␉//␊
647␉// This "pre-streaming" will never read the closing ">" so the␊
648␉// sub-tag can orient itself.␊
649␊
650␉if ( !StreamTo( in, '<', tag ) ) ␊
651␉{␊
652␉␉SetError( TIXML_ERROR_PARSING_EMPTY, 0, 0, TIXML_ENCODING_UNKNOWN );␊
653␉␉return;␊
654␉}␊
655␊
656␉while ( in->good() )␊
657␉{␊
658␉␉int tagIndex = (int) tag->length();␊
659␉␉while ( in->good() && in->peek() != '>' )␊
660␉␉{␊
661␉␉␉int c = in->get();␊
662␉␉␉if ( c <= 0 )␊
663␉␉␉{␊
664␉␉␉␉SetError( TIXML_ERROR_EMBEDDED_NULL, 0, 0, TIXML_ENCODING_UNKNOWN );␊
665␉␉␉␉break;␊
666␉␉␉}␊
667␉␉␉(*tag) += (char) c;␊
668␉␉}␊
669␊
670␉␉if ( in->good() )␊
671␉␉{␊
672␉␉␉// We now have something we presume to be a node of ␊
673␉␉␉// some sort. Identify it, and call the node to␊
674␉␉␉// continue streaming.␊
675␉␉␉TiXmlNode* node = Identify( tag->c_str() + tagIndex, TIXML_DEFAULT_ENCODING );␊
676␊
677␉␉␉if ( node )␊
678␉␉␉{␊
679␉␉␉␉node->StreamIn( in, tag );␊
680␉␉␉␉bool isElement = node->ToElement() != 0;␊
681␉␉␉␉delete node;␊
682␉␉␉␉node = 0;␊
683␊
684␉␉␉␉// If this is the root element, we're done. Parsing will be␊
685␉␉␉␉// done by the >> operator.␊
686␉␉␉␉if ( isElement )␊
687␉␉␉␉{␊
688␉␉␉␉␉return;␊
689␉␉␉␉}␊
690␉␉␉}␊
691␉␉␉else␊
692␉␉␉{␊
693␉␉␉␉SetError( TIXML_ERROR, 0, 0, TIXML_ENCODING_UNKNOWN );␊
694␉␉␉␉return;␊
695␉␉␉}␊
696␉␉}␊
697␉}␊
698␉// We should have returned sooner.␊
699␉SetError( TIXML_ERROR, 0, 0, TIXML_ENCODING_UNKNOWN );␊
700}␊
701␊
702#endif␊
703␊
704const char* TiXmlDocument::Parse( const char* p, TiXmlParsingData* prevData, TiXmlEncoding encoding )␊
705{␊
706␉ClearError();␊
707␊
708␉// Parse away, at the document level. Since a document␊
709␉// contains nothing but other tags, most of what happens␊
710␉// here is skipping white space.␊
711␉if ( !p || !*p )␊
712␉{␊
713␉␉SetError( TIXML_ERROR_DOCUMENT_EMPTY, 0, 0, TIXML_ENCODING_UNKNOWN );␊
714␉␉return 0;␊
715␉}␊
716␊
717␉// Note that, for a document, this needs to come␊
718␉// before the while space skip, so that parsing␊
719␉// starts from the pointer we are given.␊
720␉location.Clear();␊
721␉if ( prevData )␊
722␉{␊
723␉␉location.row = prevData->cursor.row;␊
724␉␉location.col = prevData->cursor.col;␊
725␉}␊
726␉else␊
727␉{␊
728␉␉location.row = 0;␊
729␉␉location.col = 0;␊
730␉}␊
731␉TiXmlParsingData data( p, TabSize(), location.row, location.col );␊
732␉location = data.Cursor();␊
733␊
734␉if ( encoding == TIXML_ENCODING_UNKNOWN )␊
735␉{␊
736␉␉// Check for the Microsoft UTF-8 lead bytes.␊
737␉␉const unsigned char* pU = (const unsigned char*)p;␊
738␉␉if (␉*(pU+0) && *(pU+0) == TIXML_UTF_LEAD_0␊
739␉␉␉ && *(pU+1) && *(pU+1) == TIXML_UTF_LEAD_1␊
740␉␉␉ && *(pU+2) && *(pU+2) == TIXML_UTF_LEAD_2 )␊
741␉␉{␊
742␉␉␉encoding = TIXML_ENCODING_UTF8;␊
743␉␉␉useMicrosoftBOM = true;␊
744␉␉}␊
745␉}␊
746␊
747 p = SkipWhiteSpace( p, encoding );␊
748␉if ( !p )␊
749␉{␊
750␉␉SetError( TIXML_ERROR_DOCUMENT_EMPTY, 0, 0, TIXML_ENCODING_UNKNOWN );␊
751␉␉return 0;␊
752␉}␊
753␊
754␉while ( p && *p )␊
755␉{␊
756␉␉TiXmlNode* node = Identify( p, encoding );␊
757␉␉if ( node )␊
758␉␉{␊
759␉␉␉p = node->Parse( p, &data, encoding );␊
760␉␉␉LinkEndChild( node );␊
761␉␉}␊
762␉␉else␊
763␉␉{␊
764␉␉␉break;␊
765␉␉}␊
766␊
767␉␉// Did we get encoding info?␊
768␉␉if ( encoding == TIXML_ENCODING_UNKNOWN␊
769␉␉␉ && node->ToDeclaration() )␊
770␉␉{␊
771␉␉␉TiXmlDeclaration* dec = node->ToDeclaration();␊
772␉␉␉const char* enc = dec->Encoding();␊
773␉␉␉assert( enc );␊
774␊
775␉␉␉if ( *enc == 0 )␊
776␉␉␉␉encoding = TIXML_ENCODING_UTF8;␊
777␉␉␉else if ( StringEqual( enc, "UTF-8", true, TIXML_ENCODING_UNKNOWN ) )␊
778␉␉␉␉encoding = TIXML_ENCODING_UTF8;␊
779␉␉␉else if ( StringEqual( enc, "UTF8", true, TIXML_ENCODING_UNKNOWN ) )␊
780␉␉␉␉encoding = TIXML_ENCODING_UTF8;␉// incorrect, but be nice␊
781␉␉␉else ␊
782␉␉␉␉encoding = TIXML_ENCODING_LEGACY;␊
783␉␉}␊
784␊
785␉␉p = SkipWhiteSpace( p, encoding );␊
786␉}␊
787␊
788␉// Was this empty?␊
789␉if ( !firstChild ) {␊
790␉␉SetError( TIXML_ERROR_DOCUMENT_EMPTY, 0, 0, encoding );␊
791␉␉return 0;␊
792␉}␊
793␊
794␉// All is well.␊
795␉return p;␊
796}␊
797␊
798void TiXmlDocument::SetError( int err, const char* pError, TiXmlParsingData* data, TiXmlEncoding encoding )␊
799{␉␊
800␉// The first error in a chain is more accurate - don't set again!␊
801␉if ( error )␊
802␉␉return;␊
803␊
804␉assert( err > 0 && err < TIXML_ERROR_STRING_COUNT );␊
805␉error = true;␊
806␉errorId = err;␊
807␉errorDesc = errorString[ errorId ];␊
808␊
809␉errorLocation.Clear();␊
810␉if ( pError && data )␊
811␉{␊
812␉␉data->Stamp( pError, encoding );␊
813␉␉errorLocation = data->Cursor();␊
814␉}␊
815}␊
816␊
817␊
818TiXmlNode* TiXmlNode::Identify( const char* p, TiXmlEncoding encoding )␊
819{␊
820␉TiXmlNode* returnNode = 0;␊
821␊
822␉p = SkipWhiteSpace( p, encoding );␊
823␉if( !p || !*p || *p != '<' )␊
824␉{␊
825␉␉return 0;␊
826␉}␊
827␊
828␉p = SkipWhiteSpace( p, encoding );␊
829␊
830␉if ( !p || !*p )␊
831␉{␊
832␉␉return 0;␊
833␉}␊
834␊
835␉// What is this thing? ␊
836␉// - Elements start with a letter or underscore, but xml is reserved.␊
837␉// - Comments: <!--␊
838␉// - Decleration: <?xml␊
839␉// - Everthing else is unknown to tinyxml.␊
840␉//␊
841␊
842␉const char* xmlHeader = { "<?xml" };␊
843␉const char* commentHeader = { "<!--" };␊
844␉const char* dtdHeader = { "<!" };␊
845␉const char* cdataHeader = { "<![CDATA[" };␊
846␊
847␉if ( StringEqual( p, xmlHeader, true, encoding ) )␊
848␉{␊
849␉␉#ifdef DEBUG_PARSER␊
850␉␉␉TIXML_LOG( "XML parsing Declaration\n" );␊
851␉␉#endif␊
852␉␉returnNode = new TiXmlDeclaration();␊
853␉}␊
854␉else if ( StringEqual( p, commentHeader, false, encoding ) )␊
855␉{␊
856␉␉#ifdef DEBUG_PARSER␊
857␉␉␉TIXML_LOG( "XML parsing Comment\n" );␊
858␉␉#endif␊
859␉␉returnNode = new TiXmlComment();␊
860␉}␊
861␉else if ( StringEqual( p, cdataHeader, false, encoding ) )␊
862␉{␊
863␉␉#ifdef DEBUG_PARSER␊
864␉␉␉TIXML_LOG( "XML parsing CDATA\n" );␊
865␉␉#endif␊
866␉␉TiXmlText* text = new TiXmlText( "" );␊
867␉␉text->SetCDATA( true );␊
868␉␉returnNode = text;␊
869␉}␊
870␉else if ( StringEqual( p, dtdHeader, false, encoding ) )␊
871␉{␊
872␉␉#ifdef DEBUG_PARSER␊
873␉␉␉TIXML_LOG( "XML parsing Unknown(1)\n" );␊
874␉␉#endif␊
875␉␉returnNode = new TiXmlUnknown();␊
876␉}␊
877␉else if ( IsAlpha( *(p+1), encoding )␊
878␉␉␉ || *(p+1) == '_' )␊
879␉{␊
880␉␉#ifdef DEBUG_PARSER␊
881␉␉␉TIXML_LOG( "XML parsing Element\n" );␊
882␉␉#endif␊
883␉␉returnNode = new TiXmlElement( "" );␊
884␉}␊
885␉else␊
886␉{␊
887␉␉#ifdef DEBUG_PARSER␊
888␉␉␉TIXML_LOG( "XML parsing Unknown(2)\n" );␊
889␉␉#endif␊
890␉␉returnNode = new TiXmlUnknown();␊
891␉}␊
892␊
893␉if ( returnNode )␊
894␉{␊
895␉␉// Set the parent, so it can report errors␊
896␉␉returnNode->parent = this;␊
897␉}␊
898␉return returnNode;␊
899}␊
900␊
901#ifdef TIXML_USE_STL␊
902␊
903void TiXmlElement::StreamIn (std::istream * in, TIXML_STRING * tag)␊
904{␊
905␉// We're called with some amount of pre-parsing. That is, some of "this"␊
906␉// element is in "tag". Go ahead and stream to the closing ">"␊
907␉while( in->good() )␊
908␉{␊
909␉␉int c = in->get();␊
910␉␉if ( c <= 0 )␊
911␉␉{␊
912␉␉␉TiXmlDocument* document = GetDocument();␊
913␉␉␉if ( document )␊
914␉␉␉␉document->SetError( TIXML_ERROR_EMBEDDED_NULL, 0, 0, TIXML_ENCODING_UNKNOWN );␊
915␉␉␉return;␊
916␉␉}␊
917␉␉(*tag) += (char) c ;␊
918␉␉␊
919␉␉if ( c == '>' )␊
920␉␉␉break;␊
921␉}␊
922␊
923␉if ( tag->length() < 3 ) return;␊
924␊
925␉// Okay...if we are a "/>" tag, then we're done. We've read a complete tag.␊
926␉// If not, identify and stream.␊
927␊
928␉if ( tag->at( tag->length() - 1 ) == '>' ␊
929␉␉ && tag->at( tag->length() - 2 ) == '/' )␊
930␉{␊
931␉␉// All good!␊
932␉␉return;␊
933␉}␊
934␉else if ( tag->at( tag->length() - 1 ) == '>' )␊
935␉{␊
936␉␉// There is more. Could be:␊
937␉␉//␉␉text␊
938␉␉//␉␉cdata text (which looks like another node)␊
939␉␉//␉␉closing tag␊
940␉␉//␉␉another node.␊
941␉␉for ( ;; )␊
942␉␉{␊
943␉␉␉StreamWhiteSpace( in, tag );␊
944␊
945␉␉␉// Do we have text?␊
946␉␉␉if ( in->good() && in->peek() != '<' ) ␊
947␉␉␉{␊
948␉␉␉␉// Yep, text.␊
949␉␉␉␉TiXmlText text( "" );␊
950␉␉␉␉text.StreamIn( in, tag );␊
951␊
952␉␉␉␉// What follows text is a closing tag or another node.␊
953␉␉␉␉// Go around again and figure it out.␊
954␉␉␉␉continue;␊
955␉␉␉}␊
956␊
957␉␉␉// We now have either a closing tag...or another node.␊
958␉␉␉// We should be at a "<", regardless.␊
959␉␉␉if ( !in->good() ) return;␊
960␉␉␉assert( in->peek() == '<' );␊
961␉␉␉int tagIndex = (int) tag->length();␊
962␊
963␉␉␉bool closingTag = false;␊
964␉␉␉bool firstCharFound = false;␊
965␊
966␉␉␉for( ;; )␊
967␉␉␉{␊
968␉␉␉␉if ( !in->good() )␊
969␉␉␉␉␉return;␊
970␊
971␉␉␉␉int c = in->peek();␊
972␉␉␉␉if ( c <= 0 )␊
973␉␉␉␉{␊
974␉␉␉␉␉TiXmlDocument* document = GetDocument();␊
975␉␉␉␉␉if ( document )␊
976␉␉␉␉␉␉document->SetError( TIXML_ERROR_EMBEDDED_NULL, 0, 0, TIXML_ENCODING_UNKNOWN );␊
977␉␉␉␉␉return;␊
978␉␉␉␉}␊
979␉␉␉␉␊
980␉␉␉␉if ( c == '>' )␊
981␉␉␉␉␉break;␊
982␊
983␉␉␉␉*tag += (char) c;␊
984␉␉␉␉in->get();␊
985␊
986␉␉␉␉// Early out if we find the CDATA id.␊
987␉␉␉␉if ( c == '[' && tag->size() >= 9 )␊
988␉␉␉␉{␊
989␉␉␉␉␉size_t len = tag->size();␊
990␉␉␉␉␉const char* start = tag->c_str() + len - 9;␊
991␉␉␉␉␉if ( strcmp( start, "<![CDATA[" ) == 0 ) {␊
992␉␉␉␉␉␉assert( !closingTag );␊
993␉␉␉␉␉␉break;␊
994␉␉␉␉␉}␊
995␉␉␉␉}␊
996␊
997␉␉␉␉if ( !firstCharFound && c != '<' && !IsWhiteSpace( c ) )␊
998␉␉␉␉{␊
999␉␉␉␉␉firstCharFound = true;␊
1000␉␉␉␉␉if ( c == '/' )␊
1001␉␉␉␉␉␉closingTag = true;␊
1002␉␉␉␉}␊
1003␉␉␉}␊
1004␉␉␉// If it was a closing tag, then read in the closing '>' to clean up the input stream.␊
1005␉␉␉// If it was not, the streaming will be done by the tag.␊
1006␉␉␉if ( closingTag )␊
1007␉␉␉{␊
1008␉␉␉␉if ( !in->good() )␊
1009␉␉␉␉␉return;␊
1010␊
1011␉␉␉␉int c = in->get();␊
1012␉␉␉␉if ( c <= 0 )␊
1013␉␉␉␉{␊
1014␉␉␉␉␉TiXmlDocument* document = GetDocument();␊
1015␉␉␉␉␉if ( document )␊
1016␉␉␉␉␉␉document->SetError( TIXML_ERROR_EMBEDDED_NULL, 0, 0, TIXML_ENCODING_UNKNOWN );␊
1017␉␉␉␉␉return;␊
1018␉␉␉␉}␊
1019␉␉␉␉assert( c == '>' );␊
1020␉␉␉␉*tag += (char) c;␊
1021␊
1022␉␉␉␉// We are done, once we've found our closing tag.␊
1023␉␉␉␉return;␊
1024␉␉␉}␊
1025␉␉␉else␊
1026␉␉␉{␊
1027␉␉␉␉// If not a closing tag, id it, and stream.␊
1028␉␉␉␉const char* tagloc = tag->c_str() + tagIndex;␊
1029␉␉␉␉TiXmlNode* node = Identify( tagloc, TIXML_DEFAULT_ENCODING );␊
1030␉␉␉␉if ( !node )␊
1031␉␉␉␉␉return;␊
1032␉␉␉␉node->StreamIn( in, tag );␊
1033␉␉␉␉delete node;␊
1034␉␉␉␉node = 0;␊
1035␊
1036␉␉␉␉// No return: go around from the beginning: text, closing tag, or node.␊
1037␉␉␉}␊
1038␉␉}␊
1039␉}␊
1040}␊
1041#endif␊
1042␊
1043const char* TiXmlElement::Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding )␊
1044{␊
1045␉p = SkipWhiteSpace( p, encoding );␊
1046␉TiXmlDocument* document = GetDocument();␊
1047␊
1048␉if ( !p || !*p )␊
1049␉{␊
1050␉␉if ( document ) document->SetError( TIXML_ERROR_PARSING_ELEMENT, 0, 0, encoding );␊
1051␉␉return 0;␊
1052␉}␊
1053␊
1054␉if ( data )␊
1055␉{␊
1056␉␉data->Stamp( p, encoding );␊
1057␉␉location = data->Cursor();␊
1058␉}␊
1059␊
1060␉if ( *p != '<' )␊
1061␉{␊
1062␉␉if ( document ) document->SetError( TIXML_ERROR_PARSING_ELEMENT, p, data, encoding );␊
1063␉␉return 0;␊
1064␉}␊
1065␊
1066␉p = SkipWhiteSpace( p+1, encoding );␊
1067␊
1068␉// Read the name.␊
1069␉const char* pErr = p;␊
1070␊
1071 p = ReadName( p, &value, encoding );␊
1072␉if ( !p || !*p )␊
1073␉{␊
1074␉␉if ( document )␉document->SetError( TIXML_ERROR_FAILED_TO_READ_ELEMENT_NAME, pErr, data, encoding );␊
1075␉␉return 0;␊
1076␉}␊
1077␊
1078 TIXML_STRING endTag ("</");␊
1079␉endTag += value;␊
1080␊
1081␉// Check for and read attributes. Also look for an empty␊
1082␉// tag or an end tag.␊
1083␉while ( p && *p )␊
1084␉{␊
1085␉␉pErr = p;␊
1086␉␉p = SkipWhiteSpace( p, encoding );␊
1087␉␉if ( !p || !*p )␊
1088␉␉{␊
1089␉␉␉if ( document ) document->SetError( TIXML_ERROR_READING_ATTRIBUTES, pErr, data, encoding );␊
1090␉␉␉return 0;␊
1091␉␉}␊
1092␉␉if ( *p == '/' )␊
1093␉␉{␊
1094␉␉␉++p;␊
1095␉␉␉// Empty tag.␊
1096␉␉␉if ( *p != '>' )␊
1097␉␉␉{␊
1098␉␉␉␉if ( document ) document->SetError( TIXML_ERROR_PARSING_EMPTY, p, data, encoding );␉␉␊
1099␉␉␉␉return 0;␊
1100␉␉␉}␊
1101␉␉␉return (p+1);␊
1102␉␉}␊
1103␉␉else if ( *p == '>' )␊
1104␉␉{␊
1105␉␉␉// Done with attributes (if there were any.)␊
1106␉␉␉// Read the value -- which can include other␊
1107␉␉␉// elements -- read the end tag, and return.␊
1108␉␉␉++p;␊
1109␉␉␉p = ReadValue( p, data, encoding );␉␉// Note this is an Element method, and will set the error if one happens.␊
1110␉␉␉if ( !p || !*p ) {␊
1111␉␉␉␉// We were looking for the end tag, but found nothing.␊
1112␉␉␉␉// Fix for [ 1663758 ] Failure to report error on bad XML␊
1113␉␉␉␉if ( document ) document->SetError( TIXML_ERROR_READING_END_TAG, p, data, encoding );␊
1114␉␉␉␉return 0;␊
1115␉␉␉}␊
1116␊
1117␉␉␉// We should find the end tag now␊
1118␉␉␉// note that:␊
1119␉␉␉// </foo > and␊
1120␉␉␉// </foo> ␊
1121␉␉␉// are both valid end tags.␊
1122␉␉␉if ( StringEqual( p, endTag.c_str(), false, encoding ) )␊
1123␉␉␉{␊
1124␉␉␉␉p += endTag.length();␊
1125␉␉␉␉p = SkipWhiteSpace( p, encoding );␊
1126␉␉␉␉if ( p && *p && *p == '>' ) {␊
1127␉␉␉␉␉++p;␊
1128␉␉␉␉␉return p;␊
1129␉␉␉␉}␊
1130␉␉␉␉if ( document ) document->SetError( TIXML_ERROR_READING_END_TAG, p, data, encoding );␊
1131␉␉␉␉return 0;␊
1132␉␉␉}␊
1133␉␉␉else␊
1134␉␉␉{␊
1135␉␉␉␉if ( document ) document->SetError( TIXML_ERROR_READING_END_TAG, p, data, encoding );␊
1136␉␉␉␉return 0;␊
1137␉␉␉}␊
1138␉␉}␊
1139␉␉else␊
1140␉␉{␊
1141␉␉␉// Try to read an attribute:␊
1142␉␉␉TiXmlAttribute* attrib = new TiXmlAttribute();␊
1143␉␉␉if ( !attrib )␊
1144␉␉␉{␊
1145␉␉␉␉return 0;␊
1146␉␉␉}␊
1147␊
1148␉␉␉attrib->SetDocument( document );␊
1149␉␉␉pErr = p;␊
1150␉␉␉p = attrib->Parse( p, data, encoding );␊
1151␊
1152␉␉␉if ( !p || !*p )␊
1153␉␉␉{␊
1154␉␉␉␉if ( document ) document->SetError( TIXML_ERROR_PARSING_ELEMENT, pErr, data, encoding );␊
1155␉␉␉␉delete attrib;␊
1156␉␉␉␉return 0;␊
1157␉␉␉}␊
1158␊
1159␉␉␉// Handle the strange case of double attributes:␊
1160␉␉␉#ifdef TIXML_USE_STL␊
1161␉␉␉TiXmlAttribute* node = attributeSet.Find( attrib->NameTStr() );␊
1162␉␉␉#else␊
1163␉␉␉TiXmlAttribute* node = attributeSet.Find( attrib->Name() );␊
1164␉␉␉#endif␊
1165␉␉␉if ( node )␊
1166␉␉␉{␊
1167␉␉␉␉if ( document ) document->SetError( TIXML_ERROR_PARSING_ELEMENT, pErr, data, encoding );␊
1168␉␉␉␉delete attrib;␊
1169␉␉␉␉return 0;␊
1170␉␉␉}␊
1171␊
1172␉␉␉attributeSet.Add( attrib );␊
1173␉␉}␊
1174␉}␊
1175␉return p;␊
1176}␊
1177␊
1178␊
1179const char* TiXmlElement::ReadValue( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding )␊
1180{␊
1181␉TiXmlDocument* document = GetDocument();␊
1182␊
1183␉// Read in text and elements in any order.␊
1184␉const char* pWithWhiteSpace = p;␊
1185␉p = SkipWhiteSpace( p, encoding );␊
1186␊
1187␉while ( p && *p )␊
1188␉{␊
1189␉␉if ( *p != '<' )␊
1190␉␉{␊
1191␉␉␉// Take what we have, make a text element.␊
1192␉␉␉TiXmlText* textNode = new TiXmlText( "" );␊
1193␊
1194␉␉␉if ( !textNode )␊
1195␉␉␉{␊
1196␉␉␉ return 0;␊
1197␉␉␉}␊
1198␊
1199␉␉␉if ( TiXmlBase::IsWhiteSpaceCondensed() )␊
1200␉␉␉{␊
1201␉␉␉␉p = textNode->Parse( p, data, encoding );␊
1202␉␉␉}␊
1203␉␉␉else␊
1204␉␉␉{␊
1205␉␉␉␉// Special case: we want to keep the white space␊
1206␉␉␉␉// so that leading spaces aren't removed.␊
1207␉␉␉␉p = textNode->Parse( pWithWhiteSpace, data, encoding );␊
1208␉␉␉}␊
1209␊
1210␉␉␉if ( !textNode->Blank() )␊
1211␉␉␉␉LinkEndChild( textNode );␊
1212␉␉␉else␊
1213␉␉␉␉delete textNode;␊
1214␉␉} ␊
1215␉␉else ␊
1216␉␉{␊
1217␉␉␉// We hit a '<'␊
1218␉␉␉// Have we hit a new element or an end tag? This could also be␊
1219␉␉␉// a TiXmlText in the "CDATA" style.␊
1220␉␉␉if ( StringEqual( p, "</", false, encoding ) )␊
1221␉␉␉{␊
1222␉␉␉␉return p;␊
1223␉␉␉}␊
1224␉␉␉else␊
1225␉␉␉{␊
1226␉␉␉␉TiXmlNode* node = Identify( p, encoding );␊
1227␉␉␉␉if ( node )␊
1228␉␉␉␉{␊
1229␉␉␉␉␉p = node->Parse( p, data, encoding );␊
1230␉␉␉␉␉LinkEndChild( node );␊
1231␉␉␉␉}␉␉␉␉␊
1232␉␉␉␉else␊
1233␉␉␉␉{␊
1234␉␉␉␉␉return 0;␊
1235␉␉␉␉}␊
1236␉␉␉}␊
1237␉␉}␊
1238␉␉pWithWhiteSpace = p;␊
1239␉␉p = SkipWhiteSpace( p, encoding );␊
1240␉}␊
1241␊
1242␉if ( !p )␊
1243␉{␊
1244␉␉if ( document ) document->SetError( TIXML_ERROR_READING_ELEMENT_VALUE, 0, 0, encoding );␊
1245␉}␉␊
1246␉return p;␊
1247}␊
1248␊
1249␊
1250#ifdef TIXML_USE_STL␊
1251void TiXmlUnknown::StreamIn( std::istream * in, TIXML_STRING * tag )␊
1252{␊
1253␉while ( in->good() )␊
1254␉{␊
1255␉␉int c = in->get();␉␊
1256␉␉if ( c <= 0 )␊
1257␉␉{␊
1258␉␉␉TiXmlDocument* document = GetDocument();␊
1259␉␉␉if ( document )␊
1260␉␉␉␉document->SetError( TIXML_ERROR_EMBEDDED_NULL, 0, 0, TIXML_ENCODING_UNKNOWN );␊
1261␉␉␉return;␊
1262␉␉}␊
1263␉␉(*tag) += (char) c;␊
1264␊
1265␉␉if ( c == '>' )␊
1266␉␉{␊
1267␉␉␉// All is well.␊
1268␉␉␉return;␉␉␊
1269␉␉}␊
1270␉}␊
1271}␊
1272#endif␊
1273␊
1274␊
1275const char* TiXmlUnknown::Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding )␊
1276{␊
1277␉TiXmlDocument* document = GetDocument();␊
1278␉p = SkipWhiteSpace( p, encoding );␊
1279␊
1280␉if ( data )␊
1281␉{␊
1282␉␉data->Stamp( p, encoding );␊
1283␉␉location = data->Cursor();␊
1284␉}␊
1285␉if ( !p || !*p || *p != '<' )␊
1286␉{␊
1287␉␉if ( document ) document->SetError( TIXML_ERROR_PARSING_UNKNOWN, p, data, encoding );␊
1288␉␉return 0;␊
1289␉}␊
1290␉++p;␊
1291 value = "";␊
1292␊
1293␉while ( p && *p && *p != '>' )␊
1294␉{␊
1295␉␉value += *p;␊
1296␉␉++p;␊
1297␉}␊
1298␊
1299␉if ( !p )␊
1300␉{␊
1301␉␉if ( document )␉␊
1302␉␉␉document->SetError( TIXML_ERROR_PARSING_UNKNOWN, 0, 0, encoding );␊
1303␉}␊
1304␉if ( p && *p == '>' )␊
1305␉␉return p+1;␊
1306␉return p;␊
1307}␊
1308␊
1309#ifdef TIXML_USE_STL␊
1310void TiXmlComment::StreamIn( std::istream * in, TIXML_STRING * tag )␊
1311{␊
1312␉while ( in->good() )␊
1313␉{␊
1314␉␉int c = in->get();␉␊
1315␉␉if ( c <= 0 )␊
1316␉␉{␊
1317␉␉␉TiXmlDocument* document = GetDocument();␊
1318␉␉␉if ( document )␊
1319␉␉␉␉document->SetError( TIXML_ERROR_EMBEDDED_NULL, 0, 0, TIXML_ENCODING_UNKNOWN );␊
1320␉␉␉return;␊
1321␉␉}␊
1322␊
1323␉␉(*tag) += (char) c;␊
1324␊
1325␉␉if ( c == '>' ␊
1326␉␉␉ && tag->at( tag->length() - 2 ) == '-'␊
1327␉␉␉ && tag->at( tag->length() - 3 ) == '-' )␊
1328␉␉{␊
1329␉␉␉// All is well.␊
1330␉␉␉return;␉␉␊
1331␉␉}␊
1332␉}␊
1333}␊
1334#endif␊
1335␊
1336␊
1337const char* TiXmlComment::Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding )␊
1338{␊
1339␉TiXmlDocument* document = GetDocument();␊
1340␉value = "";␊
1341␊
1342␉p = SkipWhiteSpace( p, encoding );␊
1343␊
1344␉if ( data )␊
1345␉{␊
1346␉␉data->Stamp( p, encoding );␊
1347␉␉location = data->Cursor();␊
1348␉}␊
1349␉const char* startTag = "<!--";␊
1350␉const char* endTag = "-->";␊
1351␊
1352␉if ( !StringEqual( p, startTag, false, encoding ) )␊
1353␉{␊
1354␉␉if ( document )␊
1355␉␉␉document->SetError( TIXML_ERROR_PARSING_COMMENT, p, data, encoding );␊
1356␉␉return 0;␊
1357␉}␊
1358␉p += strlen( startTag );␊
1359␊
1360␉// [ 1475201 ] TinyXML parses entities in comments␊
1361␉// Oops - ReadText doesn't work, because we don't want to parse the entities.␊
1362␉// p = ReadText( p, &value, false, endTag, false, encoding );␊
1363␉//␊
1364␉// from the XML spec:␊
1365␉/*␊
1366␉ [Definition: Comments may appear anywhere in a document outside other markup; in addition, ␊
1367␉ they may appear within the document type declaration at places allowed by the grammar. ␊
1368␉␉␉␉ They are not part of the document's character data; an XML processor MAY, but need not, ␊
1369␉␉␉␉ make it possible for an application to retrieve the text of comments. For compatibility, ␊
1370␉␉␉␉ the string "--" (double-hyphen) MUST NOT occur within comments.] Parameter entity ␊
1371␉␉␉␉ references MUST NOT be recognized within comments.␊
1372␊
1373␉␉␉␉ An example of a comment:␊
1374␊
1375␉␉␉␉ <!-- declarations for <head> & <body> -->␊
1376␉*/␊
1377␊
1378 value = "";␊
1379␉// Keep all the white space.␊
1380␉while (␉p && *p && !StringEqual( p, endTag, false, encoding ) )␊
1381␉{␊
1382␉␉value.append( p, 1 );␊
1383␉␉++p;␊
1384␉}␊
1385␉if ( p && *p ) ␊
1386␉␉p += strlen( endTag );␊
1387␊
1388␉return p;␊
1389}␊
1390␊
1391␊
1392const char* TiXmlAttribute::Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding )␊
1393{␊
1394␉p = SkipWhiteSpace( p, encoding );␊
1395␉if ( !p || !*p ) return 0;␊
1396␊
1397␉if ( data )␊
1398␉{␊
1399␉␉data->Stamp( p, encoding );␊
1400␉␉location = data->Cursor();␊
1401␉}␊
1402␉// Read the name, the '=' and the value.␊
1403␉const char* pErr = p;␊
1404␉p = ReadName( p, &name, encoding );␊
1405␉if ( !p || !*p )␊
1406␉{␊
1407␉␉if ( document ) document->SetError( TIXML_ERROR_READING_ATTRIBUTES, pErr, data, encoding );␊
1408␉␉return 0;␊
1409␉}␊
1410␉p = SkipWhiteSpace( p, encoding );␊
1411␉if ( !p || !*p || *p != '=' )␊
1412␉{␊
1413␉␉if ( document ) document->SetError( TIXML_ERROR_READING_ATTRIBUTES, p, data, encoding );␊
1414␉␉return 0;␊
1415␉}␊
1416␊
1417␉++p;␉// skip '='␊
1418␉p = SkipWhiteSpace( p, encoding );␊
1419␉if ( !p || !*p )␊
1420␉{␊
1421␉␉if ( document ) document->SetError( TIXML_ERROR_READING_ATTRIBUTES, p, data, encoding );␊
1422␉␉return 0;␊
1423␉}␊
1424␉␊
1425␉const char* end;␊
1426␉const char SINGLE_QUOTE = '\'';␊
1427␉const char DOUBLE_QUOTE = '\"';␊
1428␊
1429␉if ( *p == SINGLE_QUOTE )␊
1430␉{␊
1431␉␉++p;␊
1432␉␉end = "\'";␉␉// single quote in string␊
1433␉␉p = ReadText( p, &value, false, end, false, encoding );␊
1434␉}␊
1435␉else if ( *p == DOUBLE_QUOTE )␊
1436␉{␊
1437␉␉++p;␊
1438␉␉end = "\"";␉␉// double quote in string␊
1439␉␉p = ReadText( p, &value, false, end, false, encoding );␊
1440␉}␊
1441␉else␊
1442␉{␊
1443␉␉// All attribute values should be in single or double quotes.␊
1444␉␉// But this is such a common error that the parser will try␊
1445␉␉// its best, even without them.␊
1446␉␉value = "";␊
1447␉␉while ( p && *p␉␉␉␉␉␉␉␉␉␉␉// existence␊
1448␉␉␉␉&& !IsWhiteSpace( *p )␉␉␉␉␉␉␉␉// whitespace␊
1449␉␉␉␉&& *p != '/' && *p != '>' )␉␉␉␉␉␉␉// tag end␊
1450␉␉{␊
1451␉␉␉if ( *p == SINGLE_QUOTE || *p == DOUBLE_QUOTE ) {␊
1452␉␉␉␉// [ 1451649 ] Attribute values with trailing quotes not handled correctly␊
1453␉␉␉␉// We did not have an opening quote but seem to have a ␊
1454␉␉␉␉// closing one. Give up and throw an error.␊
1455␉␉␉␉if ( document ) document->SetError( TIXML_ERROR_READING_ATTRIBUTES, p, data, encoding );␊
1456␉␉␉␉return 0;␊
1457␉␉␉}␊
1458␉␉␉value += *p;␊
1459␉␉␉++p;␊
1460␉␉}␊
1461␉}␊
1462␉return p;␊
1463}␊
1464␊
1465#ifdef TIXML_USE_STL␊
1466void TiXmlText::StreamIn( std::istream * in, TIXML_STRING * tag )␊
1467{␊
1468␉while ( in->good() )␊
1469␉{␊
1470␉␉int c = in->peek();␉␊
1471␉␉if ( !cdata && (c == '<' ) ) ␊
1472␉␉{␊
1473␉␉␉return;␊
1474␉␉}␊
1475␉␉if ( c <= 0 )␊
1476␉␉{␊
1477␉␉␉TiXmlDocument* document = GetDocument();␊
1478␉␉␉if ( document )␊
1479␉␉␉␉document->SetError( TIXML_ERROR_EMBEDDED_NULL, 0, 0, TIXML_ENCODING_UNKNOWN );␊
1480␉␉␉return;␊
1481␉␉}␊
1482␊
1483␉␉(*tag) += (char) c;␊
1484␉␉in->get();␉// "commits" the peek made above␊
1485␊
1486␉␉if ( cdata && c == '>' && tag->size() >= 3 ) {␊
1487␉␉␉size_t len = tag->size();␊
1488␉␉␉if ( (*tag)[len-2] == ']' && (*tag)[len-3] == ']' ) {␊
1489␉␉␉␉// terminator of cdata.␊
1490␉␉␉␉return;␊
1491␉␉␉}␊
1492␉␉} ␊
1493␉}␊
1494}␊
1495#endif␊
1496␊
1497const char* TiXmlText::Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding )␊
1498{␊
1499␉value = "";␊
1500␉TiXmlDocument* document = GetDocument();␊
1501␊
1502␉if ( data )␊
1503␉{␊
1504␉␉data->Stamp( p, encoding );␊
1505␉␉location = data->Cursor();␊
1506␉}␊
1507␊
1508␉const char* const startTag = "<![CDATA[";␊
1509␉const char* const endTag = "]]>";␊
1510␊
1511␉if ( cdata || StringEqual( p, startTag, false, encoding ) )␊
1512␉{␊
1513␉␉cdata = true;␊
1514␊
1515␉␉if ( !StringEqual( p, startTag, false, encoding ) )␊
1516␉␉{␊
1517␉␉␉if ( document )␊
1518␉␉␉␉document->SetError( TIXML_ERROR_PARSING_CDATA, p, data, encoding );␊
1519␉␉␉return 0;␊
1520␉␉}␊
1521␉␉p += strlen( startTag );␊
1522␊
1523␉␉// Keep all the white space, ignore the encoding, etc.␊
1524␉␉while (␉ p && *p␊
1525␉␉␉␉&& !StringEqual( p, endTag, false, encoding )␊
1526␉␉␉ )␊
1527␉␉{␊
1528␉␉␉value += *p;␊
1529␉␉␉++p;␊
1530␉␉}␊
1531␊
1532␉␉TIXML_STRING dummy; ␊
1533␉␉p = ReadText( p, &dummy, false, endTag, false, encoding );␊
1534␉␉return p;␊
1535␉}␊
1536␉else␊
1537␉{␊
1538␉␉bool ignoreWhite = true;␊
1539␊
1540␉␉const char* end = "<";␊
1541␉␉p = ReadText( p, &value, ignoreWhite, end, false, encoding );␊
1542␉␉if ( p && *p )␊
1543␉␉␉return p-1;␉// don't truncate the '<'␊
1544␉␉return 0;␊
1545␉}␊
1546}␊
1547␊
1548#ifdef TIXML_USE_STL␊
1549void TiXmlDeclaration::StreamIn( std::istream * in, TIXML_STRING * tag )␊
1550{␊
1551␉while ( in->good() )␊
1552␉{␊
1553␉␉int c = in->get();␊
1554␉␉if ( c <= 0 )␊
1555␉␉{␊
1556␉␉␉TiXmlDocument* document = GetDocument();␊
1557␉␉␉if ( document )␊
1558␉␉␉␉document->SetError( TIXML_ERROR_EMBEDDED_NULL, 0, 0, TIXML_ENCODING_UNKNOWN );␊
1559␉␉␉return;␊
1560␉␉}␊
1561␉␉(*tag) += (char) c;␊
1562␊
1563␉␉if ( c == '>' )␊
1564␉␉{␊
1565␉␉␉// All is well.␊
1566␉␉␉return;␊
1567␉␉}␊
1568␉}␊
1569}␊
1570#endif␊
1571␊
1572const char* TiXmlDeclaration::Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding _encoding )␊
1573{␊
1574␉p = SkipWhiteSpace( p, _encoding );␊
1575␉// Find the beginning, find the end, and look for␊
1576␉// the stuff in-between.␊
1577␉TiXmlDocument* document = GetDocument();␊
1578␉if ( !p || !*p || !StringEqual( p, "<?xml", true, _encoding ) )␊
1579␉{␊
1580␉␉if ( document ) document->SetError( TIXML_ERROR_PARSING_DECLARATION, 0, 0, _encoding );␊
1581␉␉return 0;␊
1582␉}␊
1583␉if ( data )␊
1584␉{␊
1585␉␉data->Stamp( p, _encoding );␊
1586␉␉location = data->Cursor();␊
1587␉}␊
1588␉p += 5;␊
1589␊
1590␉version = "";␊
1591␉encoding = "";␊
1592␉standalone = "";␊
1593␊
1594␉while ( p && *p )␊
1595␉{␊
1596␉␉if ( *p == '>' )␊
1597␉␉{␊
1598␉␉␉++p;␊
1599␉␉␉return p;␊
1600␉␉}␊
1601␊
1602␉␉p = SkipWhiteSpace( p, _encoding );␊
1603␉␉if ( StringEqual( p, "version", true, _encoding ) )␊
1604␉␉{␊
1605␉␉␉TiXmlAttribute attrib;␊
1606␉␉␉p = attrib.Parse( p, data, _encoding );␉␉␊
1607␉␉␉version = attrib.Value();␊
1608␉␉}␊
1609␉␉else if ( StringEqual( p, "encoding", true, _encoding ) )␊
1610␉␉{␊
1611␉␉␉TiXmlAttribute attrib;␊
1612␉␉␉p = attrib.Parse( p, data, _encoding );␉␉␊
1613␉␉␉encoding = attrib.Value();␊
1614␉␉}␊
1615␉␉else if ( StringEqual( p, "standalone", true, _encoding ) )␊
1616␉␉{␊
1617␉␉␉TiXmlAttribute attrib;␊
1618␉␉␉p = attrib.Parse( p, data, _encoding );␉␉␊
1619␉␉␉standalone = attrib.Value();␊
1620␉␉}␊
1621␉␉else␊
1622␉␉{␊
1623␉␉␉// Read over whatever it is.␊
1624␉␉␉while( p && *p && *p != '>' && !IsWhiteSpace( *p ) )␊
1625␉␉␉␉++p;␊
1626␉␉}␊
1627␉}␊
1628␉return 0;␊
1629}␊
1630␊
1631bool TiXmlText::Blank() const␊
1632{␊
1633␉for ( unsigned i=0; i<value.length(); i++ )␊
1634␉␉if ( !IsWhiteSpace( value[i] ) )␊
1635␉␉␉return false;␊
1636␉return true;␊
1637}␊
1638␊
1639

Archive Download this file

Revision: 1307