source: icXML/icXML-devel/tests/src/ParserTest/ParserTest_Parser.cpp @ 2726

Last change on this file since 2726 was 2726, checked in by cameron, 7 years ago

Add original Xerces tests and samples directories

File size: 33.2 KB
Line 
1/*
2 * Licensed to the Apache Software Foundation (ASF) under one or more
3 * contributor license agreements.  See the NOTICE file distributed with
4 * this work for additional information regarding copyright ownership.
5 * The ASF licenses this file to You under the Apache License, Version 2.0
6 * (the "License"); you may not use this file except in compliance with
7 * the License.  You may obtain a copy of the License at
8 *
9 *      http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 */
17
18/*
19 * $Id: ParserTest_Parser.cpp 470088 2006-11-01 20:35:12Z amassari $
20 */
21
22
23// ---------------------------------------------------------------------------
24//  Includes
25// ---------------------------------------------------------------------------
26#include <xercesc/util/RefVectorOf.hpp>
27#include <xercesc/util/XMLString.hpp>
28#include <xercesc/util/XMLUni.hpp>
29#include <xercesc/internal/XMLReader.hpp>
30#include <xercesc/internal/XMLScanner.hpp>
31#include <xercesc/framework/XMLAttr.hpp>
32#include <xercesc/framework/XMLNotationDecl.hpp>
33#include <xercesc/framework/XMLValidator.hpp>
34#include <xercesc/validators/DTD/DTDAttDef.hpp>
35#include <xercesc/validators/DTD/DTDElementDecl.hpp>
36#include <xercesc/validators/DTD/DTDEntityDecl.hpp>
37#include "ParserTest.hpp"
38
39#include <stdlib.h>
40#include <ctype.h>
41
42
43
44// ---------------------------------------------------------------------------
45//  Local functions
46// ---------------------------------------------------------------------------
47static int attrComp(const void* elemOne, const void* elemTwo)
48{
49    return XMLString::compareString
50    (
51        (*(XMLAttr**)elemOne)->getName()
52        , (*(XMLAttr**)elemTwo)->getName()
53    );
54}
55
56
57// ---------------------------------------------------------------------------
58//  TestParser: Constructors and Destructor
59// ---------------------------------------------------------------------------
60TestParser::TestParser() :
61
62    fDoNamespaces(false)
63    , fInExtSubset(false)
64    , fInsideRoot(false)
65    , fIntDTDOutput(false)
66    , fNestingLevel(0)
67    , fOutputType(OutputType_None)
68    , fShowErrLoc(false)
69    , fShowWarnings(false)
70    , fSurrogate(0)
71{
72}
73
74TestParser::~TestParser()
75{
76}
77
78
79// ---------------------------------------------------------------------------
80//  TestParser: The document handler interfaces
81// ---------------------------------------------------------------------------
82void TestParser::docCharacters( const   XMLCh* const    chars
83                                , const unsigned int    length
84                                , const bool            cdataSection)
85{
86    if (fOutputType == OutputType_Debug)
87    {
88        XERCES_STD_QUALIFIER cout << "Got CHARS:\n    Bytes: "
89             << length << ", CDATA?: "
90             << (cdataSection ? "Yes" : "No")
91             << "\n"
92             << "    SrcOfs: " << fScanner->getSrcOffset()
93             << "\n" << XERCES_STD_QUALIFIER endl;
94    }
95     else if ((fOutputType == OutputType_JCCanon)
96          ||  (fOutputType == OutputType_SunCanon))
97    {
98        showChars(chars, length);
99    }
100     else if (fOutputType == OutputType_XML)
101    {
102        if (cdataSection)
103            XERCES_STD_QUALIFIER cout << "<![CDATA[";
104        showChars(chars, length);
105        if (cdataSection)
106            XERCES_STD_QUALIFIER cout << "]]>";
107    }
108}
109
110void TestParser::docComment(const XMLCh* const comment)
111{
112    if (fOutputType == OutputType_Debug)
113    {
114        XERCES_STD_QUALIFIER cout << "Got document COMMENT:\n    "
115             << "Text: \"" << StrX(comment) << "\"\n"
116             << "    SrcOfs: " << fScanner->getSrcOffset()
117             << "\n" << XERCES_STD_QUALIFIER endl;
118    }
119     else if (fOutputType == OutputType_XML)
120    {
121        XERCES_STD_QUALIFIER cout << "<!--";
122        showString(comment);
123        XERCES_STD_QUALIFIER cout << "-->";
124    }
125}
126
127void TestParser::docPI( const   XMLCh* const    target
128                        , const XMLCh* const    data)
129{
130    if (fOutputType == OutputType_Debug)
131    {
132        XERCES_STD_QUALIFIER cout << "Got document PI:\n     "
133             << "Target: \"" << target << '"';
134
135        if (XMLString::stringLen(data))
136            XERCES_STD_QUALIFIER cout << ", Data: \"" << StrX(data) << "\"\n";
137
138        XERCES_STD_QUALIFIER cout << "    SrcOfs: " << fScanner->getSrcOffset()
139             << "\n" << XERCES_STD_QUALIFIER endl;
140    }
141     else if ((fOutputType == OutputType_XML)
142          ||  (fOutputType == OutputType_JCCanon)
143          ||  (fOutputType == OutputType_SunCanon))
144    {
145        XERCES_STD_QUALIFIER cout << "<?";
146        showString(target);
147        XERCES_STD_QUALIFIER cout << " ";
148        if (XMLString::stringLen(data))
149            XERCES_STD_QUALIFIER cout << StrX(data);
150        XERCES_STD_QUALIFIER cout << "?>";
151    }
152}
153
154
155void TestParser::endDocument()
156{
157    if (fOutputType == OutputType_Debug)
158    {
159        XERCES_STD_QUALIFIER cout << "Got ENDDOCUMENT:\n"
160             << "    SrcOfs: " << fScanner->getSrcOffset()
161             << "\n" << XERCES_STD_QUALIFIER endl;
162    }
163     else if (fOutputType == OutputType_SunCanon)
164    {
165        XERCES_STD_QUALIFIER cout << "\r\n";
166    }
167}
168
169void TestParser::endElement(const   XMLElementDecl& elemDecl
170                            , const unsigned int    uriId
171                            , const bool            isRoot)
172{
173    if (fOutputType == OutputType_Debug)
174    {
175        if (fDoNamespaces)
176        {
177            XMLBuffer bufURI;
178            fScanner->getURIText(uriId, bufURI);
179
180            XERCES_STD_QUALIFIER cout << "Got ENDELEMENT:\n    Name: "
181                 << "{" << StrX(bufURI.getRawBuffer()) << "}"
182                 << StrX(elemDecl.getBaseName())
183                 << XERCES_STD_QUALIFIER endl;
184        }
185         else
186        {
187            XERCES_STD_QUALIFIER cout << "Got ENDELEMENT:\n    Name: "
188                 << StrX(elemDecl.getFullName()) << XERCES_STD_QUALIFIER endl;
189        }
190
191        XERCES_STD_QUALIFIER cout << "    SrcOfs: " << fScanner->getSrcOffset()
192             << "\n" << XERCES_STD_QUALIFIER endl;
193    }
194     else if ((fOutputType == OutputType_XML)
195          ||  (fOutputType == OutputType_JCCanon)
196          ||  (fOutputType == OutputType_SunCanon))
197    {
198        XERCES_STD_QUALIFIER cout << "</";
199        showString(elemDecl.getFullName());
200        XERCES_STD_QUALIFIER cout << ">";
201    }
202
203    // Clear the flag that says we're now inside the root
204    if (isRoot)
205        fInsideRoot = false;
206}
207
208void TestParser::endEntityReference(const XMLEntityDecl& entDecl)
209{
210    if (fOutputType == OutputType_Debug)
211    {
212        XERCES_STD_QUALIFIER cout << "Got ENDENTITYREF:\n    "
213             << "Name: " << StrX(entDecl.getName()) << "\n" << XERCES_STD_QUALIFIER endl;
214    }
215}
216
217void TestParser::ignorableWhitespace(const  XMLCh* const    chars
218                                    , const unsigned int    length
219                                    , const bool            cdataSection)
220{
221    if (fOutputType == OutputType_Debug)
222    {
223        XERCES_STD_QUALIFIER cout << "Got WHITESPACE:\n    Bytes: "
224             << length << ", CDATA?: "
225             << (cdataSection ? "Yes" : "No")
226             << "\n"
227             << "    SrcOfs: " << fScanner->getSrcOffset()
228             << "\n" << XERCES_STD_QUALIFIER endl;
229    }
230     else if (fOutputType == OutputType_XML)
231    {
232        if (cdataSection)
233            XERCES_STD_QUALIFIER cout << "<![CDATA[";
234        showChars(chars, length);
235        if (cdataSection)
236            XERCES_STD_QUALIFIER cout << "]]>";
237    }
238     else if ((fOutputType == OutputType_JCCanon)
239          ||  (fOutputType == OutputType_SunCanon))
240    {
241        if (!fInsideRoot)
242            return;
243        showChars(chars, length);
244    }
245}
246
247void TestParser::resetDocument()
248{
249    if (fOutputType == OutputType_Debug)
250        XERCES_STD_QUALIFIER cout << "Got RESETDOCUMENT:\n" << XERCES_STD_QUALIFIER endl;
251}
252
253void TestParser::startDocument()
254{
255    if (fOutputType == OutputType_Debug)
256        XERCES_STD_QUALIFIER cout << "Got STARTDOCUMENT:\n" << XERCES_STD_QUALIFIER endl;
257}
258
259void
260TestParser::startElement(const  XMLElementDecl&         elemDecl
261                        , const unsigned int            uriId
262                        , const XMLCh* const            prefixName
263                        , const RefVectorOf<XMLAttr>&   attrList
264                        , const unsigned int            attCount
265                        , const bool                    isEmpty
266                        , const bool                    isRoot)
267{
268    // Set the flag that says we're now inside the root, if its not empty
269    if (isRoot && !isEmpty)
270        fInsideRoot = true;
271
272    if (fOutputType == OutputType_Debug)
273    {
274        XMLBuffer bufURI;
275        if (fDoNamespaces)
276        {
277            fScanner->getURIText(uriId, bufURI);
278            XERCES_STD_QUALIFIER cout << "Got STARTELEMENT:\n    "
279                 << " Name: {" << StrX(bufURI.getRawBuffer()) << "}"
280                 << StrX(elemDecl.getBaseName())
281                 << ", AttCount: " << attCount
282                 << ", Empty?: "
283                 << (isEmpty ? "yes" : "no")
284                 << "\n";
285        }
286         else
287        {
288            XERCES_STD_QUALIFIER cout << "Got STARTELEMENT:\n    Name: "
289                 << StrX(elemDecl.getFullName())
290                 << ", AttCount: " << attCount
291                 << ", Empty?: "
292                 << (isEmpty ? "yes" : "no")
293                 << "\n";
294        }
295
296        XERCES_STD_QUALIFIER cout << "    SrcOfs: " << fScanner->getSrcOffset() << "\n";
297
298        // If any attributes, then show them
299        if (attCount)
300        {
301            XERCES_STD_QUALIFIER cout << "    Attrs: ";
302            for (unsigned int attInd = 0; attInd < attCount; attInd++)
303            {
304                const XMLAttr* curAttr = attrList.elementAt(attInd);
305
306                if (fDoNamespaces)
307                {
308                    fScanner->getURIText(curAttr->getURIId(), bufURI);
309                    XERCES_STD_QUALIFIER cout << "Name=" << "{" << StrX(bufURI.getRawBuffer())
310                         << "}" << StrX(curAttr->getName());
311                }
312                 else
313                {
314                    XERCES_STD_QUALIFIER cout << "Name=" << StrX(curAttr->getQName());
315                }
316
317                if (curAttr->getSpecified())
318                    XERCES_STD_QUALIFIER cout << " (Explicit)  ";
319                else
320                    XERCES_STD_QUALIFIER cout << " (Defaulted) ";
321
322                XERCES_STD_QUALIFIER cout << "Value=" << StrX(curAttr->getValue()) << "\n"
323                     << "           ";
324            }
325        }
326
327        XERCES_STD_QUALIFIER cout << XERCES_STD_QUALIFIER endl;
328    }
329     else if (fOutputType == OutputType_XML)
330    {
331        XERCES_STD_QUALIFIER cout << "<";
332        showString(elemDecl.getFullName());
333
334        if (attCount)
335        {
336            XERCES_STD_QUALIFIER cout << " ";
337
338            for (unsigned int index = 0; index < attCount; index++)
339            {
340                const XMLAttr* curAttr = attrList.elementAt(index);
341                showString(curAttr->getQName());
342                XERCES_STD_QUALIFIER cout << "=\"";
343                showString(curAttr->getValue());
344                XERCES_STD_QUALIFIER cout << "\"";
345
346                if (index < attCount-1)
347                    XERCES_STD_QUALIFIER cout << " ";
348            }
349        }
350
351        if (isEmpty)
352            XERCES_STD_QUALIFIER cout << "/>";
353        else
354            XERCES_STD_QUALIFIER cout << ">";
355    }
356     else if ((fOutputType == OutputType_JCCanon)
357          ||  (fOutputType == OutputType_SunCanon))
358    {
359        XERCES_STD_QUALIFIER cout << "<";
360        showString(elemDecl.getFullName());
361
362        if (attCount)
363        {
364            XERCES_STD_QUALIFIER cout << " ";
365
366            //
367            //  Get a list of attribute pointers. The canonical output
368            //  format requires sorted attributes. If we aren't doing
369            //  canonical output, then we don't sort it, but we still use
370            //  the array.
371            //
372            const XMLAttr** attrTmp = new const XMLAttr*[attCount];
373            unsigned int index;
374            for (index = 0; index < attCount; index++)
375                attrTmp[index] = attrList.elementAt(index);
376
377            if (attCount > 1)
378                qsort(attrTmp, attCount, sizeof(XMLAttr*), attrComp);
379
380            for (index = 0; index < attCount; index++)
381            {
382                const XMLAttr* curAttr = attrTmp[index];
383                showString(curAttr->getQName());
384                XERCES_STD_QUALIFIER cout << "=\"";
385                showString(curAttr->getValue());
386                XERCES_STD_QUALIFIER cout << "\"";
387
388                if (index < attCount-1)
389                    XERCES_STD_QUALIFIER cout << " ";
390            }
391            delete [] attrTmp;
392        }
393
394        if (isEmpty)
395        {
396            XERCES_STD_QUALIFIER cout << "></";
397            showString(elemDecl.getFullName());
398            XERCES_STD_QUALIFIER cout << ">";
399        }
400         else
401        {
402            XERCES_STD_QUALIFIER cout << ">";
403        }
404    }
405}
406
407void TestParser::startEntityReference(const XMLEntityDecl& entDecl)
408{
409    if (fOutputType == OutputType_Debug)
410    {
411        XERCES_STD_QUALIFIER cout << "Got STARTENTITY:\n    "
412             << "Name: " << StrX(entDecl.getName()) << "\n" << XERCES_STD_QUALIFIER endl;
413    }
414}
415
416void TestParser::XMLDecl(const  XMLCh* const    versionStr
417                        , const XMLCh* const    encodingStr
418                        , const XMLCh* const    standaloneStr
419                        , const XMLCh* const    autoEncStr)
420{
421    if (fOutputType == OutputType_Debug)
422    {
423        XERCES_STD_QUALIFIER cout << "Got XMLDECL:\n    "
424             << "Version:\"" << StrX(versionStr) << "\""
425             << " Encoding:\"" << StrX(encodingStr) << "\""
426             << " Standalone:\"" << StrX(standaloneStr) << "\""
427             << " Auto Encoding:\"" << StrX(autoEncStr) << "\""
428             << "\n"
429             << "    SrcOfs: " << fScanner->getSrcOffset()
430             << "\n" << XERCES_STD_QUALIFIER endl;
431    }
432     else if (fOutputType == OutputType_XML)
433    {
434        XERCES_STD_QUALIFIER cout << "<?xml";
435
436        if (XMLString::stringLen(versionStr))
437            XERCES_STD_QUALIFIER cout << " version=\"" << StrX(versionStr) << '"';
438
439        if (XMLString::stringLen(encodingStr))
440            XERCES_STD_QUALIFIER cout << " encoding=\"" << StrX(encodingStr) << '"';
441
442        if (XMLString::stringLen(standaloneStr))
443            XERCES_STD_QUALIFIER cout  << " standlone=\"" << StrX(standaloneStr) << '"';
444
445        XERCES_STD_QUALIFIER cout << " ?>";
446    }
447}
448
449
450// -----------------------------------------------------------------------
451//  TestParser: The DocTypeHandler interface
452// -----------------------------------------------------------------------
453void TestParser::attDef(const   DTDElementDecl& elemDecl
454                        , const DTDAttDef&      attDef
455                        , const bool            ignoring)
456{
457    if (fOutputType == OutputType_Debug)
458    {
459        XERCES_STD_QUALIFIER cout << "Got ATTDEF:\n    "
460             << "Name: " << StrX(attDef.getFullName())
461             << ", Type: "
462             << StrX(XMLAttDef::getAttTypeString(attDef.getType()))
463             << ", DefType: "
464             << StrX(XMLAttDef::getDefAttTypeString(attDef.getDefaultType()));
465
466        if (XMLString::stringLen(attDef.getValue()))
467            XERCES_STD_QUALIFIER cout << ", Value: \"" << StrX(attDef.getValue()) << '"';
468
469        XERCES_STD_QUALIFIER cout << "\n    SrcOfs: " << fScanner->getSrcOffset()
470             << "\n" << XERCES_STD_QUALIFIER endl;
471    }
472     else if (fOutputType != OutputType_None)
473    {
474        if (fInExtSubset)
475            return;
476
477        if (fIntDTDOutput)
478        {
479            XERCES_STD_QUALIFIER cout << StrX(attDef.getFullName()) << " ";
480            if (attDef.getType() == XMLAttDef::Enumeration)
481            {
482                XERCES_STD_QUALIFIER cout << '(';
483                StrX tmpStr(attDef.getEnumeration());
484                const char* curCh = tmpStr.localForm();
485                while (*curCh)
486                {
487                    while (!isspace(*curCh) && *curCh)
488                        XERCES_STD_QUALIFIER cout << *curCh++;
489
490                    if (*curCh)
491                    {
492                        XERCES_STD_QUALIFIER cout << '|';
493                        curCh++;
494                    }
495                }
496                XERCES_STD_QUALIFIER cout << ')';
497            }
498             else
499            {
500                XERCES_STD_QUALIFIER cout << StrX(XMLAttDef::getAttTypeString(attDef.getType()));
501            }
502
503            if (XMLString::stringLen(attDef.getValue()))
504                XERCES_STD_QUALIFIER cout << " \"" << StrX(attDef.getValue()) << '"';
505
506            if (attDef.getDefaultType() != XMLAttDef::Default)
507            {
508                XERCES_STD_QUALIFIER cout << " "
509                     << StrX(XMLAttDef::getDefAttTypeString(attDef.getDefaultType()));
510            }
511        }
512    }
513}
514
515void TestParser::doctypeComment(const XMLCh* const comment)
516{
517    if (fOutputType == OutputType_Debug)
518    {
519        XERCES_STD_QUALIFIER cout << "Got DTD COMMENT:\n    "
520             << "Text: \"" << StrX(comment) << "\"\n"
521             << "    SrcOfs: " << fScanner->getSrcOffset()
522             << "\n" << XERCES_STD_QUALIFIER endl;
523    }
524     else if (fOutputType != OutputType_None)
525    {
526        if (fInExtSubset)
527            return;
528
529        if (fIntDTDOutput)
530            XERCES_STD_QUALIFIER cout << "<!--" << StrX(comment) << "-->";
531    }
532}
533
534void TestParser::doctypeDecl(const  DTDElementDecl& elemDecl
535                            , const XMLCh* const    publicId
536                            , const XMLCh* const    systemId
537                            , const bool            hasIntSubset)
538{
539    if (fOutputType == OutputType_Debug)
540    {
541        XERCES_STD_QUALIFIER cout << "Got DOCTYPE:\n    "
542                << "Root: " << StrX(elemDecl.getFullName());
543
544        if (XMLString::stringLen(publicId))
545            XERCES_STD_QUALIFIER cout << ", PUBLIC: " << StrX(publicId);
546
547        if (XMLString::stringLen(systemId))
548            XERCES_STD_QUALIFIER cout << ", SYSTEM: " << StrX(systemId);
549
550        XERCES_STD_QUALIFIER cout << "\n    SrcOfs: " << fScanner->getSrcOffset()
551             << "\n" << XERCES_STD_QUALIFIER endl;
552    }
553     else if (fOutputType != OutputType_None)
554    {
555        if (fIntDTDOutput)
556        {
557            XERCES_STD_QUALIFIER cout << "<!DOCTYPE " << StrX(elemDecl.getFullName());
558            showIds(publicId, systemId);
559
560            if (!hasIntSubset)
561                XERCES_STD_QUALIFIER cout << ">";
562        }
563    }
564}
565
566void TestParser::doctypePI( const   XMLCh* const    target
567                            , const XMLCh* const    data)
568{
569    if (fOutputType == OutputType_Debug)
570    {
571        XERCES_STD_QUALIFIER cout << "Got DTD PI:\n     "
572                << "Target: \"" << StrX(target) << '"';
573
574        if (XMLString::stringLen(data))
575            XERCES_STD_QUALIFIER cout << ", Data: \"" << StrX(data) << '"';
576
577        XERCES_STD_QUALIFIER cout << "    SrcOfs: " << fScanner->getSrcOffset()
578             << "\n" << XERCES_STD_QUALIFIER endl;
579    }
580     else if (fOutputType != OutputType_None)
581    {
582        if (fInExtSubset)
583            return;
584
585        if (fIntDTDOutput)
586        {
587            XERCES_STD_QUALIFIER cout << "<?" << target;
588            if (XMLString::stringLen(data))
589                XERCES_STD_QUALIFIER cout << " " << StrX(data);
590            XERCES_STD_QUALIFIER cout << "?>";
591        }
592    }
593}
594
595void TestParser::doctypeWhitespace( const   XMLCh* const    chars
596                                    , const unsigned int    length)
597{
598    if (fOutputType == OutputType_Debug)
599    {
600        XERCES_STD_QUALIFIER cout << "Got DTD Spaces:\n    Bytes: "
601             << length << "\n"
602             << "    SrcOfs: " << fScanner->getSrcOffset()
603             << "\n" << XERCES_STD_QUALIFIER endl;
604    }
605     else if (fOutputType != OutputType_None)
606    {
607        if (fInExtSubset)
608            return;
609
610        if (fIntDTDOutput)
611            showChars(chars, length);
612    }
613}
614
615void TestParser::elementDecl(const  DTDElementDecl&     decl
616                            , const bool                isIgnored)
617{
618    if (fOutputType == OutputType_Debug)
619    {
620        XERCES_STD_QUALIFIER cout << "Got ELEMENT DECL:\n    "
621             << "Name: " << StrX(decl.getFullName());
622
623        if (isIgnored)
624            XERCES_STD_QUALIFIER cout << " (Ignored)";
625
626        XERCES_STD_QUALIFIER cout << ", Content: "
627             << StrX(decl.getFormattedContentModel())
628             << "\n    SrcOfs: " << fScanner->getSrcOffset()
629             << "\n" << XERCES_STD_QUALIFIER endl;
630    }
631     else if (fOutputType != OutputType_None)
632    {
633        if (fInExtSubset)
634            return;
635
636        if (fIntDTDOutput)
637        {
638            XERCES_STD_QUALIFIER cout << "<!ELEMENT " << StrX(decl.getFullName()) << " "
639                 << StrX(decl.getFormattedContentModel())
640                 << ">";
641        }
642    }
643}
644
645void TestParser::endAttList(const DTDElementDecl& elemDecl)
646{
647    if (fOutputType == OutputType_Debug)
648    {
649        XERCES_STD_QUALIFIER cout << "Got ENDATTLIST:\n    "
650             << "Name: " << StrX(elemDecl.getFullName()) << "\n"
651             << "    SrcOfs: " << fScanner->getSrcOffset()
652             << "\n" << XERCES_STD_QUALIFIER endl;
653    }
654     else if (fOutputType != OutputType_None)
655    {
656        if (fInExtSubset)
657            return;
658
659        if (fIntDTDOutput)
660            XERCES_STD_QUALIFIER cout << ">";
661    }
662}
663
664void TestParser::endIntSubset()
665{
666    if (fOutputType == OutputType_Debug)
667    {
668        XERCES_STD_QUALIFIER cout << "Got ENDINTSUBSET\n"
669             << "    SrcOfs: " << fScanner->getSrcOffset()
670             << "\n" << XERCES_STD_QUALIFIER endl;
671    }
672     else if (fOutputType != OutputType_None)
673    {
674        if (fIntDTDOutput)
675            XERCES_STD_QUALIFIER cout << "]>";
676    }
677}
678
679void TestParser::endExtSubset()
680{
681    fInExtSubset = false;
682    if (fOutputType == OutputType_Debug)
683        XERCES_STD_QUALIFIER cout << "Got ENDEXTSUBSET\n" << XERCES_STD_QUALIFIER endl;
684}
685
686void TestParser::entityDecl(const   DTDEntityDecl&  entityDecl
687                            , const bool            isPEDecl
688                            , const bool            isIgnored)
689{
690    if (fOutputType == OutputType_Debug)
691    {
692        XERCES_STD_QUALIFIER cout << "Got ENTITYDECL:\n    "
693             << "Name: " << StrX(entityDecl.getName())
694             << (isPEDecl ? " [Parameter Entity]" : " [General Entity]")
695             << "\n" << XERCES_STD_QUALIFIER endl;
696    }
697     else if (fOutputType != OutputType_None)
698    {
699        if (fInExtSubset)
700            return;
701
702        if (fIntDTDOutput)
703        {
704            XERCES_STD_QUALIFIER cout << "<!ENTITY ";
705            if (isPEDecl)
706                XERCES_STD_QUALIFIER cout << "% ";
707            XERCES_STD_QUALIFIER cout << StrX(entityDecl.getName());
708
709            if (entityDecl.isExternal())
710                showIds(entityDecl.getPublicId(), entityDecl.getSystemId());
711             else
712                XERCES_STD_QUALIFIER cout << " \"" << StrX(entityDecl.getValue()) << "\"";
713
714            XERCES_STD_QUALIFIER cout << ">";
715        }
716    }
717}
718
719void TestParser::resetDocType()
720{
721    if (fOutputType == OutputType_Debug)
722        XERCES_STD_QUALIFIER cout << "Got RESETDOCTYPE:\n" << XERCES_STD_QUALIFIER endl;
723}
724
725void TestParser::notationDecl(  const   XMLNotationDecl&    notDecl
726                                , const bool                isIgnored)
727{
728    if (fOutputType == OutputType_Debug)
729    {
730        XERCES_STD_QUALIFIER cout << "Got NOTATIONDECL:\n    "
731             << "Name: " << StrX(notDecl.getName())
732             << XERCES_STD_QUALIFIER endl;
733    }
734     else if (fOutputType != OutputType_None)
735    {
736        if (fInExtSubset)
737            return;
738
739        if (fIntDTDOutput)
740        {
741            XERCES_STD_QUALIFIER cout << "<!NOTATION " << StrX(notDecl.getName()) << " ";
742
743            if (!XMLString::stringLen(notDecl.getSystemId()))
744                XERCES_STD_QUALIFIER cout << "PUBLIC ";
745            else
746                XERCES_STD_QUALIFIER cout << "SYSTEM ";
747
748            if (XMLString::stringLen(notDecl.getPublicId()))
749                XERCES_STD_QUALIFIER cout << "\"" << StrX(notDecl.getPublicId()) << '"';
750
751            if (XMLString::stringLen(notDecl.getSystemId()))
752                XERCES_STD_QUALIFIER cout << " \"" << StrX(notDecl.getSystemId()) << '"';
753
754            XERCES_STD_QUALIFIER cout << ">";
755        }
756    }
757}
758
759void TestParser::startAttList(const DTDElementDecl& elemDecl)
760{
761    if (fOutputType == OutputType_Debug)
762    {
763        XERCES_STD_QUALIFIER cout << "Got STARTATTLIST:\n    "
764                << "Name: " << StrX(elemDecl.getFullName())
765                << "\n" << XERCES_STD_QUALIFIER endl;
766    }
767     else if (fOutputType != OutputType_None)
768    {
769        if (fInExtSubset)
770            return;
771
772        if (fIntDTDOutput)
773            XERCES_STD_QUALIFIER cout << "<!ATTLIST " << StrX(elemDecl.getFullName());
774    }
775}
776
777void TestParser::startIntSubset()
778{
779    if (fOutputType == OutputType_Debug)
780    {
781        XERCES_STD_QUALIFIER cout << "Got STARTINTSUBSET\n" << XERCES_STD_QUALIFIER endl;
782    }
783     else if (fOutputType != OutputType_None)
784    {
785        if (fIntDTDOutput)
786            XERCES_STD_QUALIFIER cout << " [";
787    }
788}
789
790void TestParser::startExtSubset()
791{
792    fInExtSubset = true;
793    if (fOutputType == OutputType_Debug)
794        XERCES_STD_QUALIFIER cout << "Got STARTEXTSUBSET\n" << XERCES_STD_QUALIFIER endl;
795}
796
797void TestParser::TextDecl(  const   XMLCh* const    versionStr
798                            , const XMLCh* const    encodingStr)
799{
800    if (fOutputType == OutputType_Debug)
801    {
802        XERCES_STD_QUALIFIER cout << "Got TEXTDECL:\n    ";
803
804        if (XMLString::stringLen(versionStr))
805            XERCES_STD_QUALIFIER cout << "Version: " << StrX(versionStr);
806
807        if (XMLString::stringLen(encodingStr))
808            XERCES_STD_QUALIFIER cout << "Encoding: " << StrX(encodingStr);
809
810        XERCES_STD_QUALIFIER cout << "\n" << XERCES_STD_QUALIFIER endl;
811    }
812}
813
814
815// ---------------------------------------------------------------------------
816//  TestParser: Implementation of the XMLErrorReporter interface
817// ---------------------------------------------------------------------------
818void TestParser::error( const   unsigned int                errCode
819                        , const XMLCh* const                msgDomain
820                        , const XMLErrorReporter::ErrTypes  type
821                        , const XMLCh* const                text
822                        , const XMLCh* const                systemId
823                        , const XMLCh* const                publicId
824                        , const unsigned int                lineNum
825                        , const unsigned int                colNum)
826{
827    //
828    //  If we are in 'show error loc' mode, then we do a special, condensed
829    //  display of error location info. Else we fall through and do the
830    //  normal one for human consumption.
831    //
832    if (fShowErrLoc)
833    {
834        // We only do fatal and validity errors in this case
835        if (type == XMLErrorReporter::ErrType_Warning)
836            return;
837
838        //
839        //  We want to display the entity name, but not the whole path, since
840        //  this output is for regression testing and has to be compared
841        //  against previous runs potentitally on other machines.
842        //
843        const XMLCh* entName = systemId;
844        int ofs = XMLString::lastIndexOf(systemId, chForwardSlash);
845        if (ofs == -1)
846            ofs = XMLString::lastIndexOf(systemId, chBackSlash);
847        if (ofs != -1)
848            entName = &systemId[ofs + 1];
849
850        XERCES_STD_QUALIFIER cout << lineNum << "/" << colNum
851                << ":" << StrX(entName)
852                << " - " << StrX(text)
853                << XERCES_STD_QUALIFIER endl;
854        return;
855    }
856
857    // If its a warning and we are not showing warnings, then get out
858    if ((type == XMLErrorReporter::ErrType_Warning) && !fShowWarnings)
859        return;
860
861    const char* typeStr = "?";
862    if (type == XMLErrorReporter::ErrType_Fatal)
863        typeStr = "ERROR";
864    else if (type == XMLErrorReporter::ErrType_Warning)
865        typeStr = "WARNING";
866    else if (type == XMLErrorReporter::ErrType_Error)
867        typeStr = "VALIDITY";
868
869    // Output the error heading and the error type string
870    XERCES_STD_QUALIFIER cout << "\nError: (" << typeStr;
871
872    // If we have either id, display them
873    if (XMLString::stringLen(systemId))
874         XERCES_STD_QUALIFIER cout << ", System Id: " << StrX(systemId);
875
876    if (XMLString::stringLen(publicId))
877        XERCES_STD_QUALIFIER cout << ", Public Id: " << StrX(publicId);
878
879    // Display the position information
880    XERCES_STD_QUALIFIER cout << ", Line/Col: " << lineNum << "/" << colNum
881         << ")\n";
882
883    // And finally the error text
884    XERCES_STD_QUALIFIER cout << StrX(text) << XERCES_STD_QUALIFIER endl;
885}
886
887void TestParser::resetErrors()
888{
889    if (fOutputType == OutputType_Debug)
890        XERCES_STD_QUALIFIER cout << "Got RESETERRORS:\n" << XERCES_STD_QUALIFIER endl;
891}
892
893
894// ---------------------------------------------------------------------------
895//  TestParser: Private helpers
896// ---------------------------------------------------------------------------
897void TestParser::showChars( const   XMLCh* const    chars
898                            , const unsigned int    length)
899{
900    static const XMLByte FirstByteMark[7] =
901    {
902        0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC
903    };
904
905    const bool doCan = ((fOutputType == OutputType_SunCanon)
906                        || (fOutputType == OutputType_JCCanon));
907
908    unsigned int index = 0;
909    while (index < length)
910    {
911        //
912        //  Convert the char to UTF-8 format. This will generate multiple
913        //  short chars to display. For each one, call the showChar()
914        //  method to display it.
915        //
916        XMLUInt32 tmpVal = chars[index++];
917
918        if ((tmpVal >= 0xD800) && (tmpVal <= 0xDBFF))
919        {
920            if (index == length)
921            {
922                XERCES_STD_QUALIFIER cout << "Missing trailing surrogate\n" << XERCES_STD_QUALIFIER endl;
923                break;
924            }
925
926            tmpVal = ((tmpVal - 0xD800) << 10)
927                     + ((chars[index] - 0xDC00) + 0x10000);
928            index++;
929        }
930
931        // Figure out how many bytes we'll kick out
932        unsigned int outBytes;
933        if (tmpVal < 0x80)
934            outBytes = 1;
935        else if (tmpVal < 0x800)
936            outBytes = 2;
937        else if (tmpVal < 0x10000)
938            outBytes = 3;
939        else if (tmpVal < 0x200000)
940            outBytes = 4;
941        else if (tmpVal < 0x4000000)
942            outBytes = 5;
943        else
944        {
945            outBytes = 6;
946            if (tmpVal & 0x80000000)
947            {
948                outBytes = 2;
949                tmpVal = 0xFFFD;
950            }
951        }
952
953        // Get the chars into a temp buffer in the right order
954        char tmpOutChars[6];
955        unsigned int outIndex = outBytes;
956        switch(outBytes)
957        {
958            case 6 : tmpOutChars[--outIndex] = char((tmpVal | 0x80) & 0xBF);
959                     tmpVal >>= 6;
960            case 5 : tmpOutChars[--outIndex] = char((tmpVal | 0x80) & 0xBF);
961                     tmpVal >>= 6;
962            case 4 : tmpOutChars[--outIndex] = char((tmpVal | 0x80) & 0xBF);
963                     tmpVal >>= 6;
964            case 3 : tmpOutChars[--outIndex] = char((tmpVal | 0x80) & 0xBF);
965                     tmpVal >>= 6;
966            case 2 : tmpOutChars[--outIndex] = char((tmpVal | 0x80) & 0xBF);
967                     tmpVal >>= 6;
968            case 1 : tmpOutChars[--outIndex] = char(tmpVal | FirstByteMark[outBytes]);
969        }
970
971        // And spit them out
972        for (outIndex = 0; outIndex < outBytes; outIndex++)
973            showChar(tmpOutChars[outIndex], doCan);
974    }
975}
976
977
978void TestParser::showChar(const char toShow, const bool doCan)
979{
980    if (doCan)
981    {
982        if (toShow == chLF)
983            XERCES_STD_QUALIFIER cout << "&#10;";
984        else if (toShow == chHTab)
985            XERCES_STD_QUALIFIER cout << "&#9;";
986        else if (toShow == chCR)
987            XERCES_STD_QUALIFIER cout << "&#13;";
988        else if (toShow == chSingleQuote)
989            XERCES_STD_QUALIFIER cout << "&apos;";
990        else if (toShow == chAmpersand)
991            XERCES_STD_QUALIFIER cout << "&amp;";
992        else if (toShow == chDoubleQuote)
993            XERCES_STD_QUALIFIER cout << "&quot;";
994        else if (toShow == chOpenAngle)
995            XERCES_STD_QUALIFIER cout << "&lt;";
996        else if (toShow == chCloseAngle)
997            XERCES_STD_QUALIFIER cout << "&gt;";
998        else
999            XERCES_STD_QUALIFIER cout << toShow;
1000    }
1001     else
1002    {
1003        XERCES_STD_QUALIFIER cout << toShow;
1004    }
1005}
1006
1007void
1008TestParser::showIds(const XMLCh* const publicId, const XMLCh* const systemId)
1009{
1010    if (XMLString::stringLen(publicId) || XMLString::stringLen(systemId))
1011    {
1012        if (!XMLString::stringLen(publicId))
1013        {
1014            XERCES_STD_QUALIFIER cout << " SYSTEM '" << StrX(systemId) << "'";
1015        }
1016         else
1017        {
1018            XERCES_STD_QUALIFIER cout << " PUBLIC '" << StrX(publicId) << "'";
1019            if (systemId)
1020                XERCES_STD_QUALIFIER cout << " '" << StrX(systemId) << "'";
1021        }
1022    }
1023}
1024
1025
1026void TestParser::showString(const XMLCh* const toShow)
1027{
1028    showChars(toShow, XMLString::stringLen(toShow));
1029}
Note: See TracBrowser for help on using the repository browser.