void processSimpleTypeDefinition(XSSimpleTypeDefinition * xsSimpleTypeDef) { XSTypeDefinition *xsBaseTypeDef = xsSimpleTypeDef->getBaseType(); XERCES_STD_QUALIFIER cout << "Base:\t\t\t"; XERCES_STD_QUALIFIER cout << StrX(xsBaseTypeDef->getName()) << XERCES_STD_QUALIFIER endl; int facets = xsSimpleTypeDef->getDefinedFacets(); if (facets) { XERCES_STD_QUALIFIER cout << "Facets:\n"; if (facets & XSSimpleTypeDefinition::FACET_LENGTH) XERCES_STD_QUALIFIER cout << "\tLength:\t\t" << StrX(xsSimpleTypeDef->getLexicalFacetValue(XSSimpleTypeDefinition::FACET_LENGTH)) << XERCES_STD_QUALIFIER endl; if (facets & XSSimpleTypeDefinition::FACET_MINLENGTH) XERCES_STD_QUALIFIER cout << "\tMinLength:\t" << StrX(xsSimpleTypeDef->getLexicalFacetValue(XSSimpleTypeDefinition::FACET_MINLENGTH)) << XERCES_STD_QUALIFIER endl; if (facets & XSSimpleTypeDefinition::FACET_MAXLENGTH) XERCES_STD_QUALIFIER cout << "\tMaxLength:\t" << StrX(xsSimpleTypeDef->getLexicalFacetValue(XSSimpleTypeDefinition::FACET_MAXLENGTH)) << XERCES_STD_QUALIFIER endl; if (facets & XSSimpleTypeDefinition::FACET_PATTERN) { StringList *lexicalPatterns = xsSimpleTypeDef->getLexicalPattern(); if (lexicalPatterns && lexicalPatterns->size()) { XERCES_STD_QUALIFIER cout << "\tPattern:\t\t"; for (unsigned i = 0; i < lexicalPatterns->size(); i++) { XERCES_STD_QUALIFIER cout << StrX(lexicalPatterns->elementAt(i)); } XERCES_STD_QUALIFIER cout << XERCES_STD_QUALIFIER endl; } } if (facets & XSSimpleTypeDefinition::FACET_WHITESPACE) XERCES_STD_QUALIFIER cout << "\tWhitespace:\t\t" << StrX(xsSimpleTypeDef->getLexicalFacetValue(XSSimpleTypeDefinition::FACET_WHITESPACE)) << XERCES_STD_QUALIFIER endl; if (facets & XSSimpleTypeDefinition::FACET_MAXINCLUSIVE) XERCES_STD_QUALIFIER cout << "\tMaxInclusive:\t" << StrX(xsSimpleTypeDef->getLexicalFacetValue(XSSimpleTypeDefinition::FACET_MAXINCLUSIVE)) << XERCES_STD_QUALIFIER endl; if (facets & XSSimpleTypeDefinition::FACET_MAXEXCLUSIVE) XERCES_STD_QUALIFIER cout << "\tMaxExclusive:\t" << StrX(xsSimpleTypeDef->getLexicalFacetValue(XSSimpleTypeDefinition::FACET_MAXEXCLUSIVE)) << XERCES_STD_QUALIFIER endl; if (facets & XSSimpleTypeDefinition::FACET_MINEXCLUSIVE) XERCES_STD_QUALIFIER cout << "\tMinExclusive:\t" << StrX(xsSimpleTypeDef->getLexicalFacetValue(XSSimpleTypeDefinition::FACET_MINEXCLUSIVE)) << XERCES_STD_QUALIFIER endl; if (facets & XSSimpleTypeDefinition::FACET_MININCLUSIVE) XERCES_STD_QUALIFIER cout << "\tMinInclusive:\t" << StrX(xsSimpleTypeDef->getLexicalFacetValue(XSSimpleTypeDefinition::FACET_MININCLUSIVE)) << XERCES_STD_QUALIFIER endl; if (facets & XSSimpleTypeDefinition::FACET_TOTALDIGITS) XERCES_STD_QUALIFIER cout << "\tTotalDigits:\t" << StrX(xsSimpleTypeDef->getLexicalFacetValue(XSSimpleTypeDefinition::FACET_TOTALDIGITS)) << XERCES_STD_QUALIFIER endl; if (facets & XSSimpleTypeDefinition::FACET_FRACTIONDIGITS) XERCES_STD_QUALIFIER cout << "\tFractionDigits:\t" << StrX(xsSimpleTypeDef->getLexicalFacetValue(XSSimpleTypeDefinition::FACET_FRACTIONDIGITS)) << XERCES_STD_QUALIFIER endl; if (facets & XSSimpleTypeDefinition::FACET_ENUMERATION) { StringList *lexicalEnums = xsSimpleTypeDef->getLexicalEnumeration(); if (lexicalEnums && lexicalEnums->size()) { XERCES_STD_QUALIFIER cout << "\tEnumeration:\n"; for (unsigned i = 0; i < lexicalEnums->size(); i++) { XERCES_STD_QUALIFIER cout << "\t\t\t" << StrX(lexicalEnums->elementAt(i)) << "\n"; } XERCES_STD_QUALIFIER cout << XERCES_STD_QUALIFIER endl; } } } }
// --------------------------------------------------------------------------- // Program entry point // --------------------------------------------------------------------------- int main(int argC, char* argV[]) { // Check command line and extract arguments. if (argC < 2) { usage(); return 1; } // cannot return out of catch-blocks lest exception-destruction // result in calls to destroyed memory handler! int errorCode = 0; try { XMLPlatformUtils::Initialize(); } catch (const XMLException& toCatch) { XERCES_STD_QUALIFIER cerr << "Error during initialization! Message:\n" << StrX(toCatch.getMessage()) << XERCES_STD_QUALIFIER endl; errorCode = 2; } if(errorCode) { XMLPlatformUtils::Terminate(); return errorCode; } bool doList = false; bool schemaFullChecking = false; const char* xsdFile = 0; int argInd; for (argInd = 1; argInd < argC; argInd++) { // Break out on first parm not starting with a dash if (argV[argInd][0] != '-') break; // Watch for special case help request if (!strcmp(argV[argInd], "-?")) { usage(); return 1; } else if (!strcmp(argV[argInd], "-l") || !strcmp(argV[argInd], "-L")) { doList = true; } else if (!strcmp(argV[argInd], "-f") || !strcmp(argV[argInd], "-F")) { schemaFullChecking = true; } else { XERCES_STD_QUALIFIER cerr << "Unknown option '" << argV[argInd] << "', ignoring it\n" << XERCES_STD_QUALIFIER endl; } } // // There should be only one and only one parameter left, and that // should be the file name. // if (argInd != argC - 1) { usage(); return 1; } XMLGrammarPool *grammarPool; SAX2XMLReader* parser; try { grammarPool = new XMLGrammarPoolImpl(XMLPlatformUtils::fgMemoryManager); parser = XMLReaderFactory::createXMLReader(XMLPlatformUtils::fgMemoryManager, grammarPool); parser->setFeature(XMLUni::fgSAX2CoreNameSpaces, true); parser->setFeature(XMLUni::fgXercesSchema, true); parser->setFeature(XMLUni::fgXercesSchemaFullChecking, schemaFullChecking); parser->setFeature(XMLUni::fgSAX2CoreNameSpacePrefixes, false); parser->setFeature(XMLUni::fgSAX2CoreValidation, true); parser->setFeature(XMLUni::fgXercesDynamic, true); parser->setProperty(XMLUni::fgXercesScannerName, (void *)XMLUni::fgSGXMLScanner); SCMPrintHandler handler; parser->setErrorHandler(&handler); bool more = true; bool parsedOneSchemaOkay = false; XERCES_STD_QUALIFIER ifstream fin; // the input is a list file if (doList) fin.open(argV[argInd]); if (fin.fail()) { XERCES_STD_QUALIFIER cerr <<"Cannot open the list file: " << argV[argInd] << XERCES_STD_QUALIFIER endl; return 3; } while (more) { char fURI[1000]; //initialize the array to zeros memset(fURI,0,sizeof(fURI)); if (doList) { if (! fin.eof() ) { fin.getline (fURI, sizeof(fURI)); if (!*fURI) continue; else { xsdFile = fURI; XERCES_STD_QUALIFIER cerr << "==Parsing== " << xsdFile << XERCES_STD_QUALIFIER endl; } } else break; } else { xsdFile = argV[argInd]; more = false; } parser->loadGrammar(xsdFile, Grammar::SchemaGrammarType, true); if (handler.getSawErrors()) { handler.resetErrors(); } else { parsedOneSchemaOkay = true; } } if (parsedOneSchemaOkay) { XERCES_STD_QUALIFIER cout << "********** Printing out information from Schema **********" << "\n\n"; bool updatedXSModel; XSModel *xsModel = grammarPool->getXSModel(updatedXSModel); if (xsModel) { StringList *namespaces = xsModel->getNamespaces(); for (unsigned i = 0; i < namespaces->size(); i++) { XERCES_STD_QUALIFIER cout << "Processing Namespace: "; const XMLCh *nameSpace = namespaces->elementAt(i); if (nameSpace && *nameSpace) XERCES_STD_QUALIFIER cout << StrX(nameSpace); XERCES_STD_QUALIFIER cout << "\n============================================" << XERCES_STD_QUALIFIER endl << XERCES_STD_QUALIFIER endl; processElements(xsModel->getComponentsByNamespace(XSConstants::ELEMENT_DECLARATION, nameSpace)); processTypeDefinitions(xsModel->getComponentsByNamespace(XSConstants::TYPE_DEFINITION, nameSpace)); } } else { XERCES_STD_QUALIFIER cout << "No XSModel to print" << "\n\n"; } } else { XERCES_STD_QUALIFIER cout << "Did not parse a schema document cleanly so not printing Schema for Schema XSModel information"; } XERCES_STD_QUALIFIER cout << XERCES_STD_QUALIFIER endl; } catch (const OutOfMemoryException&) { XERCES_STD_QUALIFIER cerr << "OutOfMemoryException during parsing: '" << xsdFile << "'\n" << XERCES_STD_QUALIFIER endl; errorCode = 6; } catch (const XMLException& e) { XERCES_STD_QUALIFIER cerr << "\nError during parsing: '" << xsdFile << "'\n" << "Exception message is: \n" << StrX(e.getMessage()) << XERCES_STD_QUALIFIER endl; errorCode = 4; } catch (...) { XERCES_STD_QUALIFIER cerr << "\nUnexpected exception during parsing: '" << xsdFile << "'\n" << XERCES_STD_QUALIFIER endl; errorCode = 5; } delete parser; delete grammarPool; XMLPlatformUtils::Terminate(); return errorCode; }