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

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

More path fixes.

File size: 11.3 KB
RevLine 
[2726]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//REVISIT
19/*
20 * $Id: PSVIWriter.cpp 833057 2009-11-05 15:25:10Z borisk $
21 */
22
23
24// ---------------------------------------------------------------------------
25//  Includes
26// ---------------------------------------------------------------------------
27#include "PSVIWriter.hpp"
28#include <xercesc/framework/StdOutFormatTarget.hpp>
29#include <xercesc/framework/LocalFileFormatTarget.hpp>
[2733]30#include <icxercesc/util/PlatformUtils.hpp>
31#include <icxercesc/util/TransService.hpp>
32#include <icxercesc/util/XMLString.hpp>
33#include <icxercesc/parsers/SAX2XMLReaderImpl.hpp>
[2726]34#include <xercesc/sax2/XMLReaderFactory.hpp>
35#include <xercesc/util/OutOfMemoryException.hpp>
36
37#if defined(XERCES_NEW_IOSTREAMS)
38#include <fstream>
39#else
40#include <fstream.h>
41#endif
42// ---------------------------------------------------------------------------
43//  Local helper methods
44// ---------------------------------------------------------------------------
45void usage()
46{
47        XERCES_STD_QUALIFIER cout << "\nUsage:\n"
48                        "    PSVIWriter [options] <XML file | List file>\n\n"
49                        "This program invokes the SAX2XMLReaderImpl, and then exposes the\n"
50                        "underlying PSVI of each parsed XML file, using SAX2 API.\n\n"
51                        "Options:\n"
52                        "    -f          Enable full schema constraint checking processing. Defaults to off.\n"
53                        "    -o=xxx      Output PSVI to file xxx (default is stdout)\n"
54                        "    -e=xxx      Output errors to file xxx (default is stdout)\n"
55                        "    -u=xxx      Handle unrepresentable chars [fail | rep | ref*].\n"
56                        "    -x=XXX      Use a particular encoding for output (UTF8*).\n"
57            "    -l          Indicate the input file is a List File that has a list of xml files.\n"
58            "                Default to off (Input file is an XML file).\n"
59                        "    -?          Show this help.\n\n"
60                        "  * = Default if not provided explicitly.\n"
61                << XERCES_STD_QUALIFIER endl;
62}
63
64
65// ---------------------------------------------------------------------------
66//  Program entry point
67// ---------------------------------------------------------------------------
68int main(int argC, char* argV[])
69{
70
71    // Check command line and extract arguments.
72    if (argC < 2)
73    {
74        usage();
75        return 1;
76    }
77
78    static const char* encodingName             = "UTF8";
79    static XMLFormatter::UnRepFlags unRepFlags = XMLFormatter::UnRep_CharRef;
80    const char*                                         xmlFile                         = 0;
81    bool                                                        doList                          = false; //REVISIT
82    bool                                                        schemaFullChecking      = false;
83    bool                                                        errorOccurred           = false;
84    const char*                                         psviOut                         = 0;
85    const char*                                         errorOut                        = 0;
86    XMLFormatTarget*                            psviTarget                      = 0;
87    XMLFormatTarget*                            errorTarget             = 0;
88    XMLFormatter*                                       psviFormatter           = 0;
89    XMLFormatter*                                       errorFormatter          = 0;
90    char                                                        fileName[80]            ="";
91
92
93    int argInd;
94    for (argInd = 1; argInd < argC; argInd++)
95    {
96        // Break out on first parm not starting with a dash
97        if (argV[argInd][0] != '-')
98            break;
99
100        // Watch for special case help request
101        if (!strcmp(argV[argInd], "-?"))
102        {
103            usage();
104            return 2;
105        }
106         else if (!strcmp(argV[argInd], "-l")
107              ||  !strcmp(argV[argInd], "-L"))
108        {
109            doList = true;
110        }
111         else if (!strcmp(argV[argInd], "-f")
112              ||  !strcmp(argV[argInd], "-F"))
113        {
114            schemaFullChecking = true;
115        }
116         else if (!strncmp(argV[argInd], "-o=", 3)
117              ||  !strncmp(argV[argInd], "-O=", 3))
118        {
119            psviOut = &argV[argInd][3];
120        }
121         else if (!strncmp(argV[argInd], "-e=", 3)
122              ||  !strncmp(argV[argInd], "-E=", 3))
123        {
124            errorOut = &argV[argInd][3];
125        }
126         else if (!strncmp(argV[argInd], "-x=", 3)
127              ||  !strncmp(argV[argInd], "-X=", 3))
128        {
129            // Get out the encoding name
130            encodingName = &argV[argInd][3];
131        }
132         else if (!strncmp(argV[argInd], "-u=", 3)
133              ||  !strncmp(argV[argInd], "-U=", 3))
134        {
135            const char* const parm = &argV[argInd][3];
136
137            if (!strcmp(parm, "fail"))
138                unRepFlags = XMLFormatter::UnRep_Fail;
139            else if (!strcmp(parm, "rep"))
140                unRepFlags = XMLFormatter::UnRep_Replace;
141            else if (!strcmp(parm, "ref"))
142                unRepFlags = XMLFormatter::UnRep_CharRef;
143            else
144            {
145                XERCES_STD_QUALIFIER cerr << "Unknown -u= value: " << parm << XERCES_STD_QUALIFIER endl;
146                XMLPlatformUtils::Terminate();
147                return 2;
148            }
149        }
150        else
151        {
152            XERCES_STD_QUALIFIER cerr << "Unknown option '" << argV[argInd]
153                << "', ignoring it\n" << XERCES_STD_QUALIFIER endl;
154        }
155    }
156
157    //
158    //  There should be only one and only one parameter left, and that
159    //  should be the file name.
160    //
161    if (argInd != argC - 1)
162    {
163        usage();
164        return 1;
165    }
166
167    // Initialize the XML4C2 system
168    try
169    {
170        XMLPlatformUtils::Initialize();
171    } catch (const XMLException& toCatch) {
172        XERCES_STD_QUALIFIER cerr << "Error during initialization! Message:\n"
173            << StrX(toCatch.getMessage()) << XERCES_STD_QUALIFIER endl;
174        return 1;
175    }
176
177    //
178    //  Create a SAX parser object, then set it to validate or not.
179    //
180    SAX2XMLReaderImpl* parser = new SAX2XMLReaderImpl();
181    parser->setFeature(XMLUni::fgSAX2CoreNameSpaces, true);
182    parser->setFeature(XMLUni::fgXercesSchema, true);
183    parser->setFeature(XMLUni::fgXercesHandleMultipleImports, true);
184    parser->setFeature(XMLUni::fgXercesSchemaFullChecking, schemaFullChecking);
185    parser->setFeature(XMLUni::fgSAX2CoreNameSpacePrefixes, false);
186    parser->setFeature(XMLUni::fgSAX2CoreValidation, true);
187    parser->setFeature(XMLUni::fgXercesDynamic, true);
188
189        //
190        //      Based on commandline arguments, create XMLFormatters for PSVI output and errors
191        //
192        if (!doList) {
193            if (psviOut==0) {
194                psviTarget = new StdOutFormatTarget();
195            } else {
196                psviTarget = new LocalFileFormatTarget(psviOut);
197            }
198                psviFormatter = new XMLFormatter(encodingName, psviTarget, XMLFormatter::NoEscapes, unRepFlags);
199    }
200
201    if (errorOut==0) {
202        errorTarget = new StdOutFormatTarget();
203    } else {
204        errorTarget = new LocalFileFormatTarget(errorOut);
205    }
206        errorFormatter = new XMLFormatter(encodingName, errorTarget, XMLFormatter::NoEscapes, unRepFlags);
207
208        //
209    //  Create our SAX handler object and install it as the handlers
210    //
211
212        PSVIWriterHandlers* handler;
213        if (doList)
214                handler = new PSVIWriterHandlers(0, errorFormatter);
215        else
216                handler = new PSVIWriterHandlers(psviFormatter, errorFormatter);
217
218    PSVIAdvancedHandler* advancedHandler = new PSVIAdvancedHandler(handler);
219    parser->installAdvDocHandler(advancedHandler);
220
221        parser->setPSVIHandler(handler);
222    parser->setContentHandler(handler);
223    parser->setLexicalHandler(handler);
224        parser->setXMLEntityResolver(handler);
225    parser->setErrorHandler(handler);
226
227    //
228    //  Get the starting time and kick off the parse of the indicated
229    //  file. Catch any exceptions that might propogate out of it.
230    //
231    unsigned long duration;
232
233    bool more = true;
234    XERCES_STD_QUALIFIER ifstream fin;
235
236    // the input is a list file
237    if (doList) //REVISIT
238        fin.open(argV[argInd]);
239
240    if (fin.fail()) {
241        XERCES_STD_QUALIFIER cerr <<"Cannot open the list file: " << argV[argInd] << XERCES_STD_QUALIFIER endl;
242        return 2;
243    }
244
245    while (more) //REVISIT
246    {
247        char fURI[1000];
248        //initialize the array to zeros
249        memset(fURI,0,sizeof(fURI));
250
251        if (doList) {
252            if (! fin.eof() ) {
253                fin.getline (fURI, sizeof(fURI));
254                if (!*fURI)
255                    continue;
256                else {
257                    xmlFile =fURI;
258                    XMLString::trim((char*)xmlFile);
259                    XERCES_STD_QUALIFIER cerr << "==Parsing== \"" << xmlFile << "\"" << XERCES_STD_QUALIFIER endl;
260                }
261
262                                if (psviOut==0) {
263                                        if (psviTarget==0 && psviFormatter==0) {
264                                        psviTarget = new StdOutFormatTarget();
265                                                psviFormatter = new XMLFormatter(encodingName, psviTarget, XMLFormatter::NoEscapes, unRepFlags);
266                                                handler->resetPSVIFormatter(psviFormatter);
267                                }
268                            } else {
269                                        strcpy(fileName, psviOut);
270                                        if (strrchr(xmlFile, '\\')>strrchr(xmlFile, '/')) {
271                                                strcat(fileName, strrchr(xmlFile, '\\'));
272                                        } else {
273                                                strcat(fileName, strrchr(xmlFile, '/'));
274                                        }
275                        if (psviFormatter)
276                                delete psviFormatter;
277                        if (psviTarget)
278                                delete psviTarget;
279                                psviTarget = new LocalFileFormatTarget(fileName);
280                                        psviFormatter = new XMLFormatter(encodingName, psviTarget, XMLFormatter::NoEscapes, unRepFlags);
281                                        handler->resetPSVIFormatter(psviFormatter);
282                            }
283            }
284            else
285                break;
286        }
287        else {
288            xmlFile = argV[argInd];
289            more = false; //REVISIT
290        }
291
292        //reset error count first
293        handler->resetErrors();
294
295        try
296        {
297            const unsigned long startMillis = XMLPlatformUtils::getCurrentMillis();
298            parser->parse(xmlFile);
299            const unsigned long endMillis = XMLPlatformUtils::getCurrentMillis();
300            duration = endMillis - startMillis;
301        }
302        catch (const OutOfMemoryException&)
303        {
304            XERCES_STD_QUALIFIER cerr << "OutOfMemoryException" << XERCES_STD_QUALIFIER endl;
305            errorOccurred = true;
306            continue;
307        }
308        catch (const XMLException& e)
309        {
310            XERCES_STD_QUALIFIER cerr << "\nError during parsing: '" << xmlFile << "'\n"
311                << "Exception message is:  \n"
312                << StrX(e.getMessage()) << "\n" << XERCES_STD_QUALIFIER endl;
313            errorOccurred = true;
314            continue;
315        }
316
317        catch (...)
318        {
319            XERCES_STD_QUALIFIER cerr << "\nUnexpected exception during parsing: '" << xmlFile << "'\n" << XERCES_STD_QUALIFIER endl;;
320            errorOccurred = true;
321            continue;
322        }
323    }
324
325    if (doList) //REVISIT
326        fin.close();
327
328    //
329    //  Delete the parser itself.  Must be done prior to calling Terminate, below.
330    //
331    delete parser;
332    delete advancedHandler;
333    delete handler;
334    delete psviFormatter;
335    delete errorFormatter;
336    delete psviTarget;
337    delete errorTarget;
338
339    // And call the termination method
340    XMLPlatformUtils::Terminate();
341
342    if (errorOccurred)
343        return 4;
344    else
345        return 0;
346
347}
Note: See TracBrowser for help on using the repository browser.