开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > xml/soap/webservice > 查看源码
ParserTest_Parser.cpp
资源名称：xerces-c-src1_6_0.tar.gz　[点击查看]
上传用户：huihehuasu
上传日期：2007-01-10
资源大小：6948k
文件大小：33k
源码类别：

xml/soap/webservice

开发平台：

C/C++

ParserTest_Parser.cpp：源码内容
  1. /*
  2.  * The Apache Software License, Version 1.1
  3.  *
  4.  * Copyright (c) 1999-2000 The Apache Software Foundation.  All rights
  5.  * reserved.
  6.  *
  7.  * Redistribution and use in source and binary forms, with or without
  8.  * modification, are permitted provided that the following conditions
  9.  * are met:
  10.  *
  11.  * 1. Redistributions of source code must retain the above copyright
  12.  *    notice, this list of conditions and the following disclaimer.
  13.  *
  14.  * 2. Redistributions in binary form must reproduce the above copyright
  15.  *    notice, this list of conditions and the following disclaimer in
  16.  *    the documentation and/or other materials provided with the
  17.  *    distribution.
  18.  *
  19.  * 3. The end-user documentation included with the redistribution,
  20.  *    if any, must include the following acknowledgment:
  21.  *       "This product includes software developed by the
  22.  *        Apache Software Foundation (http://www.apache.org/)."
  23.  *    Alternately, this acknowledgment may appear in the software itself,
  24.  *    if and wherever such third-party acknowledgments normally appear.
  25.  *
  26.  * 4. The names "Xerces" and "Apache Software Foundation" must
  27.  *    not be used to endorse or promote products derived from this
  28.  *    software without prior written permission. For written
  29.  *    permission, please contact apache@apache.org.
  30.  *
  31.  * 5. Products derived from this software may not be called "Apache",
  32.  *    nor may "Apache" appear in their name, without prior written
  33.  *    permission of the Apache Software Foundation.
  34.  *
  35.  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
  36.  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  37.  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  38.  * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
  39.  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  40.  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  41.  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
  42.  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  43.  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  44.  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  45.  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  46.  * SUCH DAMAGE.
  47.  * ====================================================================
  48.  *
  49.  * This software consists of voluntary contributions made by many
  50.  * individuals on behalf of the Apache Software Foundation, and was
  51.  * originally based on software copyright (c) 1999, International
  52.  * Business Machines, Inc., http://www.ibm.com .  For more information
  53.  * on the Apache Software Foundation, please see
  54.  * <http://www.apache.org/>.
  55.  */
  57. /*
  58.  * $Log: ParserTest_Parser.cpp,v $
  59.  * Revision 1.9  2001/11/28 21:15:08  tng
  60.  * Fix broken ParserTest.
  61.  *
  62.  * Revision 1.8  2000/03/02 19:55:46  roddey
  63.  * This checkin includes many changes done while waiting for the
  64.  * 1.1.0 code to be finished. I can't list them all here, but a list is
  65.  * available elsewhere.
  66.  *
  67.  * Revision 1.7  2000/02/06 07:48:37  rahulj
  68.  * Year 2K copyright swat.
  69.  *
  70.  * Revision 1.6  2000/01/27 20:31:31  roddey
  71.  * More recovery from the move away from the util/xx streams.
  72.  *
  73.  * Revision 1.5  2000/01/26 19:35:57  roddey
  74.  * When the /Debug output format is used, it will spit out source offset
  75.  * data as well now.
  76.  *
  77.  * Revision 1.4  2000/01/25 01:02:12  roddey
  78.  * More small fixes in the output from the recent change to get away from
  79.  * the util/xx streams.
  80.  *
  81.  * Revision 1.3  2000/01/21 23:58:06  roddey
  82.  * Initial move away from util streams was bad. Wide char APIs didn't allow enough
  83.  * control to do canonical output, so changed to use std short char APIs.
  84.  *
  85.  * Revision 1.1  1999/11/09 01:02:22  twl
  86.  * Initial revision
  87.  *
  88.  * Revision 1.3  1999/11/08 20:42:25  rahul
  89.  * Swat for adding in Product name and CVS comment log variable.
  90.  *
  91.  */
  94. // ---------------------------------------------------------------------------
  95. //  Includes
  96. // ---------------------------------------------------------------------------
  97. #include <util/RefVectorOf.hpp>
  98. #include <util/XMLString.hpp>
  99. #include <util/XMLUni.hpp>
  100. #include <internal/XMLReader.hpp>
  101. #include <internal/XMLScanner.hpp>
  102. #include <framework/XMLAttr.hpp>
  103. #include <framework/XMLNotationDecl.hpp>
  104. #include <framework/XMLValidator.hpp>
  105. #include <validators/DTD/DTDAttDef.hpp>
  106. #include <validators/DTD/DTDElementDecl.hpp>
  107. #include <validators/DTD/DTDEntityDecl.hpp>
  108. #include "ParserTest.hpp"
  110. #include <stdlib.h>
  111. #include <ctype.h>
  115. // ---------------------------------------------------------------------------
  116. //  Local functions
  117. // ---------------------------------------------------------------------------
  118. static int attrComp(const void* elemOne, const void* elemTwo)
  119. {
  120.     return XMLString::compareString
  121.     (
  122.         (*(XMLAttr**)elemOne)->getName()
  123.         , (*(XMLAttr**)elemTwo)->getName()
  124.     );
  125. }
  128. // ---------------------------------------------------------------------------
  129. //  TestParser: Constructors and Destructor
  130. // ---------------------------------------------------------------------------
  131. TestParser::TestParser() :
  133.     fDoNamespaces(false)
  134.     , fInExtSubset(false)
  135.     , fInsideRoot(false)
  136.     , fIntDTDOutput(false)
  137.     , fNestingLevel(0)
  138.     , fOutputType(OutputType_None)
  139.     , fShowErrLoc(false)
  140.     , fShowWarnings(false)
  141.     , fSurrogate(0)
  142. {
  143. }
  145. TestParser::~TestParser()
  146. {
  147. }
  150. // ---------------------------------------------------------------------------
  151. //  TestParser: The document handler interfaces
  152. // ---------------------------------------------------------------------------
  153. void TestParser::docCharacters( const   XMLCh* const    chars
  154.                                 , const unsigned int    length
  155.                                 , const bool            cdataSection)
  156. {
  157.     if (fOutputType == OutputType_Debug)
  158.     {
  159.         cout << "Got CHARS:n    Bytes: "
  160.              << length << ", CDATA?: "
  161.              << (cdataSection ? "Yes" : "No")
  162.              << "n"
  163.              << "    SrcOfs: " << fScanner->getSrcOffset()
  164.              << "n" << endl;
  165.     }
  166.      else if ((fOutputType == OutputType_JCCanon)
  167.           ||  (fOutputType == OutputType_SunCanon))
  168.     {
  169.         showChars(chars, length);
  170.     }
  171.      else if (fOutputType == OutputType_XML)
  172.     {
  173.         if (cdataSection)
  174.             cout << "<![CDATA[";
  175.         showChars(chars, length);
  176.         if (cdataSection)
  177.             cout << "]]>";
  178.     }
  179. }
  181. void TestParser::docComment(const XMLCh* const comment)
  182. {
  183.     if (fOutputType == OutputType_Debug)
  184.     {
  185.         cout << "Got document COMMENT:n    "
  186.              << "Text: "" << StrX(comment) << ""n"
  187.              << "    SrcOfs: " << fScanner->getSrcOffset()
  188.              << "n" << endl;
  189.     }
  190.      else if (fOutputType == OutputType_XML)
  191.     {
  192.         cout << "<!--";
  193.         showString(comment);
  194.         cout << "-->";
  195.     }
  196. }
  198. void TestParser::docPI( const   XMLCh* const    target
  199.                         , const XMLCh* const    data)
  200. {
  201.     if (fOutputType == OutputType_Debug)
  202.     {
  203.         cout << "Got document PI:n     "
  204.              << "Target: "" << target << '"';
  206.         if (XMLString::stringLen(data))
  207.             cout << ", Data: "" << StrX(data) << ""n";
  209.         cout << "    SrcOfs: " << fScanner->getSrcOffset()
  210.              << "n" << endl;
  211.     }
  212.      else if ((fOutputType == OutputType_XML)
  213.           ||  (fOutputType == OutputType_JCCanon)
  214.           ||  (fOutputType == OutputType_SunCanon))
  215.     {
  216.         cout << "<?";
  217.         showString(target);
  218.         cout << " ";
  219.         if (XMLString::stringLen(data))
  220.             cout << StrX(data);
  221.         cout << "?>";
  222.     }
  223. }
  226. void TestParser::endDocument()
  227. {
  228.     if (fOutputType == OutputType_Debug)
  229.     {
  230.         cout << "Got ENDDOCUMENT:n"
  231.              << "    SrcOfs: " << fScanner->getSrcOffset()
  232.              << "n" << endl;
  233.     }
  234.      else if (fOutputType == OutputType_SunCanon)
  235.     {
  236.         cout << "rn";
  237.     }
  238. }
  240. void TestParser::endElement(const   XMLElementDecl& elemDecl
  241.                             , const unsigned int    uriId
  242.                             , const bool            isRoot)
  243. {
  244.     if (fOutputType == OutputType_Debug)
  245.     {
  246.         if (fDoNamespaces)
  247.         {
  248.             XMLBuffer bufURI;
  249.             fScanner->getURIText(uriId, bufURI);
  251.             cout << "Got ENDELEMENT:n    Name: "
  252.                  << "{" << StrX(bufURI.getRawBuffer()) << "}"
  253.                  << StrX(elemDecl.getBaseName())
  254.                  << endl;
  255.         }
  256.          else
  257.         {
  258.             cout << "Got ENDELEMENT:n    Name: "
  259.                  << StrX(elemDecl.getFullName()) << endl;
  260.         }
  262.         cout << "    SrcOfs: " << fScanner->getSrcOffset()
  263.              << "n" << endl;
  264.     }
  265.      else if ((fOutputType == OutputType_XML)
  266.           ||  (fOutputType == OutputType_JCCanon)
  267.           ||  (fOutputType == OutputType_SunCanon))
  268.     {
  269.         cout << "</";
  270.         showString(elemDecl.getFullName());
  271.         cout << ">";
  272.     }
  274.     // Clear the flag that says we're now inside the root
  275.     if (isRoot)
  276.         fInsideRoot = false;
  277. }
  279. void TestParser::endEntityReference(const XMLEntityDecl& entDecl)
  280. {
  281.     if (fOutputType == OutputType_Debug)
  282.     {
  283.         cout << "Got ENDENTITYREF:n    "
  284.              << "Name: " << StrX(entDecl.getName()) << "n" << endl;
  285.     }
  286. }
  288. void TestParser::ignorableWhitespace(const  XMLCh* const    chars
  289.                                     , const unsigned int    length
  290.                                     , const bool            cdataSection)
  291. {
  292.     if (fOutputType == OutputType_Debug)
  293.     {
  294.         cout << "Got WHITESPACE:n    Bytes: "
  295.              << length << ", CDATA?: "
  296.              << (cdataSection ? "Yes" : "No")
  297.              << "n"
  298.              << "    SrcOfs: " << fScanner->getSrcOffset()
  299.              << "n" << endl;
  300.     }
  301.      else if (fOutputType == OutputType_XML)
  302.     {
  303.         if (cdataSection)
  304.             cout << "<![CDATA[";
  305.         showChars(chars, length);
  306.         if (cdataSection)
  307.             cout << "]]>";
  308.     }
  309.      else if ((fOutputType == OutputType_JCCanon)
  310.           ||  (fOutputType == OutputType_SunCanon))
  311.     {
  312.         if (!fInsideRoot)
  313.             return;
  314.         showChars(chars, length);
  315.     }
  316. }
  318. void TestParser::resetDocument()
  319. {
  320.     if (fOutputType == OutputType_Debug)
  321.         cout << "Got RESETDOCUMENT:n" << endl;
  322. }
  324. void TestParser::startDocument()
  325. {
  326.     if (fOutputType == OutputType_Debug)
  327.         cout << "Got STARTDOCUMENT:n" << endl;
  328. }
  330. void
  331. TestParser::startElement(const  XMLElementDecl&         elemDecl
  332.                         , const unsigned int            uriId
  333.                         , const XMLCh* const            prefixName
  334.                         , const RefVectorOf<XMLAttr>&   attrList
  335.                         , const unsigned int            attCount
  336.                         , const bool                    isEmpty
  337.                         , const bool                    isRoot)
  338. {
  339.     // Set the flag that says we're now inside the root, if its not empty
  340.     if (isRoot && !isEmpty)
  341.         fInsideRoot = true;
  343.     if (fOutputType == OutputType_Debug)
  344.     {
  345.         XMLBuffer bufURI;
  346.         if (fDoNamespaces)
  347.         {
  348.             fScanner->getURIText(uriId, bufURI);
  349.             cout << "Got STARTELEMENT:n    "
  350.                  << " Name: {" << StrX(bufURI.getRawBuffer()) << "}"
  351.                  << StrX(elemDecl.getBaseName())
  352.                  << ", AttCount: " << attCount
  353.                  << ", Empty?: "
  354.                  << (isEmpty ? "yes" : "no")
  355.                  << "n";
  356.         }
  357.          else
  358.         {
  359.             cout << "Got STARTELEMENT:n    Name: "
  360.                  << StrX(elemDecl.getFullName())
  361.                  << ", AttCount: " << attCount
  362.                  << ", Empty?: "
  363.                  << (isEmpty ? "yes" : "no")
  364.                  << "n";
  365.         }
  367.         cout << "    SrcOfs: " << fScanner->getSrcOffset() << "n";
  369.         // If any attributes, then show them
  370.         if (attCount)
  371.         {
  372.             cout << "    Attrs: ";
  373.             for (unsigned int attInd = 0; attInd < attCount; attInd++)
  374.             {
  375.                 const XMLAttr* curAttr = attrList.elementAt(attInd);
  377.                 if (fDoNamespaces)
  378.                 {
  379.                     fScanner->getURIText(curAttr->getURIId(), bufURI);
  380.                     cout << "Name=" << "{" << StrX(bufURI.getRawBuffer())
  381.                          << "}" << StrX(curAttr->getName());
  382.                 }
  383.                  else
  384.                 {
  385.                     cout << "Name=" << StrX(curAttr->getQName());
  386.                 }
  388.                 if (curAttr->getSpecified())
  389.                     cout << " (Explicit)  ";
  390.                 else
  391.                     cout << " (Defaulted) ";
  393.                 cout << "Value=" << StrX(curAttr->getValue()) << "n"
  394.                      << "           ";
  395.             }
  396.         }
  398.         cout << endl;
  399.     }
  400.      else if (fOutputType == OutputType_XML)
  401.     {
  402.         cout << "<";
  403.         showString(elemDecl.getFullName());
  405.         if (attCount)
  406.         {
  407.             cout << " ";
  409.             for (unsigned int index = 0; index < attCount; index++)
  410.             {
  411.                 const XMLAttr* curAttr = attrList.elementAt(index);
  412.                 showString(curAttr->getQName());
  413.                 cout << "="";
  414.                 showString(curAttr->getValue());
  415.                 cout << """;
  417.                 if (index < attCount-1)
  418.                     cout << " ";
  419.             }
  420.         }
  422.         if (isEmpty)
  423.             cout << "/>";
  424.         else
  425.             cout << ">";
  426.     }
  427.      else if ((fOutputType == OutputType_JCCanon)
  428.           ||  (fOutputType == OutputType_SunCanon))
  429.     {
  430.         cout << "<";
  431.         showString(elemDecl.getFullName());
  433.         if (attCount)
  434.         {
  435.             cout << " ";
  437.             //
  438.             //  Get a list of attribute pointers. The canonical output
  439.             //  format requires sorted attributes. If we aren't doing
  440.             //  canonical output, then we don't sort it, but we still use
  441.             //  the array.
  442.             //
  443.             const XMLAttr** attrTmp = new const XMLAttr*[attCount];
  444.             unsigned int index;
  445.             for (index = 0; index < attCount; index++)
  446.                 attrTmp[index] = attrList.elementAt(index);
  448.             if (attCount > 1)
  449.                 qsort(attrTmp, attCount, sizeof(XMLAttr*), attrComp);
  451.             for (index = 0; index < attCount; index++)
  452.             {
  453.                 const XMLAttr* curAttr = attrTmp[index];
  454.                 showString(curAttr->getQName());
  455.                 cout << "="";
  456.                 showString(curAttr->getValue());
  457.                 cout << """;
  459.                 if (index < attCount-1)
  460.                     cout << " ";
  461.             }
  462.             delete [] attrTmp;
  463.         }
  465.         if (isEmpty)
  466.         {
  467.             cout << "></";
  468.             showString(elemDecl.getFullName());
  469.             cout << ">";
  470.         }
  471.          else
  472.         {
  473.             cout << ">";
  474.         }
  475.     }
  476. }
  478. void TestParser::startEntityReference(const XMLEntityDecl& entDecl)
  479. {
  480.     if (fOutputType == OutputType_Debug)
  481.     {
  482.         cout << "Got STARTENTITY:n    "
  483.              << "Name: " << StrX(entDecl.getName()) << "n" << endl;
  484.     }
  485. }
  487. void TestParser::XMLDecl(const  XMLCh* const    versionStr
  488.                         , const XMLCh* const    encodingStr
  489.                         , const XMLCh* const    standaloneStr
  490.                         , const XMLCh* const    autoEncStr)
  491. {
  492.     if (fOutputType == OutputType_Debug)
  493.     {
  494.         cout << "Got XMLDECL:n    "
  495.              << "Version:"" << StrX(versionStr) << """
  496.              << " Encoding:"" << StrX(encodingStr) << """
  497.              << " Standalone:"" << StrX(standaloneStr) << """
  498.              << " Auto Encoding:"" << StrX(autoEncStr) << """
  499.              << "n"
  500.              << "    SrcOfs: " << fScanner->getSrcOffset()
  501.              << "n" << endl;
  502.     }
  503.      else if (fOutputType == OutputType_XML)
  504.     {
  505.         cout << "<?xml";
  507.         if (XMLString::stringLen(versionStr))
  508.             cout << " version="" << StrX(versionStr) << '"';
  510.         if (XMLString::stringLen(encodingStr))
  511.             cout << " encoding="" << StrX(encodingStr) << '"';
  513.         if (XMLString::stringLen(standaloneStr))
  514.             cout  << " standlone="" << StrX(standaloneStr) << '"';
  516.         cout << " ?>";
  517.     }
  518. }
  521. // -----------------------------------------------------------------------
  522. //  TestParser: The DocTypeHandler interface
  523. // -----------------------------------------------------------------------
  524. void TestParser::attDef(const   DTDElementDecl& elemDecl
  525.                         , const DTDAttDef&      attDef
  526.                         , const bool            ignoring)
  527. {
  528.     if (fOutputType == OutputType_Debug)
  529.     {
  530.         cout << "Got ATTDEF:n    "
  531.              << "Name: " << StrX(attDef.getFullName())
  532.              << ", Type: "
  533.              << StrX(XMLAttDef::getAttTypeString(attDef.getType()))
  534.              << ", DefType: "
  535.              << StrX(XMLAttDef::getDefAttTypeString(attDef.getDefaultType()));
  537.         if (XMLString::stringLen(attDef.getValue()))
  538.             cout << ", Value: "" << StrX(attDef.getValue()) << '"';
  540.         cout << "n    SrcOfs: " << fScanner->getSrcOffset()
  541.              << "n" << endl;
  542.     }
  543.      else if (fOutputType != OutputType_None)
  544.     {
  545.         if (fInExtSubset)
  546.             return;
  548.         if (fIntDTDOutput)
  549.         {
  550.             cout << StrX(attDef.getFullName()) << " ";
  551.             if (attDef.getType() == XMLAttDef::Enumeration)
  552.             {
  553.                 cout << '(';
  554.                 StrX tmpStr(attDef.getEnumeration());
  555.                 const char* curCh = tmpStr.localForm();
  556.                 while (*curCh)
  557.                 {
  558.                     while (!isspace(*curCh) && *curCh)
  559.                         cout << *curCh++;
  561.                     if (*curCh)
  562.                     {
  563.                         cout << '|';
  564.                         curCh++;
  565.                     }
  566.                 }
  567.                 cout << ')';
  568.             }
  569.              else
  570.             {
  571.                 cout << StrX(XMLAttDef::getAttTypeString(attDef.getType()));
  572.             }
  574.             if (XMLString::stringLen(attDef.getValue()))
  575.                 cout << " "" << StrX(attDef.getValue()) << '"';
  577.             if (attDef.getDefaultType() != XMLAttDef::Default)
  578.             {
  579.                 cout << " "
  580.                      << StrX(XMLAttDef::getDefAttTypeString(attDef.getDefaultType()));
  581.             }
  582.         }
  583.     }
  584. }
  586. void TestParser::doctypeComment(const XMLCh* const comment)
  587. {
  588.     if (fOutputType == OutputType_Debug)
  589.     {
  590.         cout << "Got DTD COMMENT:n    "
  591.              << "Text: "" << StrX(comment) << ""n"
  592.              << "    SrcOfs: " << fScanner->getSrcOffset()
  593.              << "n" << endl;
  594.     }
  595.      else if (fOutputType != OutputType_None)
  596.     {
  597.         if (fInExtSubset)
  598.             return;
  600.         if (fIntDTDOutput)
  601.             cout << "<!--" << StrX(comment) << "-->";
  602.     }
  603. }
  605. void TestParser::doctypeDecl(const  DTDElementDecl& elemDecl
  606.                             , const XMLCh* const    publicId
  607.                             , const XMLCh* const    systemId
  608.                             , const bool            hasIntSubset)
  609. {
  610.     if (fOutputType == OutputType_Debug)
  611.     {
  612.         cout << "Got DOCTYPE:n    "
  613.                 << "Root: " << StrX(elemDecl.getFullName());
  615.         if (XMLString::stringLen(publicId))
  616.             cout << ", PUBLIC: " << StrX(publicId);
  618.         if (XMLString::stringLen(systemId))
  619.             cout << ", SYSTEM: " << StrX(systemId);
  621.         cout << "n    SrcOfs: " << fScanner->getSrcOffset()
  622.              << "n" << endl;
  623.     }
  624.      else if (fOutputType != OutputType_None)
  625.     {
  626.         if (fIntDTDOutput)
  627.         {
  628.             cout << "<!DOCTYPE " << StrX(elemDecl.getFullName());
  629.             showIds(publicId, systemId);
  631.             if (!hasIntSubset)
  632.                 cout << ">";
  633.         }
  634.     }
  635. }
  637. void TestParser::doctypePI( const   XMLCh* const    target
  638.                             , const XMLCh* const    data)
  639. {
  640.     if (fOutputType == OutputType_Debug)
  641.     {
  642.         cout << "Got DTD PI:n     "
  643.                 << "Target: "" << StrX(target) << '"';
  645.         if (XMLString::stringLen(data))
  646.             cout << ", Data: "" << StrX(data) << '"';
  648.         cout << "    SrcOfs: " << fScanner->getSrcOffset()
  649.              << "n" << endl;
  650.     }
  651.      else if (fOutputType != OutputType_None)
  652.     {
  653.         if (fInExtSubset)
  654.             return;
  656.         if (fIntDTDOutput)
  657.         {
  658.             cout << "<?" << target;
  659.             if (XMLString::stringLen(data))
  660.                 cout << " " << StrX(data);
  661.             cout << "?>";
  662.         }
  663.     }
  664. }
  666. void TestParser::doctypeWhitespace( const   XMLCh* const    chars
  667.                                     , const unsigned int    length)
  668. {
  669.     if (fOutputType == OutputType_Debug)
  670.     {
  671.         cout << "Got DTD Spaces:n    Bytes: "
  672.              << length << "n"
  673.              << "    SrcOfs: " << fScanner->getSrcOffset()
  674.              << "n" << endl;
  675.     }
  676.      else if (fOutputType != OutputType_None)
  677.     {
  678.         if (fInExtSubset)
  679.             return;
  681.         if (fIntDTDOutput)
  682.             showChars(chars, length);
  683.     }
  684. }
  686. void TestParser::elementDecl(const  DTDElementDecl&     decl
  687.                             , const bool                isIgnored)
  688. {
  689.     if (fOutputType == OutputType_Debug)
  690.     {
  691.         cout << "Got ELEMENT DECL:n    "
  692.              << "Name: " << StrX(decl.getFullName());
  694.         if (isIgnored)
  695.             cout << " (Ignored)";
  697.         cout << ", Content: "
  698.              << StrX(decl.getFormattedContentModel())
  699.              << "n    SrcOfs: " << fScanner->getSrcOffset()
  700.              << "n" << endl;
  701.     }
  702.      else if (fOutputType != OutputType_None)
  703.     {
  704.         if (fInExtSubset)
  705.             return;
  707.         if (fIntDTDOutput)
  708.         {
  709.             cout << "<!ELEMENT " << StrX(decl.getFullName()) << " "
  710.                  << StrX(decl.getFormattedContentModel())
  711.                  << ">";
  712.         }
  713.     }
  714. }
  716. void TestParser::endAttList(const DTDElementDecl& elemDecl)
  717. {
  718.     if (fOutputType == OutputType_Debug)
  719.     {
  720.         cout << "Got ENDATTLIST:n    "
  721.              << "Name: " << StrX(elemDecl.getFullName()) << "n"
  722.              << "    SrcOfs: " << fScanner->getSrcOffset()
  723.              << "n" << endl;
  724.     }
  725.      else if (fOutputType != OutputType_None)
  726.     {
  727.         if (fInExtSubset)
  728.             return;
  730.         if (fIntDTDOutput)
  731.             cout << ">";
  732.     }
  733. }
  735. void TestParser::endIntSubset()
  736. {
  737.     if (fOutputType == OutputType_Debug)
  738.     {
  739.         cout << "Got ENDINTSUBSETn"
  740.              << "    SrcOfs: " << fScanner->getSrcOffset()
  741.              << "n" << endl;
  742.     }
  743.      else if (fOutputType != OutputType_None)
  744.     {
  745.         if (fIntDTDOutput)
  746.             cout << "]>";
  747.     }
  748. }
  750. void TestParser::endExtSubset()
  751. {
  752.     fInExtSubset = false;
  753.     if (fOutputType == OutputType_Debug)
  754.         cout << "Got ENDEXTSUBSETn" << endl;
  755. }
  757. void TestParser::entityDecl(const   DTDEntityDecl&  entityDecl
  758.                             , const bool            isPEDecl
  759.                             , const bool            isIgnored)
  760. {
  761.     if (fOutputType == OutputType_Debug)
  762.     {
  763.         cout << "Got ENTITYDECL:n    "
  764.              << "Name: " << StrX(entityDecl.getName())
  765.              << (isPEDecl ? " [Parameter Entity]" : " [General Entity]")
  766.              << "n" << endl;
  767.     }
  768.      else if (fOutputType != OutputType_None)
  769.     {
  770.         if (fInExtSubset)
  771.             return;
  773.         if (fIntDTDOutput)
  774.         {
  775.             cout << "<!ENTITY ";
  776.             if (isPEDecl)
  777.                 cout << "% ";
  778.             cout << StrX(entityDecl.getName());
  780.             if (entityDecl.isExternal())
  781.                 showIds(entityDecl.getPublicId(), entityDecl.getSystemId());
  782.              else
  783.                 cout << " "" << StrX(entityDecl.getValue()) << """;
  785.             cout << ">";
  786.         }
  787.     }
  788. }
  790. void TestParser::resetDocType()
  791. {
  792.     if (fOutputType == OutputType_Debug)
  793.         cout << "Got RESETDOCTYPE:n" << endl;
  794. }
  796. void TestParser::notationDecl(  const   XMLNotationDecl&    notDecl
  797.                                 , const bool                isIgnored)
  798. {
  799.     if (fOutputType == OutputType_Debug)
  800.     {
  801.         cout << "Got NOTATIONDECL:n    "
  802.              << "Name: " << StrX(notDecl.getName())
  803.              << endl;
  804.     }
  805.      else if (fOutputType != OutputType_None)
  806.     {
  807.         if (fInExtSubset)
  808.             return;
  810.         if (fIntDTDOutput)
  811.         {
  812.             cout << "<!NOTATION " << StrX(notDecl.getName()) << " ";
  814.             if (!XMLString::stringLen(notDecl.getSystemId()))
  815.                 cout << "PUBLIC ";
  816.             else
  817.                 cout << "SYSTEM ";
  819.             if (XMLString::stringLen(notDecl.getPublicId()))
  820.                 cout << """ << StrX(notDecl.getPublicId()) << '"';
  822.             if (XMLString::stringLen(notDecl.getSystemId()))
  823.                 cout << " "" << StrX(notDecl.getSystemId()) << '"';
  825.             cout << ">";
  826.         }
  827.     }
  828. }
  830. void TestParser::startAttList(const DTDElementDecl& elemDecl)
  831. {
  832.     if (fOutputType == OutputType_Debug)
  833.     {
  834.         cout << "Got STARTATTLIST:n    "
  835.                 << "Name: " << StrX(elemDecl.getFullName())
  836.                 << "n" << endl;
  837.     }
  838.      else if (fOutputType != OutputType_None)
  839.     {
  840.         if (fInExtSubset)
  841.             return;
  843.         if (fIntDTDOutput)
  844.             cout << "<!ATTLIST " << StrX(elemDecl.getFullName());
  845.     }
  846. }
  848. void TestParser::startIntSubset()
  849. {
  850.     if (fOutputType == OutputType_Debug)
  851.     {
  852.         cout << "Got STARTINTSUBSETn" << endl;
  853.     }
  854.      else if (fOutputType != OutputType_None)
  855.     {
  856.         if (fIntDTDOutput)
  857.             cout << " [";
  858.     }
  859. }
  861. void TestParser::startExtSubset()
  862. {
  863.     fInExtSubset = true;
  864.     if (fOutputType == OutputType_Debug)
  865.         cout << "Got STARTEXTSUBSETn" << endl;
  866. }
  868. void TestParser::TextDecl(  const   XMLCh* const    versionStr
  869.                             , const XMLCh* const    encodingStr)
  870. {
  871.     if (fOutputType == OutputType_Debug)
  872.     {
  873.         cout << "Got TEXTDECL:n    ";
  875.         if (XMLString::stringLen(versionStr))
  876.             cout << "Version: " << StrX(versionStr);
  878.         if (XMLString::stringLen(encodingStr))
  879.             cout << "Encoding: " << StrX(encodingStr);
  881.         cout << "n" << endl;
  882.     }
  883. }
  886. // ---------------------------------------------------------------------------
  887. //  TestParser: Implementation of the XMLErrorReporter interface
  888. // ---------------------------------------------------------------------------
  889. void TestParser::error( const   unsigned int                errCode
  890.                         , const XMLCh* const                msgDomain
  891.                         , const XMLErrorReporter::ErrTypes  type
  892.                         , const XMLCh* const                text
  893.                         , const XMLCh* const                systemId
  894.                         , const XMLCh* const                publicId
  895.                         , const unsigned int                lineNum
  896.                         , const unsigned int                colNum)
  897. {
  898.     //
  899.     //  If we are in 'show error loc' mode, then we do a special, condensed
  900.     //  display of error location info. Else we fall through and do the
  901.     //  normal one for human consumption.
  902.     //
  903.     if (fShowErrLoc)
  904.     {
  905.         // We only do fatal and validity errors in this case
  906.         if (type == XMLErrorReporter::ErrType_Warning)
  907.             return;
  909.         //
  910.         //  We want to display the entity name, but not the whole path, since
  911.         //  this output is for regression testing and has to be compared
  912.         //  against previous runs potentitally on other machines.
  913.         //
  914.         const XMLCh* entName = systemId;
  915.         int ofs = XMLString::lastIndexOf(systemId, chForwardSlash);
  916.         if (ofs == -1)
  917.             ofs = XMLString::lastIndexOf(systemId, chBackSlash);
  918.         if (ofs != -1)
  919.             entName = &systemId[ofs + 1];
  921.         cout << lineNum << "/" << colNum
  922.                 << ":" << StrX(entName)
  923.                 << " - " << StrX(text)
  924.                 << endl;
  925.         return;
  926.     }
  928.     // If its a warning and we are not showing warnings, then get out
  929.     if ((type == XMLErrorReporter::ErrType_Warning) && !fShowWarnings)
  930.         return;
  932.     const char* typeStr = "?";
  933.     if (type == XMLErrorReporter::ErrType_Fatal)
  934.         typeStr = "ERROR";
  935.     else if (type == XMLErrorReporter::ErrType_Warning)
  936.         typeStr = "WARNING";
  937.     else if (type == XMLErrorReporter::ErrType_Error)
  938.         typeStr = "VALIDITY";
  940.     // Output the error heading and the error type string
  941.     cout << "nError: (" << typeStr;
  943.     // If we have either id, display them
  944.     if (XMLString::stringLen(systemId))
  945.          cout << ", System Id: " << StrX(systemId);
  947.     if (XMLString::stringLen(publicId))
  948.         cout << ", Public Id: " << StrX(publicId);
  950.     // Display the position information
  951.     cout << ", Line/Col: " << lineNum << "/" << colNum
  952.          << ")n";
  954.     // And finally the error text
  955.     cout << StrX(text) << endl;
  956. }
  958. void TestParser::resetErrors()
  959. {
  960.     if (fOutputType == OutputType_Debug)
  961.         cout << "Got RESETERRORS:n" << endl;
  962. }
  965. // ---------------------------------------------------------------------------
  966. //  TestParser: Private helpers
  967. // ---------------------------------------------------------------------------
  968. void TestParser::showChars( const   XMLCh* const    chars
  969.                             , const unsigned int    length)
  970. {
  971.     static const XMLByte FirstByteMark[7] =
  972.     {
  973.         0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC
  974.     };
  976.     const bool doCan = ((fOutputType == OutputType_SunCanon)
  977.                         || (fOutputType == OutputType_JCCanon));
  979.     unsigned int index = 0;
  980.     while (index < length)
  981.     {
  982.         //
  983.         //  Convert the char to UTF-8 format. This will generate multiple
  984.         //  short chars to display. For each one, call the showChar()
  985.         //  method to display it.
  986.         //
  987.         XMLUInt32 tmpVal = chars[index++];
  989.         if ((tmpVal >= 0xD800) && (tmpVal <= 0xDBFF))
  990.         {
  991.             if (index == length)
  992.             {
  993.                 cout << "Missing trailing surrogaten" << endl;
  994.                 break;
  995.             }
  997.             tmpVal = ((tmpVal - 0xD800) << 10)
  998.                      + ((chars[index] - 0xDC00) + 0x10000);
  999.             index++;
  1000.         }
  1002.         // Figure out how many bytes we'll kick out
  1003.         unsigned int outBytes;
  1004.         if (tmpVal < 0x80)
  1005.             outBytes = 1;
  1006.         else if (tmpVal < 0x800)
  1007.             outBytes = 2;
  1008.         else if (tmpVal < 0x10000)
  1009.             outBytes = 3;
  1010.         else if (tmpVal < 0x200000)
  1011.             outBytes = 4;
  1012.         else if (tmpVal < 0x4000000)
  1013.             outBytes = 5;
  1014.         else
  1015.         {
  1016.             outBytes = 6;
  1017.             if (tmpVal & 0x80000000)
  1018.             {
  1019.                 outBytes = 2;
  1020.                 tmpVal = 0xFFFD;
  1021.             }
  1022.         }
  1024.         // Get the chars into a temp buffer in the right order
  1025.         char tmpOutChars[6];
  1026.         unsigned int outIndex = outBytes;
  1027.         switch(outBytes)
  1028.         {
  1029.             case 6 : tmpOutChars[--outIndex] = char((tmpVal | 0x80) & 0xBF);
  1030.                      tmpVal >>= 6;
  1031.             case 5 : tmpOutChars[--outIndex] = char((tmpVal | 0x80) & 0xBF);
  1032.                      tmpVal >>= 6;
  1033.             case 4 : tmpOutChars[--outIndex] = char((tmpVal | 0x80) & 0xBF);
  1034.                      tmpVal >>= 6;
  1035.             case 3 : tmpOutChars[--outIndex] = char((tmpVal | 0x80) & 0xBF);
  1036.                      tmpVal >>= 6;
  1037.             case 2 : tmpOutChars[--outIndex] = char((tmpVal | 0x80) & 0xBF);
  1038.                      tmpVal >>= 6;
  1039.             case 1 : tmpOutChars[--outIndex] = char(tmpVal | FirstByteMark[outBytes]);
  1040.         }
  1042.         // And spit them out
  1043.         for (outIndex = 0; outIndex < outBytes; outIndex++)
  1044.             showChar(tmpOutChars[outIndex], doCan);
  1045.     }
  1046. }
  1049. void TestParser::showChar(const char toShow, const bool doCan)
  1050. {
  1051.     if (doCan)
  1052.     {
  1053.         if (toShow == chLF)
  1054.             cout << "&#10;";
  1055.         else if (toShow == chHTab)
  1056.             cout << "&#9;";
  1057.         else if (toShow == chCR)
  1058.             cout << "&#13;";
  1059.         else if (toShow == chSingleQuote)
  1060.             cout << "&apos;";
  1061.         else if (toShow == chAmpersand)
  1062.             cout << "&amp;";
  1063.         else if (toShow == chDoubleQuote)
  1064.             cout << "&quot;";
  1065.         else if (toShow == chOpenAngle)
  1066.             cout << "&lt;";
  1067.         else if (toShow == chCloseAngle)
  1068.             cout << "&gt;";
  1069.         else
  1070.             cout << toShow;
  1071.     }
  1072.      else
  1073.     {
  1074.         cout << toShow;
  1075.     }
  1076. }
  1078. void
  1079. TestParser::showIds(const XMLCh* const publicId, const XMLCh* const systemId)
  1080. {
  1081.     if (XMLString::stringLen(publicId) || XMLString::stringLen(systemId))
  1082.     {
  1083.         if (!XMLString::stringLen(publicId))
  1084.         {
  1085.             cout << " SYSTEM '" << StrX(systemId) << "'";
  1086.         }
  1087.          else
  1088.         {
  1089.             cout << " PUBLIC '" << StrX(publicId) << "'";
  1090.             if (systemId)
  1091.                 cout << " '" << StrX(systemId) << "'";
  1092.         }
  1093.     }
  1094. }
  1097. void TestParser::showString(const XMLCh* const toShow)
  1098. {
  1099.     showChars(toShow, XMLString::stringLen(toShow));
  1100. }