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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多国语言处理 > 词法分析 > 查看源码
ParserTest_Parser.cpp
资源名称：xerces-c-src_2_3_0.zip　[点击查看]
上传用户：zhuqijet
上传日期：2013-06-25
资源大小：10074k
文件大小：34k
源码类别：

词法分析

开发平台：

Visual 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.10  2002/02/01 22:45:54  peiyongz
  60.  * sane_include
  61.  *
  62.  * Revision 1.9  2001/11/28 21:15:08  tng
  63.  * Fix broken ParserTest.
  64.  *
  65.  * Revision 1.8  2000/03/02 19:55:46  roddey
  66.  * This checkin includes many changes done while waiting for the
  67.  * 1.1.0 code to be finished. I can't list them all here, but a list is
  68.  * available elsewhere.
  69.  *
  70.  * Revision 1.7  2000/02/06 07:48:37  rahulj
  71.  * Year 2K copyright swat.
  72.  *
  73.  * Revision 1.6  2000/01/27 20:31:31  roddey
  74.  * More recovery from the move away from the util/xx streams.
  75.  *
  76.  * Revision 1.5  2000/01/26 19:35:57  roddey
  77.  * When the /Debug output format is used, it will spit out source offset
  78.  * data as well now.
  79.  *
  80.  * Revision 1.4  2000/01/25 01:02:12  roddey
  81.  * More small fixes in the output from the recent change to get away from
  82.  * the util/xx streams.
  83.  *
  84.  * Revision 1.3  2000/01/21 23:58:06  roddey
  85.  * Initial move away from util streams was bad. Wide char APIs didn't allow enough
  86.  * control to do canonical output, so changed to use std short char APIs.
  87.  *
  88.  * Revision 1.1  1999/11/09 01:02:22  twl
  89.  * Initial revision
  90.  *
  91.  * Revision 1.3  1999/11/08 20:42:25  rahul
  92.  * Swat for adding in Product name and CVS comment log variable.
  93.  *
  94.  */
  97. // ---------------------------------------------------------------------------
  98. //  Includes
  99. // ---------------------------------------------------------------------------
  100. #include <xercesc/util/RefVectorOf.hpp>
  101. #include <xercesc/util/XMLString.hpp>
  102. #include <xercesc/util/XMLUni.hpp>
  103. #include <xercesc/internal/XMLReader.hpp>
  104. #include <xercesc/internal/XMLScanner.hpp>
  105. #include <xercesc/framework/XMLAttr.hpp>
  106. #include <xercesc/framework/XMLNotationDecl.hpp>
  107. #include <xercesc/framework/XMLValidator.hpp>
  108. #include <xercesc/validators/DTD/DTDAttDef.hpp>
  109. #include <xercesc/validators/DTD/DTDElementDecl.hpp>
  110. #include <xercesc/validators/DTD/DTDEntityDecl.hpp>
  111. #include "ParserTest.hpp"
  113. #include <stdlib.h>
  114. #include <ctype.h>
  118. // ---------------------------------------------------------------------------
  119. //  Local functions
  120. // ---------------------------------------------------------------------------
  121. static int attrComp(const void* elemOne, const void* elemTwo)
  122. {
  123.     return XMLString::compareString
  124.     (
  125.         (*(XMLAttr**)elemOne)->getName()
  126.         , (*(XMLAttr**)elemTwo)->getName()
  127.     );
  128. }
  131. // ---------------------------------------------------------------------------
  132. //  TestParser: Constructors and Destructor
  133. // ---------------------------------------------------------------------------
  134. TestParser::TestParser() :
  136.     fDoNamespaces(false)
  137.     , fInExtSubset(false)
  138.     , fInsideRoot(false)
  139.     , fIntDTDOutput(false)
  140.     , fNestingLevel(0)
  141.     , fOutputType(OutputType_None)
  142.     , fShowErrLoc(false)
  143.     , fShowWarnings(false)
  144.     , fSurrogate(0)
  145. {
  146. }
  148. TestParser::~TestParser()
  149. {
  150. }
  153. // ---------------------------------------------------------------------------
  154. //  TestParser: The document handler interfaces
  155. // ---------------------------------------------------------------------------
  156. void TestParser::docCharacters( const   XMLCh* const    chars
  157.                                 , const unsigned int    length
  158.                                 , const bool            cdataSection)
  159. {
  160.     if (fOutputType == OutputType_Debug)
  161.     {
  162.         cout << "Got CHARS:n    Bytes: "
  163.              << length << ", CDATA?: "
  164.              << (cdataSection ? "Yes" : "No")
  165.              << "n"
  166.              << "    SrcOfs: " << fScanner->getSrcOffset()
  167.              << "n" << endl;
  168.     }
  169.      else if ((fOutputType == OutputType_JCCanon)
  170.           ||  (fOutputType == OutputType_SunCanon))
  171.     {
  172.         showChars(chars, length);
  173.     }
  174.      else if (fOutputType == OutputType_XML)
  175.     {
  176.         if (cdataSection)
  177.             cout << "<![CDATA[";
  178.         showChars(chars, length);
  179.         if (cdataSection)
  180.             cout << "]]>";
  181.     }
  182. }
  184. void TestParser::docComment(const XMLCh* const comment)
  185. {
  186.     if (fOutputType == OutputType_Debug)
  187.     {
  188.         cout << "Got document COMMENT:n    "
  189.              << "Text: "" << StrX(comment) << ""n"
  190.              << "    SrcOfs: " << fScanner->getSrcOffset()
  191.              << "n" << endl;
  192.     }
  193.      else if (fOutputType == OutputType_XML)
  194.     {
  195.         cout << "<!--";
  196.         showString(comment);
  197.         cout << "-->";
  198.     }
  199. }
  201. void TestParser::docPI( const   XMLCh* const    target
  202.                         , const XMLCh* const    data)
  203. {
  204.     if (fOutputType == OutputType_Debug)
  205.     {
  206.         cout << "Got document PI:n     "
  207.              << "Target: "" << target << '"';
  209.         if (XMLString::stringLen(data))
  210.             cout << ", Data: "" << StrX(data) << ""n";
  212.         cout << "    SrcOfs: " << fScanner->getSrcOffset()
  213.              << "n" << endl;
  214.     }
  215.      else if ((fOutputType == OutputType_XML)
  216.           ||  (fOutputType == OutputType_JCCanon)
  217.           ||  (fOutputType == OutputType_SunCanon))
  218.     {
  219.         cout << "<?";
  220.         showString(target);
  221.         cout << " ";
  222.         if (XMLString::stringLen(data))
  223.             cout << StrX(data);
  224.         cout << "?>";
  225.     }
  226. }
  229. void TestParser::endDocument()
  230. {
  231.     if (fOutputType == OutputType_Debug)
  232.     {
  233.         cout << "Got ENDDOCUMENT:n"
  234.              << "    SrcOfs: " << fScanner->getSrcOffset()
  235.              << "n" << endl;
  236.     }
  237.      else if (fOutputType == OutputType_SunCanon)
  238.     {
  239.         cout << "rn";
  240.     }
  241. }
  243. void TestParser::endElement(const   XMLElementDecl& elemDecl
  244.                             , const unsigned int    uriId
  245.                             , const bool            isRoot)
  246. {
  247.     if (fOutputType == OutputType_Debug)
  248.     {
  249.         if (fDoNamespaces)
  250.         {
  251.             XMLBuffer bufURI;
  252.             fScanner->getURIText(uriId, bufURI);
  254.             cout << "Got ENDELEMENT:n    Name: "
  255.                  << "{" << StrX(bufURI.getRawBuffer()) << "}"
  256.                  << StrX(elemDecl.getBaseName())
  257.                  << endl;
  258.         }
  259.          else
  260.         {
  261.             cout << "Got ENDELEMENT:n    Name: "
  262.                  << StrX(elemDecl.getFullName()) << endl;
  263.         }
  265.         cout << "    SrcOfs: " << fScanner->getSrcOffset()
  266.              << "n" << endl;
  267.     }
  268.      else if ((fOutputType == OutputType_XML)
  269.           ||  (fOutputType == OutputType_JCCanon)
  270.           ||  (fOutputType == OutputType_SunCanon))
  271.     {
  272.         cout << "</";
  273.         showString(elemDecl.getFullName());
  274.         cout << ">";
  275.     }
  277.     // Clear the flag that says we're now inside the root
  278.     if (isRoot)
  279.         fInsideRoot = false;
  280. }
  282. void TestParser::endEntityReference(const XMLEntityDecl& entDecl)
  283. {
  284.     if (fOutputType == OutputType_Debug)
  285.     {
  286.         cout << "Got ENDENTITYREF:n    "
  287.              << "Name: " << StrX(entDecl.getName()) << "n" << endl;
  288.     }
  289. }
  291. void TestParser::ignorableWhitespace(const  XMLCh* const    chars
  292.                                     , const unsigned int    length
  293.                                     , const bool            cdataSection)
  294. {
  295.     if (fOutputType == OutputType_Debug)
  296.     {
  297.         cout << "Got WHITESPACE:n    Bytes: "
  298.              << length << ", CDATA?: "
  299.              << (cdataSection ? "Yes" : "No")
  300.              << "n"
  301.              << "    SrcOfs: " << fScanner->getSrcOffset()
  302.              << "n" << endl;
  303.     }
  304.      else if (fOutputType == OutputType_XML)
  305.     {
  306.         if (cdataSection)
  307.             cout << "<![CDATA[";
  308.         showChars(chars, length);
  309.         if (cdataSection)
  310.             cout << "]]>";
  311.     }
  312.      else if ((fOutputType == OutputType_JCCanon)
  313.           ||  (fOutputType == OutputType_SunCanon))
  314.     {
  315.         if (!fInsideRoot)
  316.             return;
  317.         showChars(chars, length);
  318.     }
  319. }
  321. void TestParser::resetDocument()
  322. {
  323.     if (fOutputType == OutputType_Debug)
  324.         cout << "Got RESETDOCUMENT:n" << endl;
  325. }
  327. void TestParser::startDocument()
  328. {
  329.     if (fOutputType == OutputType_Debug)
  330.         cout << "Got STARTDOCUMENT:n" << endl;
  331. }
  333. void
  334. TestParser::startElement(const  XMLElementDecl&         elemDecl
  335.                         , const unsigned int            uriId
  336.                         , const XMLCh* const            prefixName
  337.                         , const RefVectorOf<XMLAttr>&   attrList
  338.                         , const unsigned int            attCount
  339.                         , const bool                    isEmpty
  340.                         , const bool                    isRoot)
  341. {
  342.     // Set the flag that says we're now inside the root, if its not empty
  343.     if (isRoot && !isEmpty)
  344.         fInsideRoot = true;
  346.     if (fOutputType == OutputType_Debug)
  347.     {
  348.         XMLBuffer bufURI;
  349.         if (fDoNamespaces)
  350.         {
  351.             fScanner->getURIText(uriId, bufURI);
  352.             cout << "Got STARTELEMENT:n    "
  353.                  << " Name: {" << StrX(bufURI.getRawBuffer()) << "}"
  354.                  << StrX(elemDecl.getBaseName())
  355.                  << ", AttCount: " << attCount
  356.                  << ", Empty?: "
  357.                  << (isEmpty ? "yes" : "no")
  358.                  << "n";
  359.         }
  360.          else
  361.         {
  362.             cout << "Got STARTELEMENT:n    Name: "
  363.                  << StrX(elemDecl.getFullName())
  364.                  << ", AttCount: " << attCount
  365.                  << ", Empty?: "
  366.                  << (isEmpty ? "yes" : "no")
  367.                  << "n";
  368.         }
  370.         cout << "    SrcOfs: " << fScanner->getSrcOffset() << "n";
  372.         // If any attributes, then show them
  373.         if (attCount)
  374.         {
  375.             cout << "    Attrs: ";
  376.             for (unsigned int attInd = 0; attInd < attCount; attInd++)
  377.             {
  378.                 const XMLAttr* curAttr = attrList.elementAt(attInd);
  380.                 if (fDoNamespaces)
  381.                 {
  382.                     fScanner->getURIText(curAttr->getURIId(), bufURI);
  383.                     cout << "Name=" << "{" << StrX(bufURI.getRawBuffer())
  384.                          << "}" << StrX(curAttr->getName());
  385.                 }
  386.                  else
  387.                 {
  388.                     cout << "Name=" << StrX(curAttr->getQName());
  389.                 }
  391.                 if (curAttr->getSpecified())
  392.                     cout << " (Explicit)  ";
  393.                 else
  394.                     cout << " (Defaulted) ";
  396.                 cout << "Value=" << StrX(curAttr->getValue()) << "n"
  397.                      << "           ";
  398.             }
  399.         }
  401.         cout << endl;
  402.     }
  403.      else if (fOutputType == OutputType_XML)
  404.     {
  405.         cout << "<";
  406.         showString(elemDecl.getFullName());
  408.         if (attCount)
  409.         {
  410.             cout << " ";
  412.             for (unsigned int index = 0; index < attCount; index++)
  413.             {
  414.                 const XMLAttr* curAttr = attrList.elementAt(index);
  415.                 showString(curAttr->getQName());
  416.                 cout << "="";
  417.                 showString(curAttr->getValue());
  418.                 cout << """;
  420.                 if (index < attCount-1)
  421.                     cout << " ";
  422.             }
  423.         }
  425.         if (isEmpty)
  426.             cout << "/>";
  427.         else
  428.             cout << ">";
  429.     }
  430.      else if ((fOutputType == OutputType_JCCanon)
  431.           ||  (fOutputType == OutputType_SunCanon))
  432.     {
  433.         cout << "<";
  434.         showString(elemDecl.getFullName());
  436.         if (attCount)
  437.         {
  438.             cout << " ";
  440.             //
  441.             //  Get a list of attribute pointers. The canonical output
  442.             //  format requires sorted attributes. If we aren't doing
  443.             //  canonical output, then we don't sort it, but we still use
  444.             //  the array.
  445.             //
  446.             const XMLAttr** attrTmp = new const XMLAttr*[attCount];
  447.             unsigned int index;
  448.             for (index = 0; index < attCount; index++)
  449.                 attrTmp[index] = attrList.elementAt(index);
  451.             if (attCount > 1)
  452.                 qsort(attrTmp, attCount, sizeof(XMLAttr*), attrComp);
  454.             for (index = 0; index < attCount; index++)
  455.             {
  456.                 const XMLAttr* curAttr = attrTmp[index];
  457.                 showString(curAttr->getQName());
  458.                 cout << "="";
  459.                 showString(curAttr->getValue());
  460.                 cout << """;
  462.                 if (index < attCount-1)
  463.                     cout << " ";
  464.             }
  465.             delete [] attrTmp;
  466.         }
  468.         if (isEmpty)
  469.         {
  470.             cout << "></";
  471.             showString(elemDecl.getFullName());
  472.             cout << ">";
  473.         }
  474.          else
  475.         {
  476.             cout << ">";
  477.         }
  478.     }
  479. }
  481. void TestParser::startEntityReference(const XMLEntityDecl& entDecl)
  482. {
  483.     if (fOutputType == OutputType_Debug)
  484.     {
  485.         cout << "Got STARTENTITY:n    "
  486.              << "Name: " << StrX(entDecl.getName()) << "n" << endl;
  487.     }
  488. }
  490. void TestParser::XMLDecl(const  XMLCh* const    versionStr
  491.                         , const XMLCh* const    encodingStr
  492.                         , const XMLCh* const    standaloneStr
  493.                         , const XMLCh* const    autoEncStr)
  494. {
  495.     if (fOutputType == OutputType_Debug)
  496.     {
  497.         cout << "Got XMLDECL:n    "
  498.              << "Version:"" << StrX(versionStr) << """
  499.              << " Encoding:"" << StrX(encodingStr) << """
  500.              << " Standalone:"" << StrX(standaloneStr) << """
  501.              << " Auto Encoding:"" << StrX(autoEncStr) << """
  502.              << "n"
  503.              << "    SrcOfs: " << fScanner->getSrcOffset()
  504.              << "n" << endl;
  505.     }
  506.      else if (fOutputType == OutputType_XML)
  507.     {
  508.         cout << "<?xml";
  510.         if (XMLString::stringLen(versionStr))
  511.             cout << " version="" << StrX(versionStr) << '"';
  513.         if (XMLString::stringLen(encodingStr))
  514.             cout << " encoding="" << StrX(encodingStr) << '"';
  516.         if (XMLString::stringLen(standaloneStr))
  517.             cout  << " standlone="" << StrX(standaloneStr) << '"';
  519.         cout << " ?>";
  520.     }
  521. }
  524. // -----------------------------------------------------------------------
  525. //  TestParser: The DocTypeHandler interface
  526. // -----------------------------------------------------------------------
  527. void TestParser::attDef(const   DTDElementDecl& elemDecl
  528.                         , const DTDAttDef&      attDef
  529.                         , const bool            ignoring)
  530. {
  531.     if (fOutputType == OutputType_Debug)
  532.     {
  533.         cout << "Got ATTDEF:n    "
  534.              << "Name: " << StrX(attDef.getFullName())
  535.              << ", Type: "
  536.              << StrX(XMLAttDef::getAttTypeString(attDef.getType()))
  537.              << ", DefType: "
  538.              << StrX(XMLAttDef::getDefAttTypeString(attDef.getDefaultType()));
  540.         if (XMLString::stringLen(attDef.getValue()))
  541.             cout << ", Value: "" << StrX(attDef.getValue()) << '"';
  543.         cout << "n    SrcOfs: " << fScanner->getSrcOffset()
  544.              << "n" << endl;
  545.     }
  546.      else if (fOutputType != OutputType_None)
  547.     {
  548.         if (fInExtSubset)
  549.             return;
  551.         if (fIntDTDOutput)
  552.         {
  553.             cout << StrX(attDef.getFullName()) << " ";
  554.             if (attDef.getType() == XMLAttDef::Enumeration)
  555.             {
  556.                 cout << '(';
  557.                 StrX tmpStr(attDef.getEnumeration());
  558.                 const char* curCh = tmpStr.localForm();
  559.                 while (*curCh)
  560.                 {
  561.                     while (!isspace(*curCh) && *curCh)
  562.                         cout << *curCh++;
  564.                     if (*curCh)
  565.                     {
  566.                         cout << '|';
  567.                         curCh++;
  568.                     }
  569.                 }
  570.                 cout << ')';
  571.             }
  572.              else
  573.             {
  574.                 cout << StrX(XMLAttDef::getAttTypeString(attDef.getType()));
  575.             }
  577.             if (XMLString::stringLen(attDef.getValue()))
  578.                 cout << " "" << StrX(attDef.getValue()) << '"';
  580.             if (attDef.getDefaultType() != XMLAttDef::Default)
  581.             {
  582.                 cout << " "
  583.                      << StrX(XMLAttDef::getDefAttTypeString(attDef.getDefaultType()));
  584.             }
  585.         }
  586.     }
  587. }
  589. void TestParser::doctypeComment(const XMLCh* const comment)
  590. {
  591.     if (fOutputType == OutputType_Debug)
  592.     {
  593.         cout << "Got DTD COMMENT:n    "
  594.              << "Text: "" << StrX(comment) << ""n"
  595.              << "    SrcOfs: " << fScanner->getSrcOffset()
  596.              << "n" << endl;
  597.     }
  598.      else if (fOutputType != OutputType_None)
  599.     {
  600.         if (fInExtSubset)
  601.             return;
  603.         if (fIntDTDOutput)
  604.             cout << "<!--" << StrX(comment) << "-->";
  605.     }
  606. }
  608. void TestParser::doctypeDecl(const  DTDElementDecl& elemDecl
  609.                             , const XMLCh* const    publicId
  610.                             , const XMLCh* const    systemId
  611.                             , const bool            hasIntSubset)
  612. {
  613.     if (fOutputType == OutputType_Debug)
  614.     {
  615.         cout << "Got DOCTYPE:n    "
  616.                 << "Root: " << StrX(elemDecl.getFullName());
  618.         if (XMLString::stringLen(publicId))
  619.             cout << ", PUBLIC: " << StrX(publicId);
  621.         if (XMLString::stringLen(systemId))
  622.             cout << ", SYSTEM: " << StrX(systemId);
  624.         cout << "n    SrcOfs: " << fScanner->getSrcOffset()
  625.              << "n" << endl;
  626.     }
  627.      else if (fOutputType != OutputType_None)
  628.     {
  629.         if (fIntDTDOutput)
  630.         {
  631.             cout << "<!DOCTYPE " << StrX(elemDecl.getFullName());
  632.             showIds(publicId, systemId);
  634.             if (!hasIntSubset)
  635.                 cout << ">";
  636.         }
  637.     }
  638. }
  640. void TestParser::doctypePI( const   XMLCh* const    target
  641.                             , const XMLCh* const    data)
  642. {
  643.     if (fOutputType == OutputType_Debug)
  644.     {
  645.         cout << "Got DTD PI:n     "
  646.                 << "Target: "" << StrX(target) << '"';
  648.         if (XMLString::stringLen(data))
  649.             cout << ", Data: "" << StrX(data) << '"';
  651.         cout << "    SrcOfs: " << fScanner->getSrcOffset()
  652.              << "n" << endl;
  653.     }
  654.      else if (fOutputType != OutputType_None)
  655.     {
  656.         if (fInExtSubset)
  657.             return;
  659.         if (fIntDTDOutput)
  660.         {
  661.             cout << "<?" << target;
  662.             if (XMLString::stringLen(data))
  663.                 cout << " " << StrX(data);
  664.             cout << "?>";
  665.         }
  666.     }
  667. }
  669. void TestParser::doctypeWhitespace( const   XMLCh* const    chars
  670.                                     , const unsigned int    length)
  671. {
  672.     if (fOutputType == OutputType_Debug)
  673.     {
  674.         cout << "Got DTD Spaces:n    Bytes: "
  675.              << length << "n"
  676.              << "    SrcOfs: " << fScanner->getSrcOffset()
  677.              << "n" << endl;
  678.     }
  679.      else if (fOutputType != OutputType_None)
  680.     {
  681.         if (fInExtSubset)
  682.             return;
  684.         if (fIntDTDOutput)
  685.             showChars(chars, length);
  686.     }
  687. }
  689. void TestParser::elementDecl(const  DTDElementDecl&     decl
  690.                             , const bool                isIgnored)
  691. {
  692.     if (fOutputType == OutputType_Debug)
  693.     {
  694.         cout << "Got ELEMENT DECL:n    "
  695.              << "Name: " << StrX(decl.getFullName());
  697.         if (isIgnored)
  698.             cout << " (Ignored)";
  700.         cout << ", Content: "
  701.              << StrX(decl.getFormattedContentModel())
  702.              << "n    SrcOfs: " << fScanner->getSrcOffset()
  703.              << "n" << endl;
  704.     }
  705.      else if (fOutputType != OutputType_None)
  706.     {
  707.         if (fInExtSubset)
  708.             return;
  710.         if (fIntDTDOutput)
  711.         {
  712.             cout << "<!ELEMENT " << StrX(decl.getFullName()) << " "
  713.                  << StrX(decl.getFormattedContentModel())
  714.                  << ">";
  715.         }
  716.     }
  717. }
  719. void TestParser::endAttList(const DTDElementDecl& elemDecl)
  720. {
  721.     if (fOutputType == OutputType_Debug)
  722.     {
  723.         cout << "Got ENDATTLIST:n    "
  724.              << "Name: " << StrX(elemDecl.getFullName()) << "n"
  725.              << "    SrcOfs: " << fScanner->getSrcOffset()
  726.              << "n" << endl;
  727.     }
  728.      else if (fOutputType != OutputType_None)
  729.     {
  730.         if (fInExtSubset)
  731.             return;
  733.         if (fIntDTDOutput)
  734.             cout << ">";
  735.     }
  736. }
  738. void TestParser::endIntSubset()
  739. {
  740.     if (fOutputType == OutputType_Debug)
  741.     {
  742.         cout << "Got ENDINTSUBSETn"
  743.              << "    SrcOfs: " << fScanner->getSrcOffset()
  744.              << "n" << endl;
  745.     }
  746.      else if (fOutputType != OutputType_None)
  747.     {
  748.         if (fIntDTDOutput)
  749.             cout << "]>";
  750.     }
  751. }
  753. void TestParser::endExtSubset()
  754. {
  755.     fInExtSubset = false;
  756.     if (fOutputType == OutputType_Debug)
  757.         cout << "Got ENDEXTSUBSETn" << endl;
  758. }
  760. void TestParser::entityDecl(const   DTDEntityDecl&  entityDecl
  761.                             , const bool            isPEDecl
  762.                             , const bool            isIgnored)
  763. {
  764.     if (fOutputType == OutputType_Debug)
  765.     {
  766.         cout << "Got ENTITYDECL:n    "
  767.              << "Name: " << StrX(entityDecl.getName())
  768.              << (isPEDecl ? " [Parameter Entity]" : " [General Entity]")
  769.              << "n" << endl;
  770.     }
  771.      else if (fOutputType != OutputType_None)
  772.     {
  773.         if (fInExtSubset)
  774.             return;
  776.         if (fIntDTDOutput)
  777.         {
  778.             cout << "<!ENTITY ";
  779.             if (isPEDecl)
  780.                 cout << "% ";
  781.             cout << StrX(entityDecl.getName());
  783.             if (entityDecl.isExternal())
  784.                 showIds(entityDecl.getPublicId(), entityDecl.getSystemId());
  785.              else
  786.                 cout << " "" << StrX(entityDecl.getValue()) << """;
  788.             cout << ">";
  789.         }
  790.     }
  791. }
  793. void TestParser::resetDocType()
  794. {
  795.     if (fOutputType == OutputType_Debug)
  796.         cout << "Got RESETDOCTYPE:n" << endl;
  797. }
  799. void TestParser::notationDecl(  const   XMLNotationDecl&    notDecl
  800.                                 , const bool                isIgnored)
  801. {
  802.     if (fOutputType == OutputType_Debug)
  803.     {
  804.         cout << "Got NOTATIONDECL:n    "
  805.              << "Name: " << StrX(notDecl.getName())
  806.              << endl;
  807.     }
  808.      else if (fOutputType != OutputType_None)
  809.     {
  810.         if (fInExtSubset)
  811.             return;
  813.         if (fIntDTDOutput)
  814.         {
  815.             cout << "<!NOTATION " << StrX(notDecl.getName()) << " ";
  817.             if (!XMLString::stringLen(notDecl.getSystemId()))
  818.                 cout << "PUBLIC ";
  819.             else
  820.                 cout << "SYSTEM ";
  822.             if (XMLString::stringLen(notDecl.getPublicId()))
  823.                 cout << """ << StrX(notDecl.getPublicId()) << '"';
  825.             if (XMLString::stringLen(notDecl.getSystemId()))
  826.                 cout << " "" << StrX(notDecl.getSystemId()) << '"';
  828.             cout << ">";
  829.         }
  830.     }
  831. }
  833. void TestParser::startAttList(const DTDElementDecl& elemDecl)
  834. {
  835.     if (fOutputType == OutputType_Debug)
  836.     {
  837.         cout << "Got STARTATTLIST:n    "
  838.                 << "Name: " << StrX(elemDecl.getFullName())
  839.                 << "n" << endl;
  840.     }
  841.      else if (fOutputType != OutputType_None)
  842.     {
  843.         if (fInExtSubset)
  844.             return;
  846.         if (fIntDTDOutput)
  847.             cout << "<!ATTLIST " << StrX(elemDecl.getFullName());
  848.     }
  849. }
  851. void TestParser::startIntSubset()
  852. {
  853.     if (fOutputType == OutputType_Debug)
  854.     {
  855.         cout << "Got STARTINTSUBSETn" << endl;
  856.     }
  857.      else if (fOutputType != OutputType_None)
  858.     {
  859.         if (fIntDTDOutput)
  860.             cout << " [";
  861.     }
  862. }
  864. void TestParser::startExtSubset()
  865. {
  866.     fInExtSubset = true;
  867.     if (fOutputType == OutputType_Debug)
  868.         cout << "Got STARTEXTSUBSETn" << endl;
  869. }
  871. void TestParser::TextDecl(  const   XMLCh* const    versionStr
  872.                             , const XMLCh* const    encodingStr)
  873. {
  874.     if (fOutputType == OutputType_Debug)
  875.     {
  876.         cout << "Got TEXTDECL:n    ";
  878.         if (XMLString::stringLen(versionStr))
  879.             cout << "Version: " << StrX(versionStr);
  881.         if (XMLString::stringLen(encodingStr))
  882.             cout << "Encoding: " << StrX(encodingStr);
  884.         cout << "n" << endl;
  885.     }
  886. }
  889. // ---------------------------------------------------------------------------
  890. //  TestParser: Implementation of the XMLErrorReporter interface
  891. // ---------------------------------------------------------------------------
  892. void TestParser::error( const   unsigned int                errCode
  893.                         , const XMLCh* const                msgDomain
  894.                         , const XMLErrorReporter::ErrTypes  type
  895.                         , const XMLCh* const                text
  896.                         , const XMLCh* const                systemId
  897.                         , const XMLCh* const                publicId
  898.                         , const unsigned int                lineNum
  899.                         , const unsigned int                colNum)
  900. {
  901.     //
  902.     //  If we are in 'show error loc' mode, then we do a special, condensed
  903.     //  display of error location info. Else we fall through and do the
  904.     //  normal one for human consumption.
  905.     //
  906.     if (fShowErrLoc)
  907.     {
  908.         // We only do fatal and validity errors in this case
  909.         if (type == XMLErrorReporter::ErrType_Warning)
  910.             return;
  912.         //
  913.         //  We want to display the entity name, but not the whole path, since
  914.         //  this output is for regression testing and has to be compared
  915.         //  against previous runs potentitally on other machines.
  916.         //
  917.         const XMLCh* entName = systemId;
  918.         int ofs = XMLString::lastIndexOf(systemId, chForwardSlash);
  919.         if (ofs == -1)
  920.             ofs = XMLString::lastIndexOf(systemId, chBackSlash);
  921.         if (ofs != -1)
  922.             entName = &systemId[ofs + 1];
  924.         cout << lineNum << "/" << colNum
  925.                 << ":" << StrX(entName)
  926.                 << " - " << StrX(text)
  927.                 << endl;
  928.         return;
  929.     }
  931.     // If its a warning and we are not showing warnings, then get out
  932.     if ((type == XMLErrorReporter::ErrType_Warning) && !fShowWarnings)
  933.         return;
  935.     const char* typeStr = "?";
  936.     if (type == XMLErrorReporter::ErrType_Fatal)
  937.         typeStr = "ERROR";
  938.     else if (type == XMLErrorReporter::ErrType_Warning)
  939.         typeStr = "WARNING";
  940.     else if (type == XMLErrorReporter::ErrType_Error)
  941.         typeStr = "VALIDITY";
  943.     // Output the error heading and the error type string
  944.     cout << "nError: (" << typeStr;
  946.     // If we have either id, display them
  947.     if (XMLString::stringLen(systemId))
  948.          cout << ", System Id: " << StrX(systemId);
  950.     if (XMLString::stringLen(publicId))
  951.         cout << ", Public Id: " << StrX(publicId);
  953.     // Display the position information
  954.     cout << ", Line/Col: " << lineNum << "/" << colNum
  955.          << ")n";
  957.     // And finally the error text
  958.     cout << StrX(text) << endl;
  959. }
  961. void TestParser::resetErrors()
  962. {
  963.     if (fOutputType == OutputType_Debug)
  964.         cout << "Got RESETERRORS:n" << endl;
  965. }
  968. // ---------------------------------------------------------------------------
  969. //  TestParser: Private helpers
  970. // ---------------------------------------------------------------------------
  971. void TestParser::showChars( const   XMLCh* const    chars
  972.                             , const unsigned int    length)
  973. {
  974.     static const XMLByte FirstByteMark[7] =
  975.     {
  976.         0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC
  977.     };
  979.     const bool doCan = ((fOutputType == OutputType_SunCanon)
  980.                         || (fOutputType == OutputType_JCCanon));
  982.     unsigned int index = 0;
  983.     while (index < length)
  984.     {
  985.         //
  986.         //  Convert the char to UTF-8 format. This will generate multiple
  987.         //  short chars to display. For each one, call the showChar()
  988.         //  method to display it.
  989.         //
  990.         XMLUInt32 tmpVal = chars[index++];
  992.         if ((tmpVal >= 0xD800) && (tmpVal <= 0xDBFF))
  993.         {
  994.             if (index == length)
  995.             {
  996.                 cout << "Missing trailing surrogaten" << endl;
  997.                 break;
  998.             }
  1000.             tmpVal = ((tmpVal - 0xD800) << 10)
  1001.                      + ((chars[index] - 0xDC00) + 0x10000);
  1002.             index++;
  1003.         }
  1005.         // Figure out how many bytes we'll kick out
  1006.         unsigned int outBytes;
  1007.         if (tmpVal < 0x80)
  1008.             outBytes = 1;
  1009.         else if (tmpVal < 0x800)
  1010.             outBytes = 2;
  1011.         else if (tmpVal < 0x10000)
  1012.             outBytes = 3;
  1013.         else if (tmpVal < 0x200000)
  1014.             outBytes = 4;
  1015.         else if (tmpVal < 0x4000000)
  1016.             outBytes = 5;
  1017.         else
  1018.         {
  1019.             outBytes = 6;
  1020.             if (tmpVal & 0x80000000)
  1021.             {
  1022.                 outBytes = 2;
  1023.                 tmpVal = 0xFFFD;
  1024.             }
  1025.         }
  1027.         // Get the chars into a temp buffer in the right order
  1028.         char tmpOutChars[6];
  1029.         unsigned int outIndex = outBytes;
  1030.         switch(outBytes)
  1031.         {
  1032.             case 6 : tmpOutChars[--outIndex] = char((tmpVal | 0x80) & 0xBF);
  1033.                      tmpVal >>= 6;
  1034.             case 5 : tmpOutChars[--outIndex] = char((tmpVal | 0x80) & 0xBF);
  1035.                      tmpVal >>= 6;
  1036.             case 4 : tmpOutChars[--outIndex] = char((tmpVal | 0x80) & 0xBF);
  1037.                      tmpVal >>= 6;
  1038.             case 3 : tmpOutChars[--outIndex] = char((tmpVal | 0x80) & 0xBF);
  1039.                      tmpVal >>= 6;
  1040.             case 2 : tmpOutChars[--outIndex] = char((tmpVal | 0x80) & 0xBF);
  1041.                      tmpVal >>= 6;
  1042.             case 1 : tmpOutChars[--outIndex] = char(tmpVal | FirstByteMark[outBytes]);
  1043.         }
  1045.         // And spit them out
  1046.         for (outIndex = 0; outIndex < outBytes; outIndex++)
  1047.             showChar(tmpOutChars[outIndex], doCan);
  1048.     }
  1049. }
  1052. void TestParser::showChar(const char toShow, const bool doCan)
  1053. {
  1054.     if (doCan)
  1055.     {
  1056.         if (toShow == chLF)
  1057.             cout << "&#10;";
  1058.         else if (toShow == chHTab)
  1059.             cout << "&#9;";
  1060.         else if (toShow == chCR)
  1061.             cout << "&#13;";
  1062.         else if (toShow == chSingleQuote)
  1063.             cout << "&apos;";
  1064.         else if (toShow == chAmpersand)
  1065.             cout << "&amp;";
  1066.         else if (toShow == chDoubleQuote)
  1067.             cout << "&quot;";
  1068.         else if (toShow == chOpenAngle)
  1069.             cout << "&lt;";
  1070.         else if (toShow == chCloseAngle)
  1071.             cout << "&gt;";
  1072.         else
  1073.             cout << toShow;
  1074.     }
  1075.      else
  1076.     {
  1077.         cout << toShow;
  1078.     }
  1079. }
  1081. void
  1082. TestParser::showIds(const XMLCh* const publicId, const XMLCh* const systemId)
  1083. {
  1084.     if (XMLString::stringLen(publicId) || XMLString::stringLen(systemId))
  1085.     {
  1086.         if (!XMLString::stringLen(publicId))
  1087.         {
  1088.             cout << " SYSTEM '" << StrX(systemId) << "'";
  1089.         }
  1090.          else
  1091.         {
  1092.             cout << " PUBLIC '" << StrX(publicId) << "'";
  1093.             if (systemId)
  1094.                 cout << " '" << StrX(systemId) << "'";
  1095.         }
  1096.     }
  1097. }
  1100. void TestParser::showString(const XMLCh* const toShow)
  1101. {
  1102.     showChars(toShow, XMLString::stringLen(toShow));
  1103. }