// ---------------------------------------------------------------------------
// Program entry point
// ---------------------------------------------------------------------------
int main(int argC, char* argV[])
{
// Initialize the XML4C system
try
{
XMLPlatformUtils::Initialize();
}
catch (const XMLException& toCatch)
{
XERCES_STD_QUALIFIER cerr << "Error during initialization! Message:\n"
<< StrX(toCatch.getMessage()) << XERCES_STD_QUALIFIER endl;
return 1;
}
// Check command line and extract arguments.
if (argC < 2)
{
usage();
XMLPlatformUtils::Terminate();
return 1;
}
// We only have one required parameter, which is the file to process
if ((argC != 2) || (*(argV[1]) == '-'))
{
usage();
XMLPlatformUtils::Terminate();
return 1;
}
const char* xmlFile = argV[1];
SAXParser::ValSchemes valScheme = SAXParser::Val_Auto;
//
// Create a DTD validator to be used for our validation work. Then create
// a SAX parser object and pass it our validator. Then, according to what
// we were told on the command line, set it to validate or not. He owns
// the validator, so we have to allocate it.
//
int errorCount = 0;
DTDValidator* valToUse = new DTDValidator;
SAXParser* parser = new SAXParser(valToUse);
parser->setValidationScheme(valScheme);
//
// Get the starting time and kick off the parse of the indicated
// file. Catch any exceptions that might propogate out of it.
//
int errorCode = 0;
try
{
parser->parse(xmlFile);
errorCount = parser->getErrorCount();
}
catch (const OutOfMemoryException&)
{
XERCES_STD_QUALIFIER cerr << "OutOfMemoryException" << XERCES_STD_QUALIFIER endl;
errorCode = 5;
}
catch (const XMLException& e)
{
XERCES_STD_QUALIFIER cerr << "\nError during parsing: '" << xmlFile << "'\n"
<< "Exception message is: \n"
<< StrX(e.getMessage()) << "\n" << XERCES_STD_QUALIFIER endl;
errorCode = 4;
}
if(errorCode) {
XMLPlatformUtils::Terminate();
return errorCode;
}
if (!errorCount) {
//
// Now we will get an enumerator for the element pool from the validator
// and enumerate the elements, printing them as we go. For each element
// we get an enumerator for its attributes and print them also.
//
DTDGrammar* grammar = (DTDGrammar*) valToUse->getGrammar();
NameIdPoolEnumerator<DTDElementDecl> elemEnum = grammar->getElemEnumerator();
if (elemEnum.hasMoreElements())
{
XERCES_STD_QUALIFIER cout << "\nELEMENTS:\n----------------------------\n";
while(elemEnum.hasMoreElements())
{
const DTDElementDecl& curElem = elemEnum.nextElement();
XERCES_STD_QUALIFIER cout << " Name: " << StrX(curElem.getFullName()) << "\n";
XERCES_STD_QUALIFIER cout << " Content Model: "
<< StrX(curElem.getFormattedContentModel())
<< "\n";
// Get an enumerator for this guy's attributes if any
if (curElem.hasAttDefs())
{
XERCES_STD_QUALIFIER cout << " Attributes:\n";
XMLAttDefList& attList = curElem.getAttDefList();
for (unsigned int i=0; i<attList.getAttDefCount(); i++)
{
const XMLAttDef& curAttDef = attList.getAttDef(i);
XERCES_STD_QUALIFIER cout << " Name:" << StrX(curAttDef.getFullName())
<< ", Type: ";
// Get the type and display it
const XMLAttDef::AttTypes type = curAttDef.getType();
switch(type)
{
case XMLAttDef::CData :
XERCES_STD_QUALIFIER cout << "CDATA";
break;
case XMLAttDef::ID :
XERCES_STD_QUALIFIER cout << "ID";
break;
case XMLAttDef::IDRef :
case XMLAttDef::IDRefs :
XERCES_STD_QUALIFIER cout << "IDREF(S)";
break;
case XMLAttDef::Entity :
case XMLAttDef::Entities :
XERCES_STD_QUALIFIER cout << "ENTITY(IES)";
break;
case XMLAttDef::NmToken :
case XMLAttDef::NmTokens :
XERCES_STD_QUALIFIER cout << "NMTOKEN(S)";
break;
case XMLAttDef::Notation :
XERCES_STD_QUALIFIER cout << "NOTATION";
break;
case XMLAttDef::Enumeration :
XERCES_STD_QUALIFIER cout << "ENUMERATION";
break;
default:
break;
}
XERCES_STD_QUALIFIER cout << "\n";
}
}
XERCES_STD_QUALIFIER cout << XERCES_STD_QUALIFIER endl;
}
}
else
{
XERCES_STD_QUALIFIER cout << "The validator has no elements to display\n" << XERCES_STD_QUALIFIER endl;
}
}
else
XERCES_STD_QUALIFIER cout << "\nErrors occurred, no output available\n" << XERCES_STD_QUALIFIER endl;
//
// Delete the parser itself. Must be done prior to calling Terminate, below.
//
delete parser;
// And call the termination method
XMLPlatformUtils::Terminate();
if (errorCount > 0)
return 4;
else
return 0;
}
void XSModel::addGrammarToXSModel(XSNamespaceItem* namespaceItem)
{
// Loop through top-level attribute declarations in the grammar...
RefHashTableOf<XMLAttDef>* attDeclRegistry = namespaceItem->fGrammar->getAttributeDeclRegistry();
if(attDeclRegistry) {
RefHashTableOfEnumerator<XMLAttDef> attrEnum = RefHashTableOfEnumerator<XMLAttDef> (attDeclRegistry, false, fMemoryManager);
while (attrEnum.hasMoreElements())
{
XSAttributeDeclaration* xsAttrDecl = fObjFactory->addOrFind
(
(SchemaAttDef*) &(attrEnum.nextElement()), this
);
addComponentToNamespace
(
namespaceItem, xsAttrDecl, XSConstants::ATTRIBUTE_DECLARATION - 1
);
} // end of attribute loop
}
// Loop through top-level elements in the grammar...
RefHash3KeysIdPoolEnumerator<SchemaElementDecl> elemEnum = namespaceItem->fGrammar->getElemEnumerator();
while (elemEnum.hasMoreElements())
{
SchemaElementDecl& curElem = elemEnum.nextElement();
if (curElem.getEnclosingScope() == Grammar::TOP_LEVEL_SCOPE)
{
XSElementDeclaration* xsElemDecl = fObjFactory->addOrFind
(
&curElem, this
);
addComponentToNamespace
(
namespaceItem, xsElemDecl, XSConstants::ELEMENT_DECLARATION -1
);
}
} // end of element loop
// Now loop through top-level User Defined simple type definitions in the grammar...
DVHashTable* dvHT = namespaceItem->fGrammar->getDatatypeRegistry()->getUserDefinedRegistry();
if (dvHT)
{
RefHashTableOfEnumerator<DatatypeValidator> simpleUserEnum = RefHashTableOfEnumerator<DatatypeValidator> (dvHT, false, fMemoryManager);
while (simpleUserEnum.hasMoreElements())
{
DatatypeValidator& curSimple = simpleUserEnum.nextElement();
if (!curSimple.getAnonymous())
{
addComponentToNamespace
(
namespaceItem
, fObjFactory->addOrFind(&curSimple, this)
, XSConstants::TYPE_DEFINITION - 1
);
}
} // end of simple User loop
}
// Loop through top-level COMPLEX type definitions in the grammar...
RefHashTableOf<ComplexTypeInfo>* complexTypeRegistry = namespaceItem->fGrammar->getComplexTypeRegistry();
if(complexTypeRegistry) {
RefHashTableOfEnumerator<ComplexTypeInfo> complexEnum = RefHashTableOfEnumerator<ComplexTypeInfo> (complexTypeRegistry, false, fMemoryManager);
while (complexEnum.hasMoreElements())
{
ComplexTypeInfo& curComplex = complexEnum.nextElement();
if (!curComplex.getAnonymous())
{
addComponentToNamespace
(
namespaceItem
, fObjFactory->addOrFind(&curComplex, this)
, XSConstants::TYPE_DEFINITION - 1
);
}
} // end of type definition loop
}
// Loop through top-level attribute group definitions in the grammar...
RefHashTableOf<XercesAttGroupInfo>* attGroupInfoRegistry = namespaceItem->fGrammar->getAttGroupInfoRegistry();
if(attGroupInfoRegistry) {
RefHashTableOfEnumerator<XercesAttGroupInfo> attrGroupEnum = RefHashTableOfEnumerator<XercesAttGroupInfo> (attGroupInfoRegistry, false, fMemoryManager);
while (attrGroupEnum.hasMoreElements())
{
addComponentToNamespace
(
namespaceItem
, fObjFactory->createXSAttGroupDefinition
(
&(attrGroupEnum.nextElement()), this
)
, XSConstants::ATTRIBUTE_GROUP_DEFINITION - 1
);
} // end of attribute group loop
}
// Loop through top-level model group definitions in the grammar...
RefHashTableOf<XercesGroupInfo>* groupInfoRegistry = namespaceItem->fGrammar->getGroupInfoRegistry();
if(groupInfoRegistry) {
RefHashTableOfEnumerator<XercesGroupInfo> modelGroupEnum = RefHashTableOfEnumerator<XercesGroupInfo> (groupInfoRegistry, false, fMemoryManager);
while (modelGroupEnum.hasMoreElements())
{
addComponentToNamespace
(
namespaceItem
, fObjFactory->createXSModelGroupDefinition
(
&(modelGroupEnum.nextElement()), this
)
, XSConstants::MODEL_GROUP_DEFINITION - 1
);
} // end of model group loop
}
// Loop through notations in the grammar...
NameIdPoolEnumerator<XMLNotationDecl> notationEnum = namespaceItem->fGrammar->getNotationEnumerator();
while (notationEnum.hasMoreElements())
{
addComponentToNamespace
(
namespaceItem
, fObjFactory->addOrFind(&(notationEnum.nextElement()), this)
, XSConstants::NOTATION_DECLARATION - 1
);
} // end of notation loop
// Loop through annotations in the grammar...
// As annotations are already created as XSAnnotations no need to create them
// or store them in the XercesToXSMap.
XSAnnotation* annot = namespaceItem->fGrammar->getAnnotation();
while (annot)
{
fXSAnnotationList->addElement(annot);
namespaceItem->fXSAnnotationList->addElement(annot);
addComponentToIdVector(annot, XSConstants::ANNOTATION -1);
annot = annot->getNext();
} // end of annotation loop
}
void DTDValidator::preContentValidation(bool
#if defined(MATCH_DEBUG)
reuseGrammar
#endif
,bool validateDefAttr)
{
//
// Lets enumerate all of the elements in the element decl pool
// and put out an error for any that did not get declared.
// We also check all of the attributes as well.
//
NameIdPoolEnumerator<DTDElementDecl> elemEnum = fDTDGrammar->getElemEnumerator();
fDTDGrammar->setValidated(true);
while (elemEnum.hasMoreElements())
{
const DTDElementDecl& curElem = elemEnum.nextElement();
const DTDElementDecl::CreateReasons reason = curElem.getCreateReason();
//
// See if this element decl was ever marked as declared. If
// not, then put out an error. In some cases its just
// a warning, such as being referenced in a content model.
//
if (reason != XMLElementDecl::Declared)
{
if (reason == XMLElementDecl::AttList)
{
getScanner()->emitError
(
XMLErrs::UndeclaredElemInAttList
, curElem.getFullName()
);
}
else if (reason == XMLElementDecl::AsRootElem)
{
// It's ok that the root element is not declared in the DTD
/*
emitError
(
XMLValid::UndeclaredElemInDocType
, curElem.getFullName()
);*/
}
else if (reason == XMLElementDecl::InContentModel)
{
getScanner()->emitError
(
XMLErrs::UndeclaredElemInCM
, curElem.getFullName()
);
}
else
{
#if defined(MATCH_DEBUG)
if(reuseGrammar && reason == XMLElementDecl::JustFaultIn){
}
else
ThrowXMLwithMemMgr(RuntimeException, XMLExcepts::DTD_UnknownCreateReason, getScanner()->getMemoryManager());
#endif
}
}
//
// Check all of the attributes of the current element.
// We check for:
//
// 1) Multiple ID attributes
// 2) That all of the default values of attributes are
// valid for their type.
// 3) That for any notation types, that their lists
// of possible values refer to declared notations.
//
// 4) XML1.0(3rd edition)
//
// Validity constraint: One Notation Per Element Type
// An element type MUST NOT have more than one NOTATION attribute specified.
//
// Validity constraint: No Notation on Empty Element
// For compatibility, an attribute of type NOTATION MUST NOT be declared on an element declared EMPTY.
//
// Validity constraint: No Duplicate Tokens
// The notation names in a single NotationType attribute declaration, as well as
// the NmTokens in a single Enumeration attribute declaration, MUST all be distinct.
//
XMLAttDefList& attDefList = curElem.getAttDefList();
bool seenId = false;
bool seenNOTATION = false;
bool elemEmpty = (curElem.getModelType() == DTDElementDecl::Empty);
for(XMLSize_t i=0; i<attDefList.getAttDefCount(); i++)
{
const XMLAttDef& curAttDef = attDefList.getAttDef(i);
if (curAttDef.getType() == XMLAttDef::ID)
{
if (seenId)
{
emitError
(
XMLValid::MultipleIdAttrs
, curElem.getFullName()
);
break;
}
seenId = true;
}
else if (curAttDef.getType() == XMLAttDef::Notation)
{
if (seenNOTATION)
{
emitError
(
XMLValid::ElemOneNotationAttr
, curElem.getFullName()
);
break;
}
seenNOTATION = true;
// no notation attribute on empty element
if (elemEmpty)
{
emitError
(
XMLValid::EmptyElemNotationAttr
, curElem.getFullName()
, curAttDef.getFullName()
);
break;
}
//go through enumeration list to check
// distinct
// notation declaration
if (curAttDef.getEnumeration())
{
checkTokenList(curAttDef, true);
}
}
else if (curAttDef.getType() == XMLAttDef::Enumeration )
{
//go through enumeration list to check
// distinct only
if (curAttDef.getEnumeration())
{
checkTokenList(curAttDef, false);
}
}
// If it has a default/fixed value, then validate it
if (validateDefAttr && curAttDef.getValue())
{
validateAttrValue
(
&curAttDef
, curAttDef.getValue()
, true
, &curElem
);
}
}
}
//
// And enumerate all of the general entities. If any of them
// reference a notation, then make sure the notation exists.
//
NameIdPoolEnumerator<DTDEntityDecl> entEnum = fDTDGrammar->getEntityEnumerator();
while (entEnum.hasMoreElements())
{
const DTDEntityDecl& curEntity = entEnum.nextElement();
if (!curEntity.getNotationName())
continue;
// It has a notation name, so look it up
if (!fDTDGrammar->getNotationDecl(curEntity.getNotationName()))
{
emitError
(
XMLValid::NotationNotDeclared
, curEntity.getNotationName()
);
}
}
}
