source: icXML/icXML-devel/samples/src/SAX2Count/SAX2Count.cpp @ 2733

Last change on this file since 2733 was 2733, checked in by cameron, 6 years ago

More path fixes.

File size: 11.5 KB
Line 
1/*
2 * Licensed to the Apache Software Foundation (ASF) under one or more
3 * contributor license agreements.  See the NOTICE file distributed with
4 * this work for additional information regarding copyright ownership.
5 * The ASF licenses this file to You under the Apache License, Version 2.0
6 * (the "License"); you may not use this file except in compliance with
7 * the License.  You may obtain a copy of the License at
8 *
9 *      http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 */
17
18/*
19 * $Id: SAX2Count.cpp 833057 2009-11-05 15:25:10Z borisk $
20 */
21
22
23// ---------------------------------------------------------------------------
24//  Includes
25// ---------------------------------------------------------------------------
26#include "SAX2Count.hpp"
27#include <icxercesc/util/PlatformUtils.hpp>
28#include <xercesc/sax2/SAX2XMLReader.hpp>
29#include <xercesc/sax2/XMLReaderFactory.hpp>
30#if defined(XERCES_NEW_IOSTREAMS)
31#include <fstream>
32#else
33#include <fstream.h>
34#endif
35#include <xercesc/util/OutOfMemoryException.hpp>
36
37// ---------------------------------------------------------------------------
38//  Local helper methods
39// ---------------------------------------------------------------------------
40void usage()
41{
42    XERCES_STD_QUALIFIER cout << "\nUsage:\n"
43            "    SAX2Count [options] <XML file | List file>\n\n"
44            "This program invokes the SAX2XMLReader, and then prints the\n"
45            "number of elements, attributes, spaces and characters found\n"
46            "in each XML file, using SAX2 API.\n\n"
47            "Options:\n"
48            "    -l          Indicate the input file is a List File that has a list of xml files.\n"
49            "                Default to off (Input file is an XML file).\n"
50            "    -v=xxx      Validation scheme [always | never | auto*].\n"
51            "    -f          Enable full schema constraint checking processing. Defaults to off.\n"
52            "    -p          Enable namespace-prefixes feature. Defaults to off.\n"
53            "    -n          Disable namespace processing. Defaults to on.\n"
54            "                NOTE: THIS IS OPPOSITE FROM OTHER SAMPLES.\n"
55            "    -s          Disable schema processing. Defaults to on.\n"
56            "                NOTE: THIS IS OPPOSITE FROM OTHER SAMPLES.\n"
57            "    -i          Disable identity constraint checking. Defaults to on.\n"
58            "                NOTE: THIS IS OPPOSITE FROM OTHER SAMPLES.\n"
59            "    -locale=ll_CC specify the locale, default: en_US.\n"
60            "    -?          Show this help.\n\n"
61            "  * = Default if not provided explicitly.\n"
62         << XERCES_STD_QUALIFIER endl;
63}
64
65
66// ---------------------------------------------------------------------------
67//  Program entry point
68// ---------------------------------------------------------------------------
69int main(int argC, char* argV[])
70{
71
72    // Check command line and extract arguments.
73    if (argC < 2)
74    {
75        usage();
76        return 1;
77    }
78
79    const char*                  xmlFile      = 0;
80    SAX2XMLReader::ValSchemes    valScheme    = SAX2XMLReader::Val_Auto;
81    bool                         doNamespaces = true;
82    bool                         doSchema = true;
83    bool                         schemaFullChecking = false;
84    bool                         identityConstraintChecking = true;
85    bool                         doList = false;
86    bool                         errorOccurred = false;
87    bool                         namespacePrefixes = false;
88    bool                         recognizeNEL = false;
89    char                         localeStr[64];
90    memset(localeStr, 0, sizeof localeStr);
91
92    int argInd;
93    for (argInd = 1; argInd < argC; argInd++)
94    {
95        // Break out on first parm not starting with a dash
96        if (argV[argInd][0] != '-')
97            break;
98
99        // Watch for special case help request
100        if (!strcmp(argV[argInd], "-?"))
101        {
102            usage();
103            return 2;
104        }
105         else if (!strncmp(argV[argInd], "-v=", 3)
106              ||  !strncmp(argV[argInd], "-V=", 3))
107        {
108            const char* const parm = &argV[argInd][3];
109
110            if (!strcmp(parm, "never"))
111                valScheme = SAX2XMLReader::Val_Never;
112            else if (!strcmp(parm, "auto"))
113                valScheme = SAX2XMLReader::Val_Auto;
114            else if (!strcmp(parm, "always"))
115                valScheme = SAX2XMLReader::Val_Always;
116            else
117            {
118                XERCES_STD_QUALIFIER cerr << "Unknown -v= value: " << parm << XERCES_STD_QUALIFIER endl;
119                return 2;
120            }
121        }
122         else if (!strcmp(argV[argInd], "-n")
123              ||  !strcmp(argV[argInd], "-N"))
124        {
125            doNamespaces = false;
126        }
127         else if (!strcmp(argV[argInd], "-s")
128              ||  !strcmp(argV[argInd], "-S"))
129        {
130            doSchema = false;
131        }
132         else if (!strcmp(argV[argInd], "-f")
133              ||  !strcmp(argV[argInd], "-F"))
134        {
135            schemaFullChecking = true;
136        }
137         else if (!strcmp(argV[argInd], "-i")
138              ||  !strcmp(argV[argInd], "-I"))
139        {
140            identityConstraintChecking = false;
141        }
142         else if (!strcmp(argV[argInd], "-l")
143              ||  !strcmp(argV[argInd], "-L"))
144        {
145            doList = true;
146        }
147         else if (!strcmp(argV[argInd], "-p")
148              ||  !strcmp(argV[argInd], "-P"))
149        {
150            namespacePrefixes = true;
151        }
152         else if (!strcmp(argV[argInd], "-special:nel"))
153        {
154            // turning this on will lead to non-standard compliance behaviour
155            // it will recognize the unicode character 0x85 as new line character
156            // instead of regular character as specified in XML 1.0
157            // do not turn this on unless really necessary
158             recognizeNEL = true;
159        }
160         else if (!strncmp(argV[argInd], "-locale=", 8))
161        {
162             // Get out the end of line
163             strncpy(localeStr, &(argV[argInd][8]), sizeof localeStr);
164        }
165        else
166        {
167            XERCES_STD_QUALIFIER cerr << "Unknown option '" << argV[argInd]
168                << "', ignoring it\n" << XERCES_STD_QUALIFIER endl;
169        }
170    }
171
172    //
173    //  There should be only one and only one parameter left, and that
174    //  should be the file name.
175    //
176    if (argInd != argC - 1)
177    {
178        usage();
179        return 1;
180    }
181
182    // Initialize the XML4C2 system
183    try
184    {
185        if (strlen(localeStr))
186        {
187            XMLPlatformUtils::Initialize(localeStr);
188        }
189        else
190        {
191            XMLPlatformUtils::Initialize();
192        }
193
194        if (recognizeNEL)
195        {
196            XMLPlatformUtils::recognizeNEL(recognizeNEL);
197        }
198    }
199
200    catch (const XMLException& toCatch)
201    {
202        XERCES_STD_QUALIFIER cerr << "Error during initialization! Message:\n"
203            << StrX(toCatch.getMessage()) << XERCES_STD_QUALIFIER endl;
204        return 1;
205    }
206
207    //
208    //  Create a SAX parser object. Then, according to what we were told on
209    //  the command line, set it to validate or not.
210    //
211    SAX2XMLReader* parser = XMLReaderFactory::createXMLReader();
212    parser->setFeature(XMLUni::fgSAX2CoreNameSpaces, doNamespaces);
213    parser->setFeature(XMLUni::fgXercesSchema, doSchema);
214    parser->setFeature(XMLUni::fgXercesHandleMultipleImports, true);
215    parser->setFeature(XMLUni::fgXercesSchemaFullChecking, schemaFullChecking);
216    parser->setFeature(XMLUni::fgXercesIdentityConstraintChecking, identityConstraintChecking);
217    parser->setFeature(XMLUni::fgSAX2CoreNameSpacePrefixes, namespacePrefixes);
218
219    if (valScheme == SAX2XMLReader::Val_Auto)
220    {
221        parser->setFeature(XMLUni::fgSAX2CoreValidation, true);
222        parser->setFeature(XMLUni::fgXercesDynamic, true);
223    }
224    if (valScheme == SAX2XMLReader::Val_Never)
225    {
226        parser->setFeature(XMLUni::fgSAX2CoreValidation, false);
227    }
228    if (valScheme == SAX2XMLReader::Val_Always)
229    {
230        parser->setFeature(XMLUni::fgSAX2CoreValidation, true);
231        parser->setFeature(XMLUni::fgXercesDynamic, false);
232    }
233
234    //
235    //  Create our SAX handler object and install it on the parser, as the
236    //  document and error handler.
237    //
238    SAX2CountHandlers handler;
239    parser->setContentHandler(&handler);
240    parser->setErrorHandler(&handler);
241
242    //
243    //  Get the starting time and kick off the parse of the indicated
244    //  file. Catch any exceptions that might propogate out of it.
245    //
246    unsigned long duration;
247
248    bool more = true;
249    XERCES_STD_QUALIFIER ifstream fin;
250
251    // the input is a list file
252    if (doList)
253        fin.open(argV[argInd]);
254
255    if (fin.fail()) {
256        XERCES_STD_QUALIFIER cerr <<"Cannot open the list file: " << argV[argInd] << XERCES_STD_QUALIFIER endl;
257        return 2;
258    }
259
260    while (more)
261    {
262        char fURI[1000];
263        //initialize the array to zeros
264        memset(fURI,0,sizeof(fURI));
265
266        if (doList) {
267            if (! fin.eof() ) {
268                fin.getline (fURI, sizeof(fURI));
269                if (!*fURI)
270                    continue;
271                else {
272                    xmlFile = fURI;
273                    XERCES_STD_QUALIFIER cerr << "==Parsing== " << xmlFile << XERCES_STD_QUALIFIER endl;
274                }
275            }
276            else
277                break;
278        }
279        else {
280            xmlFile = argV[argInd];
281            more = false;
282        }
283
284        //reset error count first
285        handler.resetErrors();
286
287        try
288        {
289            const unsigned long startMillis = XMLPlatformUtils::getCurrentMillis();
290            parser->parse(xmlFile);
291            const unsigned long endMillis = XMLPlatformUtils::getCurrentMillis();
292            duration = endMillis - startMillis;
293        }
294        catch (const OutOfMemoryException&)
295        {
296            XERCES_STD_QUALIFIER cerr << "OutOfMemoryException" << XERCES_STD_QUALIFIER endl;
297            errorOccurred = true;
298            continue;
299        }
300        catch (const XMLException& e)
301        {
302            XERCES_STD_QUALIFIER cerr << "\nError during parsing: '" << xmlFile << "'\n"
303                << "Exception message is:  \n"
304                << StrX(e.getMessage()) << "\n" << XERCES_STD_QUALIFIER endl;
305            errorOccurred = true;
306            continue;
307        }
308
309        catch (...)
310        {
311            XERCES_STD_QUALIFIER cerr << "\nUnexpected exception during parsing: '" << xmlFile << "'\n";
312            errorOccurred = true;
313            continue;
314        }
315
316
317        // Print out the stats that we collected and time taken
318        if (!handler.getSawErrors())
319        {
320            XERCES_STD_QUALIFIER cout << xmlFile << ": " << duration << " ms ("
321                << handler.getElementCount() << " elems, "
322                << handler.getAttrCount() << " attrs, "
323                << handler.getSpaceCount() << " spaces, "
324                << handler.getCharacterCount() << " chars)" << XERCES_STD_QUALIFIER endl;
325        }
326        else
327            errorOccurred = true;
328    }
329
330    if (doList)
331        fin.close();
332
333    //
334    //  Delete the parser itself.  Must be done prior to calling Terminate, below.
335    //
336    delete parser;
337
338    // And call the termination method
339    XMLPlatformUtils::Terminate();
340
341    if (errorOccurred)
342        return 4;
343    else
344        return 0;
345
346}
Note: See TracBrowser for help on using the repository browser.