/**
* @param parentElement
* @param childElement
* @param severity
*/
private void reportMinOccurenceViolation(
Element parentElement, ElementOccurrenceResult result, int severity) {
ISchemaElement childElement = result.getSchemaElement();
String allowedOccurrences = new Integer(result.getAllowedOccurrences()).toString();
String message =
NLS.bind(
MDECoreMessages.ExtensionsErrorReporter_minOccurrence,
new String[] {allowedOccurrences, childElement.getName()});
report(message, getLine(parentElement), severity, MDEMarkerFactory.CAT_FATAL);
}
private void computeAllowedElements(ISchemaCompositor compositor, HashSet elementSet) {
ISchemaObject[] children = compositor.getChildren();
for (int i = 0; i < children.length; i++) {
ISchemaObject child = children[i];
if (child instanceof ISchemaObjectReference) {
ISchemaObjectReference ref = (ISchemaObjectReference) child;
ISchemaElement refElement = (ISchemaElement) ref.getReferencedObject();
if (refElement != null) elementSet.add(refElement.getName());
} else if (child instanceof ISchemaCompositor) {
computeAllowedElements((ISchemaCompositor) child, elementSet);
}
}
}
private void validateExistingExtensionAttributes(
Element element, NamedNodeMap attrs, ISchemaElement schemaElement) {
for (int i = 0; i < attrs.getLength(); i++) {
Attr attr = (Attr) attrs.item(i);
ISchemaAttribute attInfo = schemaElement.getAttribute(attr.getName());
if (attInfo == null) {
HashSet allowedElements = new HashSet();
computeAllowedElements(schemaElement.getType(), allowedElements);
if (allowedElements.contains(attr.getName())) {
validateJavaAttribute(element, attr);
} else {
int flag = CompilerFlags.getFlag(fProject, CompilerFlags.P_UNKNOWN_ATTRIBUTE);
if (flag != CompilerFlags.IGNORE) reportUnknownAttribute(element, attr.getName(), flag);
}
} else {
validateExtensionAttribute(element, attr, attInfo);
}
}
}
private void validateInternalExtensionAttribute(Element element, ISchemaElement schemaElement) {
int severity = CompilerFlags.getFlag(fProject, CompilerFlags.P_INTERNAL);
if (severity == CompilerFlags.IGNORE) return;
if (schemaElement instanceof ISchemaRootElement) {
ISchemaRootElement rootElement = (ISchemaRootElement) schemaElement;
String epid = schemaElement.getSchema().getPluginId();
String pid = fModel.getMonitorBase().getId();
if (epid == null || pid == null) return;
if (rootElement.isInternal() && !epid.equals(pid)) {
String point = element.getAttribute("point"); // $NON-NLS-1$
if (point == null) return; // should never come to this...
report(
NLS.bind(MDECoreMessages.Builders_Manifest_internal_rootElement, point),
getLine(element, "point"),
severity,
MDEMarkerFactory.CAT_DEPRECATION); // $NON-NLS-1$
}
}
}
private void validateRequiredExtensionAttributes(Element element, ISchemaElement schemaElement) {
int severity = CompilerFlags.getFlag(fProject, CompilerFlags.P_NO_REQUIRED_ATT);
if (severity == CompilerFlags.IGNORE) return;
ISchemaAttribute[] attInfos = schemaElement.getAttributes();
for (int i = 0; i < attInfos.length; i++) {
ISchemaAttribute attInfo = attInfos[i];
if (attInfo.getUse() == ISchemaAttribute.REQUIRED) {
boolean found = element.getAttributeNode(attInfo.getName()) != null;
if (!found && attInfo.getKind() == IMetaAttribute.JAVA) {
NodeList children = element.getChildNodes();
for (int j = 0; j < children.getLength(); j++) {
if (attInfo.getName().equals(children.item(j).getNodeName())) {
found = true;
break;
}
}
}
if (!found) {
reportMissingRequiredAttribute(element, attInfo.getName(), severity);
}
}
}
}
protected void validateElement(Element element, ISchema schema, boolean isTopLevel) {
String elementName = element.getNodeName();
ISchemaElement schemaElement = schema.findElement(elementName);
// Validate element occurrence violations
if ((schemaElement != null) && (schemaElement.getType() instanceof ISchemaComplexType)) {
validateMaxElementMult(element, schemaElement);
validateMinElementMult(element, schemaElement);
}
ISchemaElement parentSchema = null;
if (!"extension".equals(elementName)) { // $NON-NLS-1$
Node parent = element.getParentNode();
parentSchema = schema.findElement(parent.getNodeName());
} else if (isTopLevel == false) {
// This is an "extension" element; but, not a top level one.
// It is nested within another "extension" element somewhere
// e.g. "extension" element is a child element of another element
// that is not a "plugin" elment
// element
// Report illegal element
int severity = CompilerFlags.getFlag(fProject, CompilerFlags.P_UNKNOWN_ELEMENT);
reportIllegalElement(element, severity);
return;
}
if (parentSchema != null) {
int severity = CompilerFlags.getFlag(fProject, CompilerFlags.P_UNKNOWN_ELEMENT);
if (severity != CompilerFlags.IGNORE) {
HashSet allowedElements = new HashSet();
computeAllowedElements(parentSchema.getType(), allowedElements);
if (!allowedElements.contains(elementName)) {
reportIllegalElement(element, severity);
return;
}
}
}
if (schemaElement == null && parentSchema != null) {
ISchemaAttribute attr = parentSchema.getAttribute(elementName);
if (attr != null && attr.getKind() == IMetaAttribute.JAVA) {
if (attr.isDeprecated())
reportDeprecatedAttribute(element, element.getAttributeNode("class")); // $NON-NLS-1$
validateJavaAttribute(element, element.getAttributeNode("class")); // $NON-NLS-1$
}
} else {
if (schemaElement != null) {
validateRequiredExtensionAttributes(element, schemaElement);
validateExistingExtensionAttributes(element, element.getAttributes(), schemaElement);
validateInternalExtensionAttribute(element, schemaElement);
if (schemaElement.isDeprecated()) {
if (schemaElement instanceof ISchemaRootElement)
reportDeprecatedRootElement(
element, ((ISchemaRootElement) schemaElement).getDeprecatedSuggestion());
else reportDeprecatedElement(element);
}
if (schemaElement.hasTranslatableContent()) validateTranslatableElementContent(element);
// Bug 213457 - look up elements based on the schema in which the parent is found
schema = schemaElement.getSchema();
}
NodeList children = element.getChildNodes();
for (int i = 0; i < children.getLength(); i++) {
validateElement((Element) children.item(i), schema, false);
}
}
}