source: icXML/icXML-devel/samples/src/SAXCount/SAXCount.cpp @ 2726

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

Add original Xerces tests and samples directories

File size: 9.9 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: SAXCount.cpp 833057 2009-11-05 15:25:10Z borisk $
20 */
21
22
23// ---------------------------------------------------------------------------
24//  Includes
25// ---------------------------------------------------------------------------
26#include "SAXCount.hpp"
27#if defined(XERCES_NEW_IOSTREAMS)
28#include <fstream>
29#else
30#include <fstream.h>
31#endif
32#include <xercesc/util/OutOfMemoryException.hpp>
33
34// ---------------------------------------------------------------------------
35//  Local helper methods
36// ---------------------------------------------------------------------------
37void usage()
38{
39    XERCES_STD_QUALIFIER cout << "\nUsage:\n"
40            "    SAXCount [options] <XML file | List file>\n\n"
41            "This program invokes the SAX Parser, and then prints the\n"
42            "number of elements, attributes, spaces and characters found\n"
43            "in each XML file, using SAX API.\n\n"
44            "Options:\n"
45            "    -l          Indicate the input file is a List File that has a list of xml files.\n"
46            "                Default to off (Input file is an XML file).\n"
47            "    -v=xxx      Validation scheme [always | never | auto*].\n"
48            "    -n          Enable namespace processing. Defaults to off.\n"
49            "    -s          Enable schema processing. Defaults to off.\n"
50            "    -f          Enable full schema constraint checking. Defaults to off.\n"
51            "    -locale=ll_CC specify the locale, default: en_US.\n"
52                    "    -?          Show this help.\n\n"
53            "  * = Default if not provided explicitly.\n"
54         << XERCES_STD_QUALIFIER endl;
55}
56
57
58// ---------------------------------------------------------------------------
59//  Program entry point
60// ---------------------------------------------------------------------------
61int main(int argC, char* argV[])
62{
63
64    // Check command line and extract arguments.
65    if (argC < 2)
66    {
67        usage();
68        return 1;
69    }
70
71    const char*              xmlFile = 0;
72    SAXParser::ValSchemes    valScheme = SAXParser::Val_Auto;
73    bool                     doNamespaces       = false;
74    bool                     doSchema           = false;
75    bool                     schemaFullChecking = false;
76    bool                     doList = false;
77    bool                     errorOccurred = false;
78    bool                     recognizeNEL = false;
79    char                     localeStr[64];
80    memset(localeStr, 0, sizeof localeStr);
81
82    int argInd;
83    for (argInd = 1; argInd < argC; argInd++)
84    {
85        // Break out on first parm not starting with a dash
86        if (argV[argInd][0] != '-')
87            break;
88
89        // Watch for special case help request
90        if (!strcmp(argV[argInd], "-?"))
91        {
92            usage();
93            return 2;
94        }
95         else if (!strncmp(argV[argInd], "-v=", 3)
96              ||  !strncmp(argV[argInd], "-V=", 3))
97        {
98            const char* const parm = &argV[argInd][3];
99
100            if (!strcmp(parm, "never"))
101                valScheme = SAXParser::Val_Never;
102            else if (!strcmp(parm, "auto"))
103                valScheme = SAXParser::Val_Auto;
104            else if (!strcmp(parm, "always"))
105                valScheme = SAXParser::Val_Always;
106            else
107            {
108                XERCES_STD_QUALIFIER cerr << "Unknown -v= value: " << parm << XERCES_STD_QUALIFIER endl;
109                return 2;
110            }
111        }
112         else if (!strcmp(argV[argInd], "-n")
113              ||  !strcmp(argV[argInd], "-N"))
114        {
115            doNamespaces = true;
116        }
117         else if (!strcmp(argV[argInd], "-s")
118              ||  !strcmp(argV[argInd], "-S"))
119        {
120            doSchema = true;
121        }
122         else if (!strcmp(argV[argInd], "-f")
123              ||  !strcmp(argV[argInd], "-F"))
124        {
125            schemaFullChecking = true;
126        }
127         else if (!strcmp(argV[argInd], "-l")
128              ||  !strcmp(argV[argInd], "-L"))
129        {
130            doList = true;
131        }
132         else if (!strcmp(argV[argInd], "-special:nel"))
133        {
134            // turning this on will lead to non-standard compliance behaviour
135            // it will recognize the unicode character 0x85 as new line character
136            // instead of regular character as specified in XML 1.0
137            // do not turn this on unless really necessary
138             recognizeNEL = true;
139        }
140         else if (!strncmp(argV[argInd], "-locale=", 8))
141        {
142             // Get out the end of line
143             strcpy(localeStr, &(argV[argInd][8]));
144        }
145        else
146        {
147            XERCES_STD_QUALIFIER cerr << "Unknown option '" << argV[argInd]
148                << "', ignoring it\n" << XERCES_STD_QUALIFIER endl;
149        }
150    }
151
152    //
153    //  There should at least one parameter left, and that
154    //  should be the file name(s).
155    //
156    if (argInd == argC)
157    {
158        usage();
159        return 1;
160    }
161
162    // Initialize the XML4C2 system
163    try
164    {
165        if (strlen(localeStr))
166        {
167            XMLPlatformUtils::Initialize(localeStr);
168        }
169        else
170        {
171            XMLPlatformUtils::Initialize();
172        }
173
174        if (recognizeNEL)
175        {
176            XMLPlatformUtils::recognizeNEL(recognizeNEL);
177        }
178    }
179
180    catch (const XMLException& toCatch)
181    {
182        XERCES_STD_QUALIFIER cerr << "Error during initialization! Message:\n"
183            << StrX(toCatch.getMessage()) << XERCES_STD_QUALIFIER endl;
184        return 1;
185    }
186
187    //
188    //  Create a SAX parser object. Then, according to what we were told on
189    //  the command line, set it to validate or not.
190    //
191    SAXParser* parser = new SAXParser;
192
193    parser->setValidationScheme(valScheme);
194    parser->setDoNamespaces(doNamespaces);
195    parser->setDoSchema(doSchema);
196    parser->setHandleMultipleImports (true);
197    parser->setValidationSchemaFullChecking(schemaFullChecking);
198
199    //
200    //  Create our SAX handler object and install it on the parser, as the
201    //  document and error handler.
202    //
203    SAXCountHandlers handler;
204    parser->setDocumentHandler(&handler);
205    parser->setErrorHandler(&handler);
206
207
208    //
209    //  Get the starting time and kick off the parse of the indicated
210    //  file. Catch any exceptions that might propogate out of it.
211    //
212    unsigned long duration;
213
214    XERCES_STD_QUALIFIER ifstream fin;
215
216    // the input is a list file
217    if (doList)
218        fin.open(argV[argInd]);
219
220    if (fin.fail()) {
221        XERCES_STD_QUALIFIER cerr <<"Cannot open the list file: " << argV[argInd] << XERCES_STD_QUALIFIER endl;
222        return 2;
223    }
224
225    while (true)
226    {
227        char fURI[1000];
228        //initialize the array to zeros
229        memset(fURI,0,sizeof(fURI));
230
231        if (doList) {
232            if (! fin.eof() ) {
233                fin.getline (fURI, sizeof(fURI));
234                if (!*fURI)
235                    continue;
236                else {
237                    xmlFile = fURI;
238                    XERCES_STD_QUALIFIER cerr << "==Parsing== " << xmlFile << XERCES_STD_QUALIFIER endl;
239                }
240            }
241            else
242                break;
243        }
244        else {
245            if (argInd < argC)
246            {
247                 xmlFile = argV[argInd];
248                 argInd++;
249            }
250            else
251                break;
252        }
253
254        //reset error count first
255        handler.resetErrors();
256
257        try
258        {
259            const unsigned long startMillis = XMLPlatformUtils::getCurrentMillis();
260            parser->parse(xmlFile);
261            const unsigned long endMillis = XMLPlatformUtils::getCurrentMillis();
262            duration = endMillis - startMillis;
263        }
264        catch (const OutOfMemoryException&)
265        {
266            XERCES_STD_QUALIFIER cerr << "OutOfMemoryException" << XERCES_STD_QUALIFIER endl;
267            errorOccurred = true;
268            continue;
269        }
270        catch (const XMLException& e)
271        {
272            XERCES_STD_QUALIFIER cerr << "\nError during parsing: '" << xmlFile << "'\n"
273                << "Exception message is:  \n"
274                << StrX(e.getMessage()) << "\n" << XERCES_STD_QUALIFIER endl;
275            errorOccurred = true;
276            continue;
277        }
278
279        catch (...)
280        {
281            XERCES_STD_QUALIFIER cerr << "\nUnexpected exception during parsing: '" << xmlFile << "'\n";
282            errorOccurred = true;
283            continue;
284        }
285
286
287        // Print out the stats that we collected and time taken
288        if (!handler.getSawErrors())
289        {
290            XERCES_STD_QUALIFIER cout << xmlFile << ": " << duration << " ms ("
291                << handler.getElementCount() << " elems, "
292                << handler.getAttrCount() << " attrs, "
293                << handler.getSpaceCount() << " spaces, "
294                << handler.getCharacterCount() << " chars)" << XERCES_STD_QUALIFIER endl;
295        }
296        else
297            errorOccurred = true;
298    }
299
300    if (doList)
301        fin.close();
302
303    //
304    //  Delete the parser itself.  Must be done prior to calling Terminate, below.
305    //
306    delete parser;
307
308    // And call the termination method
309    XMLPlatformUtils::Terminate();
310
311    if (errorOccurred)
312        return 4;
313    else
314        return 0;
315
316}
Note: See TracBrowser for help on using the repository browser.