EnumVal.cpp
上传用户:zhuqijet
上传日期:2013-06-25
资源大小:10074k
文件大小:13k
源码类别:

词法分析

开发平台:

Visual C++

  1. /*
  2.  * The Apache Software License, Version 1.1
  3.  *
  4.  * Copyright (c) 1999-2001 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.  */
  56. /*
  57.  * $Log: EnumVal.cpp,v $
  58.  * Revision 1.19  2003/02/05 18:53:23  tng
  59.  * [Bug 11915] Utility for freeing memory.
  60.  *
  61.  * Revision 1.18  2002/11/05 21:46:19  tng
  62.  * Explicit code using namespace in application.
  63.  *
  64.  * Revision 1.17  2002/04/17 20:18:08  tng
  65.  * [Bug 7493] The word "occured" is misspelled and it is a global error.
  66.  *
  67.  * Revision 1.16  2002/02/01 22:35:51  peiyongz
  68.  * sane_include
  69.  *
  70.  * Revision 1.15  2001/11/22 14:47:54  tng
  71.  * Use the phrase "Grammar" instead of "Validator" in EnumVal and SEnumVal Description.
  72.  *
  73.  * Revision 1.14  2001/10/25 15:18:33  tng
  74.  * delete the parser before XMLPlatformUtils::Terminate.
  75.  *
  76.  * Revision 1.13  2001/10/19 19:02:42  tng
  77.  * [Bug 3909] return non-zero an exit code when error was encounted.
  78.  * And other modification for consistent help display and return code across samples.
  79.  *
  80.  * Revision 1.12  2001/05/11 13:24:54  tng
  81.  * Copyright update.
  82.  *
  83.  * Revision 1.11  2001/04/19 18:16:46  tng
  84.  * Schema: SchemaValidator update, and use QName in Content Model
  85.  *
  86.  * Revision 1.10  2001/03/21 21:55:57  tng
  87.  * Schema: Add Schema Grammar, Schema Validator, and split the DTDValidator into DTDValidator, DTDScanner, and DTDGrammar.
  88.  *
  89.  * Revision 1.9  2000/06/12 22:07:22  rahulj
  90.  * Correctly rejects unsupported command line options.
  91.  *
  92.  * Revision 1.8  2000/05/31 18:50:42  rahulj
  93.  * Removed extraneous command line arguments.
  94.  *
  95.  * Revision 1.7  2000/03/03 01:29:30  roddey
  96.  * Added a scanReset()/parseReset() method to the scanner and
  97.  * parsers, to allow for reset after early exit from a progressive parse.
  98.  * Added calls to new Terminate() call to all of the samples. Improved
  99.  * documentation in SAX and DOM parsers.
  100.  *
  101.  * Revision 1.6  2000/03/02 19:53:40  roddey
  102.  * This checkin includes many changes done while waiting for the
  103.  * 1.1.0 code to be finished. I can't list them all here, but a list is
  104.  * available elsewhere.
  105.  *
  106.  * Revision 1.5  2000/02/11 02:49:47  abagchi
  107.  * Removed StrX::transcode
  108.  *
  109.  * Revision 1.4  2000/02/11 02:26:40  abagchi
  110.  * Removed StrX::transcode
  111.  *
  112.  * Revision 1.3  2000/02/06 07:47:19  rahulj
  113.  * Year 2K copyright swat.
  114.  *
  115.  * Revision 1.2  1999/12/21 19:54:44  rahulj
  116.  * Added Apache license and version tags.
  117.  *
  118.  */
  119. // ---------------------------------------------------------------------------
  120. //  Includes
  121. // ---------------------------------------------------------------------------
  122. #include <xercesc/util/NameIdPool.hpp>
  123. #include <xercesc/util/PlatformUtils.hpp>
  124. #include <xercesc/framework/XMLValidator.hpp>
  125. #include <xercesc/parsers/SAXParser.hpp>
  126. #include <xercesc/validators/DTD/DTDValidator.hpp>
  127. #include <iostream.h>
  128. #include <stdlib.h>
  129. #include <string.h>
  130. XERCES_CPP_NAMESPACE_USE
  131. // ---------------------------------------------------------------------------
  132. //  Forward references
  133. // ---------------------------------------------------------------------------
  134. static void usage();
  135. // ---------------------------------------------------------------------------
  136. //  This is a simple class that lets us do easy (though not terribly efficient)
  137. //  trancoding of XMLCh data to local code page for display.
  138. // ---------------------------------------------------------------------------
  139. class StrX
  140. {
  141. public :
  142.     // -----------------------------------------------------------------------
  143.     //  Constructors and Destructor
  144.     // -----------------------------------------------------------------------
  145.     StrX(const XMLCh* const toTranscode)
  146.     {
  147.         // Call the private transcoding method
  148.         fLocalForm = XMLString::transcode(toTranscode);
  149.     }
  150.     ~StrX()
  151.     {
  152.         XMLString::release(&fLocalForm);
  153.     }
  154.     // -----------------------------------------------------------------------
  155.     //  Getter methods
  156.     // -----------------------------------------------------------------------
  157.     const char* localForm() const
  158.     {
  159.         return fLocalForm;
  160.     }
  161. private :
  162.     // -----------------------------------------------------------------------
  163.     //  Private data members
  164.     //
  165.     //  fLocalForm
  166.     //      This is the local code page form of the string.
  167.     // -----------------------------------------------------------------------
  168.     char*   fLocalForm;
  169. };
  170. inline ostream& operator<<(ostream& target, const StrX& toDump)
  171. {
  172.     target << toDump.localForm();
  173.     return target;
  174. }
  175. // ---------------------------------------------------------------------------
  176. //  Local helper methods
  177. // ---------------------------------------------------------------------------
  178. static void usage()
  179. {
  180.     cout << "nUsage:n"
  181.             "    EnumVal <XML file>nn"
  182.             "This program parses the specified XML file, then shows how ton"
  183.             "enumerate the contents of the DTD Grammar. Essentially,n"
  184.             "shows how one can access the DTD information stored in internaln"
  185.             "data structures.n"
  186.          << endl;
  187. }
  188. // ---------------------------------------------------------------------------
  189. //  Program entry point
  190. // ---------------------------------------------------------------------------
  191. int main(int argC, char* argV[])
  192. {
  193.     // Initialize the XML4C system
  194.     try
  195.     {
  196.          XMLPlatformUtils::Initialize();
  197.     }
  198.     catch (const XMLException& toCatch)
  199.     {
  200.          cerr   << "Error during initialization! Message:n"
  201.                 << StrX(toCatch.getMessage()) << endl;
  202.          XMLPlatformUtils::Terminate();
  203.          return 1;
  204.     }
  205.     // Check command line and extract arguments.
  206.     if (argC < 2)
  207.     {
  208.         usage();
  209.         XMLPlatformUtils::Terminate();
  210.         return 1;
  211.     }
  212.     // We only have one required parameter, which is the file to process
  213.     if ((argC != 2) || (*(argV[1]) == '-'))
  214.     {
  215.         usage();
  216.         XMLPlatformUtils::Terminate();
  217.         return 1;
  218.     }
  219.     const char*              xmlFile   = argV[1];
  220.     SAXParser::ValSchemes    valScheme = SAXParser::Val_Auto;
  221.     //
  222.     //  Create a DTD validator to be used for our validation work. Then create
  223.     //  a SAX parser object and pass it our validator. Then, according to what
  224.     //  we were told on the command line, set it to validate or not. He owns
  225.     //  the validator, so we have to allocate it.
  226.     //
  227.     int errorCount = 0;
  228.     DTDValidator* valToUse = new DTDValidator;
  229.     SAXParser* parser = new SAXParser(valToUse);
  230.     parser->setValidationScheme(valScheme);
  231.     //
  232.     //  Get the starting time and kick off the parse of the indicated
  233.     //  file. Catch any exceptions that might propogate out of it.
  234.     //
  235.     try
  236.     {
  237.         parser->parse(xmlFile);
  238.         errorCount = parser->getErrorCount();
  239.     }
  240.     catch (const XMLException& e)
  241.     {
  242.         cerr << "nError during parsing: '" << xmlFile << "'n"
  243.              << "Exception message is:  n"
  244.              << StrX(e.getMessage()) << "n" << endl;
  245.         XMLPlatformUtils::Terminate();
  246.         return 4;
  247.     }
  248.     if (!errorCount) {
  249.         //
  250.         //  Now we will get an enumerator for the element pool from the validator
  251.         //  and enumerate the elements, printing them as we go. For each element
  252.         //  we get an enumerator for its attributes and print them also.
  253.         //
  254.         DTDGrammar* grammar = (DTDGrammar*) valToUse->getGrammar();
  255.         NameIdPoolEnumerator<DTDElementDecl> elemEnum = grammar->getElemEnumerator();
  256.         if (elemEnum.hasMoreElements())
  257.         {
  258.             cout << "nELEMENTS:n----------------------------n";
  259.             while(elemEnum.hasMoreElements())
  260.             {
  261.                 const DTDElementDecl& curElem = elemEnum.nextElement();
  262.                 cout << "  Name: " << StrX(curElem.getFullName()) << "n";
  263.                 cout << "  Content Model: "
  264.                      << StrX(curElem.getFormattedContentModel())
  265.                      << "n";
  266.                 // Get an enumerator for this guy's attributes if any
  267.                 if (curElem.hasAttDefs())
  268.                 {
  269.                     cout << "  Attributes:n";
  270.                     XMLAttDefList& attList = curElem.getAttDefList();
  271.                     while (attList.hasMoreElements())
  272.                     {
  273.                         const XMLAttDef& curAttDef = attList.nextElement();
  274.                         cout << "    Name:" << StrX(curAttDef.getFullName())
  275.                              << ", Type: ";
  276.                         // Get the type and display it
  277.                         const XMLAttDef::AttTypes type = curAttDef.getType();
  278.                         switch(type)
  279.                         {
  280.                             case XMLAttDef::CData :
  281.                                 cout << "CDATA";
  282.                                 break;
  283.                             case XMLAttDef::ID :
  284.                                 cout << "ID";
  285.                                 break;
  286.                             case XMLAttDef::IDRef :
  287.                             case XMLAttDef::IDRefs :
  288.                                 cout << "IDREF(S)";
  289.                                 break;
  290.                             case XMLAttDef::Entity :
  291.                             case XMLAttDef::Entities :
  292.                                 cout << "ENTITY(IES)";
  293.                                 break;
  294.                             case XMLAttDef::NmToken :
  295.                             case XMLAttDef::NmTokens :
  296.                                 cout << "NMTOKEN(S)";
  297.                                 break;
  298.                             case XMLAttDef::Notation :
  299.                                 cout << "NOTATION";
  300.                                 break;
  301.                             case XMLAttDef::Enumeration :
  302.                                 cout << "ENUMERATION";
  303.                                 break;
  304.                         }
  305.                         cout << "n";
  306.                     }
  307.                 }
  308.                 cout << endl;
  309.             }
  310.         }
  311.          else
  312.         {
  313.             cout << "The validator has no elements to displayn" << endl;
  314.         }
  315.     }
  316.     else
  317.         cout << "nErrors occurred, no output availablen" << endl;
  318.     //
  319.     //  Delete the parser itself.  Must be done prior to calling Terminate, below.
  320.     //
  321.     delete parser;
  322.     // And call the termination method
  323.     XMLPlatformUtils::Terminate();
  324.     if (errorCount > 0)
  325.         return 4;
  326.     else
  327.         return 0;
  328. }