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

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

Update SAXCount; add Makefile.in

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