/*******************************************************************************
* Copyright (c) 2001, 2010 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
*******************************************************************************/
package org.eclipse.wst.dtd.core.internal.emf.util;
import java.util.Enumeration;
import java.util.Iterator;
import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.ecore.EEnumLiteral;
import org.eclipse.emf.ecore.EPackage;
import org.eclipse.emf.ecore.EcorePackage;
import org.eclipse.emf.ecore.resource.ResourceSet;
import org.eclipse.wst.common.uriresolver.internal.provisional.URIResolver;
import org.eclipse.wst.common.uriresolver.internal.provisional.URIResolverPlugin;
import org.eclipse.wst.dtd.core.internal.DTDCoreMessages;
import org.eclipse.wst.dtd.core.internal.emf.DTDAnyContent;
import org.eclipse.wst.dtd.core.internal.emf.DTDAttribute;
import org.eclipse.wst.dtd.core.internal.emf.DTDBasicType;
import org.eclipse.wst.dtd.core.internal.emf.DTDBasicTypeKind;
import org.eclipse.wst.dtd.core.internal.emf.DTDDefaultKind;
import org.eclipse.wst.dtd.core.internal.emf.DTDElement;
import org.eclipse.wst.dtd.core.internal.emf.DTDElementReferenceContent;
import org.eclipse.wst.dtd.core.internal.emf.DTDEmptyContent;
import org.eclipse.wst.dtd.core.internal.emf.DTDEntity;
import org.eclipse.wst.dtd.core.internal.emf.DTDEntityReferenceContent;
import org.eclipse.wst.dtd.core.internal.emf.DTDEnumGroupKind;
import org.eclipse.wst.dtd.core.internal.emf.DTDEnumerationType;
import org.eclipse.wst.dtd.core.internal.emf.DTDExternalEntity;
import org.eclipse.wst.dtd.core.internal.emf.DTDFactory;
import org.eclipse.wst.dtd.core.internal.emf.DTDFile;
import org.eclipse.wst.dtd.core.internal.emf.DTDGroupContent;
import org.eclipse.wst.dtd.core.internal.emf.DTDGroupKind;
import org.eclipse.wst.dtd.core.internal.emf.DTDInternalEntity;
import org.eclipse.wst.dtd.core.internal.emf.DTDNotation;
import org.eclipse.wst.dtd.core.internal.emf.DTDOccurrenceType;
import org.eclipse.wst.dtd.core.internal.emf.DTDPCDataContent;
import org.eclipse.wst.dtd.core.internal.emf.DTDParameterEntityReference;
import org.eclipse.wst.dtd.core.internal.emf.DTDType;
import org.eclipse.wst.dtd.core.internal.emf.impl.DTDFactoryImpl;
import org.eclipse.wst.dtd.core.internal.saxparser.AttNode;
import org.eclipse.wst.dtd.core.internal.saxparser.Attlist;
import org.eclipse.wst.dtd.core.internal.saxparser.CMBasicNode;
import org.eclipse.wst.dtd.core.internal.saxparser.CMGroupNode;
import org.eclipse.wst.dtd.core.internal.saxparser.CMNode;
import org.eclipse.wst.dtd.core.internal.saxparser.CMNodeType;
import org.eclipse.wst.dtd.core.internal.saxparser.CMReferenceNode;
import org.eclipse.wst.dtd.core.internal.saxparser.CMRepeatableNode;
import org.eclipse.wst.dtd.core.internal.saxparser.DTD;
import org.eclipse.wst.dtd.core.internal.saxparser.DTDSaxArtifactVisitor;
import org.eclipse.wst.dtd.core.internal.saxparser.ElementDecl;
import org.eclipse.wst.dtd.core.internal.saxparser.EntityDecl;
import org.eclipse.wst.dtd.core.internal.saxparser.ErrorMessage;
import org.eclipse.wst.dtd.core.internal.saxparser.NotationDecl;
public class DTDModelBuilder extends DTDSaxArtifactVisitor {
DTD dtd;
DTDUtil dtdUtil;
DTDFile dtdFile;
ResourceSet resources;
public DTDModelBuilder(ResourceSet resources, DTDUtil dtdUtil, DTD dtd, DTDFile dtdFile) {
this.resources = resources;
this.dtdUtil = dtdUtil;
this.dtd = dtd;
this.dtdFile = dtdFile;
}
public DTDFactoryImpl getFactory() {
return (DTDFactoryImpl) dtdUtil.getFactory();
}
public DTDFile getDTDFile() {
return dtdFile;
}
public void visitDTD(DTD dtd) {
super.visitDTD(dtd);
// - 2nd pass -
// do final processing for Attlists and adding contentModel
addAttlistAndContentModel(dtd, dtdFile);
}
public void visitElementDecl(ElementDecl element) {
// Element might have been added earlier because it is referenced
String declName = element.getNodeName();
// System.out.println("process ElementDecl:" + declName );
DTDElement dtdelement = (DTDElement) dtdUtil.getElementPool().get(declName);
if (dtdelement == null) {
// System.out.println("process ElementDecl - not found - create"
// );
dtdelement = getFactory().createDTDElement();
dtdelement.setName(declName);
dtdFile.getDTDObject().add(dtdelement);
dtdUtil.getElementPool().put(declName, dtdelement);
}
super.visitElementDecl(element);
}
public void visitNotationDecl(NotationDecl notation) {
// Notation might have been added earlier because it is referenced
// by an entity
DTDNotation dtdnot = dtdFile.findNotation(notation.getNodeName());
if (dtdnot == null) {
dtdnot = getFactory().createDTDNotation();
dtdFile.getDTDObject().add(dtdnot);
}
dtdnot.setName(notation.getNodeName());
if (notation.getSystemId() != null)
dtdnot.setSystemID(notation.getSystemId());
if (notation.getPublicId() != null)
dtdnot.setPublicID(notation.getPublicId());
if (notation.getComment() != null)
dtdnot.setComment(notation.getComment());
if (notation.getErrorMessage() != null) {
addErrorMessage(notation.getErrorMessage(), dtdnot);
}
super.visitNotationDecl(notation);
}
public void visitParameterEntityReferenceDecl(EntityDecl entity) {
// This is a parameter entity reference.
// Add the link to the real entity that it references
DTDParameterEntityReference parmEntRef = getFactory().createDTDParameterEntityReference();
dtdFile.getDTDObject().add(parmEntRef);
String entityName = entity.getNodeName();
// Add the reference to the DTDEntity
DTDEntity dtdentity = getDTDFile().findEntity(entityName);
if (dtdentity != null) {
parmEntRef.setEntity(dtdentity);
}
if (entity.getErrorMessage() != null) {
addErrorMessage(entity.getErrorMessage(), dtdentity);
}
// System.out.println("adding PE reference: " + declName);
super.visitParameterEntityReferenceDecl(entity);
}
public void visitExternalEntityDecl(EntityDecl entity) {
DTDEntity dtdEntity = createDTDEntity(entity);
// System.out.println("adding entity: " + declName);
DTDExternalEntity extEntity = getFactory().createDTDExternalEntity();
dtdEntity.setContent(extEntity);
finishExternalEntity(extEntity, entity);
// System.out.println(" ext entity toMof: " );
if (dtdEntity.isParameterEntity()) {
dtdUtil.getPEPool().put("%" + entity.getNodeName() + ";", dtdEntity); //$NON-NLS-1$ //$NON-NLS-2$
}
super.visitExternalEntityDecl(entity);
}
public void visitInternalEntityDecl(EntityDecl entity) {
DTDEntity dtdEntity = createDTDEntity(entity);
DTDInternalEntity intEntity = getFactory().createDTDInternalEntity();
dtdEntity.setContent(intEntity);
intEntity.setValue(entity.getValue());
// System.out.println(" int entity toMof: " );
if (dtdEntity.isParameterEntity()) {
dtdUtil.getPEPool().put("%" + entity.getNodeName() + ";", dtdEntity); //$NON-NLS-1$ //$NON-NLS-2$
}
super.visitInternalEntityDecl(entity);
}
private void addAttlistAndContentModel(DTD dtd, DTDFile dFile) {
// System.out.println("addAttListAndCotentModel - dtd:" +
// dtd.getName());
Enumeration en = dtd.externalElements();
while (en.hasMoreElements()) {
Object e = en.nextElement();
if (e instanceof ElementDecl) {
DTDElement dtdelement = (DTDElement) dtdUtil.getElementPool().get(((ElementDecl) e).getNodeName());
if (dtdelement == null) {
dtdelement = getFactory().createDTDElement();
dtdFile.getDTDObject().add(dtdelement);
}
finishElementDecl(dtdelement, (ElementDecl) e);
}
else if (e instanceof Attlist) {
processAttList((Attlist) e);
}
}
}
private void processAttList(Attlist attList) {
DTDElement e = (DTDElement) dtdUtil.getElementPool().get(attList.getNodeName());
if (e != null) {
// Element has been added. Add the attributes
// System.out.println(" processAttlist - adding Attlist:" +
// attList.getNodeName());
createAttributes(e, attList);
}
else {
// System.out.println("!!!!!!!!! element is null ");
}
}
// /////////////////////////////////////////////////////////////
//
// Methods for finishing the import of a DTDExternalEntity
//
// /////////////////////////////////////////////////////////////
void finishExternalEntity(DTDExternalEntity extEntity, EntityDecl entityDecl) {
updateSystemID(extEntity, entityDecl);
extEntity.setPublicID(entityDecl.getPublicId());
String notationName = entityDecl.getNotationName();
if (notationName != null) {
DTDNotation dtdNotation = createOrFindNotation(extEntity, notationName, true);
extEntity.setNotation(dtdNotation);
}
}
public DTDNotation createOrFindNotation(DTDExternalEntity extEntity, String name, boolean create) {
DTDNotation aNotation = extEntity.getDTDEntity().getDTDFile().findNotation(name);
if (aNotation != null) {
return aNotation;
}
//
// Create a notation for the reference
//
if (create) {
aNotation = getFactory().createDTDNotation();
dtdFile.getDTDObject().add(aNotation);
aNotation.setName(name);
}
return aNotation;
}
/**
* The SystemID attribute is set to whatever the user enters e.g.
* com/ibm/b2b/xmimodels/xxx.dtd.xmi
*
* In the unparse() method, parse out the DTD file name from the classpath
* name. e.g. returns xxx.dtd
*/
private void updateSystemID(DTDExternalEntity extEntity, EntityDecl entityDecl) {
String systemId = entityDecl.getSystemId();
String publicId = entityDecl.getPublicId();
if (systemId != null) {
URIResolver idResolver = URIResolverPlugin.createResolver();
String uri = idResolver.resolve(dtd.getName(), publicId, systemId);
ExternalDTDModel ed = dtdUtil.getExternalDTDModel(resources, uri);
if (ed != null) {
DTDFile referenceDtdFile = ed.getExternalDTDFile();
extEntity.setEntityReferencedFromAnotherFile(referenceDtdFile);
extEntity.setSystemID(systemId);
}
else {
if (entityDecl.getErrorMessage() == null) {
ErrorMessage dtdError = new ErrorMessage();
dtdError.setErrorMessage(DTDCoreMessages._ERROR_INCL_FILE_LOAD_FAILURE + " '" + systemId + "'"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
addErrorMessage(dtdError, extEntity.getDTDEntity());
}
if (systemId != null) {
extEntity.setSystemID(systemId);
}
else {
extEntity.setSystemID(""); //$NON-NLS-1$
}
}
} // end of if ()
else {
// set the system id to be ""
extEntity.setSystemID(""); //$NON-NLS-1$
}
}
public DTDEntity createDTDEntity(EntityDecl entity) {
// create and do what we can to fill in some basic things
DTDEntity dtdEntity = getFactory().createDTDEntity();
dtdFile.getDTDObject().add(dtdEntity);
dtdEntity.setName(entity.getNodeName());
dtdEntity.setParameterEntity(entity.isParameter());
if (entity.getComment() != null) {
dtdEntity.setComment(entity.getComment());
}
if (entity.getErrorMessage() != null) {
addErrorMessage(entity.getErrorMessage(), dtdEntity);
}
return dtdEntity;
}
// /////////////////////////////////////////////////////////////
//
// Methods for finishing the import of a DTDElement
//
// /////////////////////////////////////////////////////////////
public void finishElementDecl(DTDElement dtdElement, ElementDecl ed) {
dtdElement.setName(ed.getNodeName());
CMNode cmNode = ed.getContentModelNode();
if (ed.getComment() != null) {
dtdElement.setComment(ed.getComment());
}
if (ed.getErrorMessage() != null) {
addErrorMessage(ed.getErrorMessage(), dtdElement);
}
if (cmNode instanceof CMBasicNode) {
CMBasicNode bn = (CMBasicNode) cmNode;
switch (bn.getType()) {
case CMNodeType.EMPTY :
DTDEmptyContent emptyContent = getFactory().createDTDEmptyContent();
dtdElement.setContent(emptyContent);
break;
case CMNodeType.ANY :
DTDAnyContent anyContent = getFactory().createDTDAnyContent();
dtdElement.setContent(anyContent);
break;
case CMNodeType.PCDATA :
DTDPCDataContent pcData = getFactory().createDTDPCDataContent();
dtdElement.setContent(pcData);
}
}
else if (cmNode instanceof CMReferenceNode) {
CMReferenceNode rn = (CMReferenceNode) cmNode;
if (rn.getType() == CMNodeType.ENTITY_REFERENCE) {
String entityName = rn.getName().trim();
DTDEntity anEntity = (DTDEntity) dtdUtil.getPEPool().get(entityName);
if (anEntity != null) {
//
// Create an DTDEntityReference and set its referenced
// element
//
DTDEntityReferenceContent enRef = getFactory().createDTDEntityReferenceContent();
enRef.setElementReferencedEntity(anEntity);
DTDOccurrenceType occurrenceType = DTDOccurrenceType.get(computeMofOccurrence(rn));
enRef.setOccurrence(occurrenceType);
dtdElement.setContent(enRef);
}
else { // create default content
DTDEmptyContent emptyContent = getFactory().createDTDEmptyContent();
dtdElement.setContent(emptyContent);
}
}
else {
//
// Find the real element for this element references
// If the real element does not yet exist, create it
//
DTDElement anElement = createOrFindElement(rn.getName(), dtdElement);
//
// Create an DTDElementReference and set its referenced
// element
//
DTDElementReferenceContent elemRef = getFactory().createDTDElementReferenceContent();
elemRef.setReferencedElement(anElement);
DTDOccurrenceType occurrenceType = DTDOccurrenceType.get(computeMofOccurrence(rn));
elemRef.setOccurrence(occurrenceType);
// setContent to DTDElementReference
dtdElement.setContent(elemRef);
}
}
else if (cmNode instanceof CMGroupNode) {
CMGroupNode grpNode = (CMGroupNode) cmNode;
DTDGroupContent groupContent = getFactory().createDTDGroupContent();
DTDGroupKind groupKind = DTDGroupKind.get(computeMofGroupKind(grpNode.getGroupKind()));
groupContent.setGroupKind(groupKind);
DTDOccurrenceType occurrenceType = DTDOccurrenceType.get(computeMofOccurrence(grpNode));
groupContent.setOccurrence(occurrenceType);
// just use the locator for the element as the closest guess
processGroupContent(groupContent, grpNode);
dtdElement.setContent(groupContent);
}
else if (cmNode == null) {
// bad thing happened here, just create a pcdata
DTDEmptyContent emptyContent = getFactory().createDTDEmptyContent();
dtdElement.setContent(emptyContent);
}
}
/**
* Add a new group to the current group
*
* @param parent -
* the parent node for this group element
* @param op1Node -
* the group e.g. (a,b)
* @param op2Node -
* set only if called by processCM1op e.g. (a,b)+
*/
void processGroupContent(DTDGroupContent parent, CMGroupNode grpNode) {
Enumeration children = grpNode.getChildren().elements();
DTDFactory factory = getFactory();
while (children.hasMoreElements()) {
CMNode cnode = (CMNode) children.nextElement();
if (cnode instanceof CMGroupNode) {
CMGroupNode gNode = (CMGroupNode) cnode;
DTDGroupContent groupContent = factory.createDTDGroupContent();
DTDGroupKind groupKind = DTDGroupKind.get(computeMofGroupKind(gNode.getGroupKind()));
groupContent.setGroupKind(groupKind);
DTDOccurrenceType occurrenceType = DTDOccurrenceType.get(computeMofOccurrence(gNode));
groupContent.setOccurrence(occurrenceType);
parent.getContent().add(groupContent);
processGroupContent(groupContent, gNode);
}
else if (cnode instanceof CMBasicNode) {
CMBasicNode n = (CMBasicNode) cnode;
if (n.getType() == CMNodeType.PCDATA) {
// Create a DTDPCDataContent for a leaf PCData node
//
DTDPCDataContent pcData = factory.createDTDPCDataContent();
// Add #PCDATA to the Group, i.e Mixed content model
parent.getContent().add(pcData);
}
}
else if (cnode instanceof CMReferenceNode) {
CMReferenceNode rn = (CMReferenceNode) cnode;
if (rn.getType() == CMNodeType.ELEMENT_REFERENCE) {
// System.out.println("CM Element Ref name: " +
// rn.getName());
//
// Create an DTDElementReference and set its referenced
// element
//
DTDElementReferenceContent elemRef = factory.createDTDElementReferenceContent();
//
// Find the real element for this element references
// If the real element does not yet exist, create it
//
DTDElement anElement = createOrFindElement(rn.getName(), elemRef);
elemRef.setReferencedElement(anElement);
DTDOccurrenceType occurrenceType = DTDOccurrenceType.get(computeMofOccurrence(rn));
elemRef.setOccurrence(occurrenceType);
// Add DTDElementReference to the Group
parent.getContent().add(elemRef);
}
else // PE Reference
{
String entityName = rn.getName().trim();
// System.out.println("CM PE Ref name: " + entityName);
DTDEntity anEntity = (DTDEntity) dtdUtil.getPEPool().get(entityName);
if (anEntity != null) {
//
// Create an DTDEntityReference and set its referenced
// element
//
DTDEntityReferenceContent enRef = factory.createDTDEntityReferenceContent();
enRef.setElementReferencedEntity(anEntity);
DTDOccurrenceType occurrenceType = DTDOccurrenceType.get(computeMofOccurrence(rn));
enRef.setOccurrence(occurrenceType);
// Add DTDEntityReference to the Group
parent.getContent().add(enRef);
}
}
}
}
}
/**
* Find the real element that is referenced by the current element
*/
private DTDElement createOrFindElement(String name, Object obj) {
// DTDElement aElement = getDTDFile().findElement(name);
DTDElement aElement = (DTDElement) dtdUtil.getElementPool().get(name);
if (aElement != null) {
return aElement;
}
String errorMsg = DTDCoreMessages._ERROR_UNDECLARED_ELEMENT_1; //$NON-NLS-1$
errorMsg += "\"" + name + "\""; //$NON-NLS-1$ //$NON-NLS-2$
errorMsg += DTDCoreMessages._UI_ERRORPART_UNDECLARED_ELEMENT_2; //$NON-NLS-1$
ErrorMessage dtdError = new ErrorMessage();
dtdError.setErrorMessage(errorMsg);
addErrorMessage(dtdError, obj);
// System.out.println(errorMsg);
// setDTDErrorMessage(errorMsg);
getDTDFile().setParseError(true);
//
// Create an empty element for the reference to make it valid
//
DTDFactory factory = getFactory();
DTDElement dtdelement = factory.createDTDElement();
dtdelement.setName(name);
DTDEmptyContent emptyContent = factory.createDTDEmptyContent();
dtdelement.setContent(emptyContent);
getDTDFile().getDTDObject().add(dtdelement);
dtdUtil.getElementPool().put(name, dtdelement);
return dtdelement;
}
/**
* Compute the MOF occurrence from the xml4j occurrence
*/
private int computeMofOccurrence(CMRepeatableNode rnode) {
int occurrence = rnode.getOccurrence();
int mofoccur = DTDOccurrenceType.ONE;
if (occurrence == CMNodeType.ZERO_OR_MORE) {
mofoccur = DTDOccurrenceType.ZERO_OR_MORE;
}
else if (occurrence == CMNodeType.ONE_OR_MORE) {
mofoccur = DTDOccurrenceType.ONE_OR_MORE;
}
else if (occurrence == CMNodeType.OPTIONAL) {
mofoccur = DTDOccurrenceType.OPTIONAL;
}
return mofoccur;
}
/**
* Compute the MOF model group from the xml4j model group
*/
private int computeMofGroupKind(int type) {
if (type == CMNodeType.GROUP_CHOICE) {
return DTDGroupKind.CHOICE;
}
else {
return DTDGroupKind.SEQUENCE;
}
}
// /////////////////////////////////////////////////////////////
//
// Methods for creating the attributes of a DTDElement
//
// /////////////////////////////////////////////////////////////
public void createAttributes(DTDElement element, Attlist attList) {
if (attList.getErrorMessage() != null) {
addErrorMessage(attList.getErrorMessage(), element);
}
for (int i = 0; i < attList.size(); i++) {
AttNode ad = attList.elementAt(i);
// DTDAttributeElement dtdAtt=
// getDTDAttributeElement(a.getName());
// only add the AttDef if it is not added yet
// ignore the dup AttDef as documented in the XML 1.0 specs
// if( dtdAtt==null)
addAttribute(element, ad);
}
}
/**
* Create a DTDAttribute from the xml4j attribute
*/
public void addAttribute(DTDElement dtdelement, AttNode ad) {
DTDAttribute dtdattr = getFactory().createDTDAttribute();
dtdelement.getDTDAttribute().add(dtdattr);
finishAttribute(dtdattr, ad);
}
// Stuff for populating attribute
public void finishAttribute(DTDAttribute dtdattr, AttNode attdef) {
boolean parseError = false;
if (attdef.name.startsWith("%")) { //$NON-NLS-1$
String peName = attdef.name.trim();
DTDEntity en = (DTDEntity) dtdUtil.getPEPool().get(peName);
if (en != null) {
dtdattr.setAttributeNameReferencedEntity(en);
}
}
dtdattr.setName(attdef.name);
int attrType = attdef.getDeclaredType();
if (attrType == AttNode.PEREFERENCE && attdef.type != null) {
String peName = attdef.type.trim();
DTDEntity en = (DTDEntity) dtdUtil.getPEPool().get(peName);
if (en != null) {
dtdattr.setAttributeTypeReferencedEntity(en);
setAttrDTDType(dtdattr, getFactory().getDTDBasicType_CDATA()); // hack,
// so
// we
// can
// get
// back
// the
// default
// value
}
else
// set default type
setAttrDTDType(dtdattr, getFactory().getDTDBasicType_CDATA());
}
else {
switch (attrType) {
case AttNode.CDATA :
setAttrDTDType(dtdattr, getFactory().getDTDBasicType_CDATA());
break;
case AttNode.ENTITIES :
setAttrDTDType(dtdattr, getFactory().getDTDBasicType_ENTITIES());
break;
case AttNode.ENTITY :
setAttrDTDType(dtdattr, getFactory().getDTDBasicType_ENTITY());
break;
case AttNode.ID :
// check for duplicate ID attribute
if (hasIDAttribute(dtdattr)) {
/*String errMsg = DTDCoreMessages._ERROR_DUP_ID_ATTRIBUTE_1; //$NON-NLS-1$
errMsg += attdef.name + DTDCoreMessages._UI_ERRORPART_DUP_ID_ATTRIBUTE_2; //$NON-NLS-1$*/
// dtdattr.getDTDElement().getIElement().setDTDErrorMessage(errMsg);
// dtdattr.getDTDElement().getDTDFile().setParseError(true);
parseError = true;
}
setAttrDTDType(dtdattr, getFactory().getDTDBasicType_ID());
break;
case AttNode.IDREF :
setAttrDTDType(dtdattr, getFactory().getDTDBasicType_IDREF());
break;
case AttNode.IDREFS :
setAttrDTDType(dtdattr, getFactory().getDTDBasicType_IDREFS());
break;
case AttNode.ENUMERATION :
setAttrDTDType(dtdattr, createDTDEnumeration(dtdattr, attdef, DTDEnumGroupKind.NAME_TOKEN_GROUP));
break;
case AttNode.NOTATION :
setAttrDTDType(dtdattr, createDTDEnumeration(dtdattr, attdef, DTDEnumGroupKind.NOTATION_GROUP));
break;
case AttNode.NMTOKEN :
setAttrDTDType(dtdattr, getFactory().getDTDBasicType_NMTOKEN());
break;
case AttNode.NMTOKENS :
setAttrDTDType(dtdattr, getFactory().getDTDBasicType_NMTOKENS());
break;
default :
// System.out.println("DTDATTR '" +attdef.name + "'Unknown
// type..." + attrType);
}
}
int attrDefault = attdef.getDefaultType();
int defaultKind = DTDDefaultKind.IMPLIED;
switch (attrDefault) {
case AttNode.FIXED :
defaultKind = DTDDefaultKind.FIXED;
break;
case AttNode.IMPLIED :
defaultKind = DTDDefaultKind.IMPLIED;
break;
case AttNode.REQUIRED :
defaultKind = DTDDefaultKind.REQUIRED;
break;
case AttNode.NOFIXED :
defaultKind = DTDDefaultKind.NOFIXED;
break;
default :
// System.out.println("DTDATTR '" +attdef.name + "' Unknown default
// type... " + attrDefault);
}
DTDDefaultKind defaultKindObj = DTDDefaultKind.get(defaultKind);
dtdattr.setDefaultKind(defaultKindObj);
if (parseError) {
return;
}
String defaultValue = attdef.defaultValue;
if (defaultValue != null) {
if (attrType == AttNode.ENUMERATION || attrType == AttNode.NOTATION) {
if (!isDefaultEnumValueValid(attdef, defaultValue)) {
/*String typeString = (attrType == AttNode.ENUMERATION ? "enumeration" : "notation"); //$NON-NLS-1$ //$NON-NLS-2$
String errMsg = DTDCoreMessages._ERROR_INVALID_DEFAULT_ATTR_VALUE_1; //$NON-NLS-1$
errMsg += typeString + DTDCoreMessages._UI_ERRORPART_INVALID_DEFAULT_ATTR_VALUE_2; //$NON-NLS-1$
errMsg += attdef.name + "'"; //$NON-NLS-1$*/
// dtdattr.getDTDElement().getIElement().setDTDErrorMessage(errMsg);
// dtdattr.getDTDElement().getDTDFile().setParseError(true);
return;
}
}
dtdattr.setDefaultValueString(defaultValue);
}
// System.out.println("DTDAttr - toMof getDefaultValueString " +
// getDefaultValueString());
// System.out.println("DTDAttr - toMof getDefaultValue: " +
// getDefaultValue());
}
public boolean hasIDAttribute(DTDAttribute dtdattr) {
boolean hasID = false;
DTDElement element = dtdattr.getDTDElement();
EList attrs = element.getDTDAttribute();
Iterator i = attrs.iterator();
while (i.hasNext()) {
DTDAttribute attr = (DTDAttribute) i.next();
DTDType dType = attr.getDTDType();
if (dType instanceof DTDBasicType) {
if (((DTDBasicType) dType).getKind().getValue() == DTDBasicTypeKind.ID) {
hasID = true;
break;
}
}
}
return hasID;
}
public DTDEnumerationType createDTDEnumeration(DTDAttribute dtdattr, String[] enumValues, int enumKind) {
DTDEnumerationType enumeration = getFactory().createDTDEnumerationType();
DTDEnumGroupKind groupKind = DTDEnumGroupKind.get(enumKind);
enumeration.setKind(groupKind);
// Enumeration values
if (enumValues != null) {
for (int i = 0; i < enumValues.length; i++) {
EEnumLiteral enumLiteral = createEEnumLiteral();
// enumVal.setXMIDocument(dtdattr.getXMIDocument());
// MOF2EMF Port
// enumLiteral.refSetLiteral(enumValues[i]);
enumLiteral.setName(enumValues[i]);
// enumLiteral.setNumber(i);
enumeration.getEnumLiterals().add(enumLiteral);
}
}
dtdattr.getDTDElement().getDTDFile().getDTDEnumerationType().add(enumeration);
return enumeration;
}
private EEnumLiteral createEEnumLiteral() {
EcorePackage ePackage = (EcorePackage) EPackage.Registry.INSTANCE.getEPackage(EcorePackage.eNS_URI);
// MOF2EMF Port
// return ((EcoreFactory)ePackage.getFactory()).createEEnumLiteral();
return ePackage.getEcoreFactory().createEEnumLiteral();
}
private DTDEnumerationType createDTDEnumeration(DTDAttribute dtdattr, AttNode attdef, int enumKind) {
DTDEnumerationType enumeration = getFactory().createDTDEnumerationType();
DTDEnumGroupKind groupKind = DTDEnumGroupKind.get(enumKind);
enumeration.setKind(groupKind);
dtdattr.getDTDElement().getDTDFile().getDTDEnumerationType().add(enumeration);
// Enumeration values
Enumeration tokenIter = attdef.elements();
if (tokenIter != null) {
while (tokenIter.hasMoreElements()) {
String val = (String) tokenIter.nextElement();
EEnumLiteral enumLiteral = createEEnumLiteral();
// enumLiteral.setXMIDocument(dtdattr.getXMIDocument());
// MOF2EMF Port
// enumLiteral.refSetLiteral(val);
enumLiteral.setName(val);
// enumLiteral.setNumber(i++);
enumeration.getEnumLiterals().add(enumLiteral);
}
}
return enumeration;
}
private boolean isDefaultEnumValueValid(AttNode attdef, String defaultValue) {
boolean valid = false;
boolean containsPercent = false;
// Enumeration values
Enumeration enumValues = attdef.elements();
while (enumValues.hasMoreElements()) {
String val = (String) enumValues.nextElement();
if (val.equals(defaultValue)) {
valid = true;
break;
}
if (val.indexOf('%') >= 0) {
containsPercent = true;
}
}
return valid || containsPercent;
}
public void setAttrDTDType(DTDAttribute dtdattr, DTDType type) {
dtdattr.setDTDType(type);
}
protected void addErrorMessage(ErrorMessage errMsg, Object obj) {
errMsg.setObject(obj);
dtdUtil.addErrorMessage(errMsg);
}
// /**
// * @generated
// */
// protected DTDFactoryImpl getFactoryGen() {
//
// return (DTDFactoryImpl)dtdUtil.getFactory();
// }
// /**
// * @generated
// */
// protected DTDFile getDTDFileGen() {
//
// return dtdFile;
// }
// /**
// * @generated
// */
// protected void visitDTDGen(DTD dtd) {
//
// super.visitDTD(dtd);
//
//
// // - 2nd pass -
// // do final processing for Attlists and adding contentModel
// addAttlistAndContentModel(dtd,dtdFile);
// }
// /**
// * @generated
// */
// protected void visitElementDeclGen(ElementDecl element) {
//
// // Element might have been added earlier because it is referenced
// String declName = element.getNodeName() ;
// // System.out.println("process ElementDecl:" + declName );
// DTDElement dtdelement = (DTDElement)
// dtdUtil.getElementPool().get(declName);
// if (dtdelement == null)
// {
// // System.out.println("process ElementDecl - not found - create" );
// dtdelement = getFactory().createDTDElement();
// dtdelement.setName(declName);
// dtdFile.getDTDObject().add(dtdelement);
// dtdUtil.getElementPool().put(declName,dtdelement);
// }
//
//
// super.visitElementDecl(element);
// }
// /**
// * @generated
// */
// protected void visitNotationDeclGen(NotationDecl notation) {
//
// // Notation might have been added earlier because it is referenced
// // by an entity
// DTDNotation dtdnot = dtdFile.findNotation( notation.getNodeName() );
// if (dtdnot == null)
// {
// dtdnot = getFactory().createDTDNotation();
// dtdFile.getDTDObject().add(dtdnot);
// }
// dtdnot.setName(notation.getNodeName());
//
//
// if (notation.getSystemId()!= null )
// dtdnot.setSystemID(notation.getSystemId());
// if (notation.getPublicId()!= null )
// dtdnot.setPublicID(notation.getPublicId());
//
//
// if (notation.getComment()!=null)
// dtdnot.setComment(notation.getComment());
// if (notation.getErrorMessage()!=null)
// {
// addErrorMessage(notation.getErrorMessage(), dtdnot);
// }
//
//
// super.visitNotationDecl(notation);
// }
// /**
// * @generated
// */
// protected void visitParameterEntityReferenceDeclGen(EntityDecl entity)
// {
//
// // This is a parameter entity reference.
// // Add the link to the real entity that it references
// DTDParameterEntityReference parmEntRef =
// getFactory().createDTDParameterEntityReference();
// dtdFile.getDTDObject().add(parmEntRef);
//
//
// String entityName = entity.getNodeName();
//
//
// // Add the reference to the DTDEntity
// DTDEntity dtdentity = getDTDFile().findEntity(entityName);
// if (dtdentity != null)
// {
// parmEntRef.setEntity(dtdentity);
// }
// if (entity.getErrorMessage()!=null)
// {
// addErrorMessage(entity.getErrorMessage(), dtdentity);
// }
// // System.out.println("adding PE reference: " + declName);
//
//
// super.visitParameterEntityReferenceDecl(entity);
// }
// /**
// * @generated
// */
// protected void visitExternalEntityDeclGen(EntityDecl entity) {
//
// DTDEntity dtdEntity = createDTDEntity(entity);
// // System.out.println("adding entity: " + declName);
// DTDExternalEntity extEntity = getFactory().createDTDExternalEntity();
// dtdEntity.setContent(extEntity);
//
//
// finishExternalEntity(extEntity, entity);
// // System.out.println(" ext entity toMof: " );
// if (dtdEntity.isParameterEntity())
// {
//
//
// dtdUtil.getPEPool().put("%"+entity.getNodeName()+";", dtdEntity);
// }
//
//
// super.visitExternalEntityDecl(entity);
// }
// /**
// * @generated
// */
// protected void visitInternalEntityDeclGen(EntityDecl entity) {
//
// DTDEntity dtdEntity = createDTDEntity(entity);
//
//
// DTDInternalEntity intEntity = getFactory().createDTDInternalEntity();
// dtdEntity.setContent(intEntity);
// intEntity.setValue(entity.getValue());
// // System.out.println(" int entity toMof: " );
// if (dtdEntity.isParameterEntity())
// {
// dtdUtil.getPEPool().put("%"+entity.getNodeName()+";", dtdEntity);
// }
//
//
// super.visitInternalEntityDecl(entity);
// }
// /**
// * @generated
// */
// protected void addAttlistAndContentModelGen(DTD dtd, DTDFile dFile) {
//
// //System.out.println("addAttListAndCotentModel - dtd:" +
// dtd.getName());
// Enumeration en = dtd.externalElements();
// while (en.hasMoreElements())
// {
// Object e = en.nextElement();
// if ( e instanceof ElementDecl )
// {
// DTDElement dtdelement = (DTDElement) dtdUtil.getElementPool().get(
// ((ElementDecl)e).getNodeName() );
// if (dtdelement == null)
// {
// dtdelement = getFactory().createDTDElement();
// dtdFile.getDTDObject().add(dtdelement);
// }
// finishElementDecl(dtdelement, (ElementDecl) e);
// }
// else if ( e instanceof Attlist )
// {
// processAttList((Attlist) e);
// }
// }
// }
// /**
// * @generated
// */
// protected void processAttListGen(Attlist attList) {
//
// DTDElement e = (DTDElement)
// dtdUtil.getElementPool().get(attList.getNodeName());
// if ( e != null )
// {
// // Element has been added. Add the attributes
// //System.out.println(" processAttlist - adding Attlist:" +
// attList.getNodeName());
// createAttributes(e, attList);
// }
// else
// {
// //System.out.println("!!!!!!!!! element is null ");
// }
// }
// /**
// * @generated
// */
// protected void finishExternalEntityGen(DTDExternalEntity extEntity,
// EntityDecl entityDecl) {
//
// updateSystemID(extEntity, entityDecl);
// extEntity.setPublicID(entityDecl.getPublicId());
//
//
// String notationName = entityDecl.getNotationName();
// if (notationName != null)
// {
// DTDNotation dtdNotation = createOrFindNotation(extEntity,
// notationName,true);
// extEntity.setNotation(dtdNotation);
// }
// }
// /**
// * @generated
// */
// protected DTDNotation createOrFindNotationGen(DTDExternalEntity
// extEntity, String name, boolean create) {
//
// DTDNotation aNotation =
// extEntity.getDTDEntity().getDTDFile().findNotation(name);
// if (aNotation != null)
// {
// return aNotation;
// }
//
//
// //
// // Create a notation for the reference
// //
// if (create)
// {
// aNotation = getFactory().createDTDNotation();
// dtdFile.getDTDObject().add(aNotation);
// aNotation.setName(name);
// }
// return aNotation;
// }
// /**
// * The SystemID attribute is set to whatever the user enters
// * e.g. com/ibm/b2b/xmimodels/xxx.dtd.xmi
// *
// * In the unparse() method, parse out the DTD file name from
// * the classpath name.
// * e.g. returns xxx.dtd
// */
// protected void updateSystemIDGen(DTDExternalEntity extEntity,
// EntityDecl entityDecl) {
//
// String systemId = entityDecl.getSystemId();
// String publicId = entityDecl.getPublicId();
// if (systemId != null)
// {
// IdResolver idResolver = new IdResolverImpl(dtd.getName());
// String uri = idResolver.resolveId(publicId, systemId);
// ExternalDTDModel ed = dtdUtil.getExternalDTDModel(resources, uri);
// if (ed != null)
// {
// DTDFile referenceDtdFile = ed.getExternalDTDFile();
// extEntity.setEntityReferencedFromAnotherFile(referenceDtdFile);
// extEntity.setSystemID(systemId);
// }
// else
// {
// if (entityDecl.getErrorMessage() == null)
// {
// ErrorMessage dtdError = new ErrorMessage();
// dtdError.setErrorMessage(DTDCoreMessages.getString("_ERROR_INCL_FILE_LOAD_FAILURE")
// + " '" + systemId + "'");
// addErrorMessage(dtdError, extEntity.getDTDEntity());
// }
//
// if (systemId != null)
// {
// extEntity.setSystemID(systemId);
// }
// else
// {
// extEntity.setSystemID("");
// }
// }
// } // end of if ()
// else
// {
// // set the system id to be ""
// extEntity.setSystemID("");
// }
// }
// /**
// * @generated
// */
// protected DTDEntity createDTDEntityGen(EntityDecl entity) {
//
// // create and do what we can to fill in some basic things
// DTDEntity dtdEntity = getFactory().createDTDEntity();
// dtdFile.getDTDObject().add(dtdEntity);
//
//
// dtdEntity.setName(entity.getNodeName());
// dtdEntity.setParameterEntity(entity.isParameter());
// if (entity.getComment()!=null)
// {
// dtdEntity.setComment(entity.getComment());
// }
// if (entity.getErrorMessage()!=null)
// {
// addErrorMessage(entity.getErrorMessage(), dtdEntity);
// }
//
//
// return dtdEntity;
// }
// /**
// * @generated
// */
// protected void finishElementDeclGen(DTDElement dtdElement, ElementDecl
// ed) {
//
// dtdElement.setName(ed.getNodeName());
//
//
// CMNode cmNode = ed.getContentModelNode();
//
//
// if (ed.getComment()!=null)
// {
// dtdElement.setComment(ed.getComment());
// }
// if (ed.getErrorMessage()!=null)
// {
// addErrorMessage(ed.getErrorMessage(), dtdElement);
// }
//
//
// if (cmNode instanceof CMBasicNode)
// {
// CMBasicNode bn = (CMBasicNode)cmNode;
// switch (bn.getType())
// {
// case CMNodeType.EMPTY :
// DTDEmptyContent emptyContent = getFactory().createDTDEmptyContent();
// dtdElement.setContent(emptyContent);
// break;
//
//
// case CMNodeType.ANY :
// DTDAnyContent anyContent = getFactory().createDTDAnyContent();
// dtdElement.setContent(anyContent);
// break;
//
//
// case CMNodeType.PCDATA:
// DTDPCDataContent pcData = getFactory().createDTDPCDataContent();
// dtdElement.setContent(pcData);
// }
//
//
// }
// else if (cmNode instanceof CMReferenceNode)
// {
// CMReferenceNode rn = (CMReferenceNode) cmNode;
// if (rn.getType() == CMNodeType.ENTITY_REFERENCE)
// {
// String entityName = rn.getName().trim();
//
//
// DTDEntity anEntity = (DTDEntity) dtdUtil.getPEPool().get(entityName);
// if (anEntity!=null)
// {
// //
// // Create an DTDEntityReference and set its referenced element
// //
// DTDEntityReferenceContent enRef =
// getFactory().createDTDEntityReferenceContent();
// enRef.setElementReferencedEntity(anEntity);
//
// DTDOccurrenceType occurrenceType =
// DTDOccurrenceType.get(computeMofOccurrence(rn));
// enRef.setOccurrence(occurrenceType);
//
// dtdElement.setContent(enRef);
// }
// else
// { // create default content
// DTDEmptyContent emptyContent = getFactory().createDTDEmptyContent();
// dtdElement.setContent(emptyContent);
// }
// }
// else
// {
// //
// // Find the real element for this element references
// // If the real element does not yet exist, create it
// //
// DTDElement anElement = createOrFindElement(rn.getName(), dtdElement);
//
//
// //
// // Create an DTDElementReference and set its referenced element
// //
// DTDElementReferenceContent elemRef =
// getFactory().createDTDElementReferenceContent();
// elemRef.setReferencedElement(anElement);
//
// DTDOccurrenceType occurrenceType =
// DTDOccurrenceType.get(computeMofOccurrence(rn));
// elemRef.setOccurrence(occurrenceType);
//
// // setContent to DTDElementReference
// dtdElement.setContent(elemRef);
//
//
// }
// }
// else if (cmNode instanceof CMGroupNode)
// {
// CMGroupNode grpNode = (CMGroupNode)cmNode;
// DTDGroupContent groupContent = getFactory().createDTDGroupContent();
// DTDGroupKind groupKind =
// DTDGroupKind.get(computeMofGroupKind(grpNode.getGroupKind()));
// groupContent.setGroupKind(groupKind);
// DTDOccurrenceType occurrenceType =
// DTDOccurrenceType.get(computeMofOccurrence(grpNode));
// groupContent.setOccurrence(occurrenceType);
//
// // just use the locator for the element as the closest guess
// processGroupContent(groupContent, grpNode);
// dtdElement.setContent(groupContent);
// }
// else if (cmNode == null)
// {
// // bad thing happened here, just create a pcdata
// DTDEmptyContent emptyContent = getFactory().createDTDEmptyContent();
// dtdElement.setContent(emptyContent);
// }
// }
// /**
// * Add a new group to the current group
// * @param parent - the parent node for this group element
// * @param op1Node - the group
// * e.g. (a,b)
// * @param op2Node - set only if called by processCM1op
// * e.g. (a,b)+
// */
// protected void processGroupContentGen(DTDGroupContent parent,
// CMGroupNode grpNode) {
//
// Enumeration children = grpNode.getChildren().elements();
// DTDFactory factory = getFactory();
// while (children.hasMoreElements())
// {
// CMNode cnode = (CMNode) children.nextElement();
//
//
// if (cnode instanceof CMGroupNode)
// {
// CMGroupNode gNode = (CMGroupNode)cnode;
// DTDGroupContent groupContent = factory.createDTDGroupContent();
// DTDGroupKind groupKind =
// DTDGroupKind.get(computeMofGroupKind(gNode.getGroupKind()));
// groupContent.setGroupKind(groupKind);
// DTDOccurrenceType occurrenceType =
// DTDOccurrenceType.get(computeMofOccurrence(gNode));
// groupContent.setOccurrence(occurrenceType);
//
// parent.getContent().add(groupContent);
// processGroupContent(groupContent,gNode);
// }
// else if (cnode instanceof CMBasicNode)
// {
// CMBasicNode n = (CMBasicNode)cnode;
// if (n.getType() == CMNodeType.PCDATA)
// {
// // Create a DTDPCDataContent for a leaf PCData node
// //
// DTDPCDataContent pcData = factory.createDTDPCDataContent();
// // Add #PCDATA to the Group, i.e Mixed content model
// parent.getContent().add(pcData);
// }
// }
// else if (cnode instanceof CMReferenceNode)
// {
// CMReferenceNode rn = (CMReferenceNode)cnode;
// if (rn.getType()==CMNodeType.ELEMENT_REFERENCE)
// {
// // System.out.println("CM Element Ref name: " + rn.getName());
// //
// // Create an DTDElementReference and set its referenced element
// //
// DTDElementReferenceContent elemRef =
// factory.createDTDElementReferenceContent();
//
//
// //
// // Find the real element for this element references
// // If the real element does not yet exist, create it
// //
// DTDElement anElement = createOrFindElement(rn.getName(), elemRef);
//
//
// elemRef.setReferencedElement(anElement);
// DTDOccurrenceType occurrenceType =
// DTDOccurrenceType.get(computeMofOccurrence(rn));
// elemRef.setOccurrence(occurrenceType);
//
// // Add DTDElementReference to the Group
// parent.getContent().add(elemRef);
// }
// else // PE Reference
// {
// String entityName = rn.getName().trim();
//
//
// // System.out.println("CM PE Ref name: " + entityName);
// DTDEntity anEntity = (DTDEntity) dtdUtil.getPEPool().get(entityName);
// if (anEntity!=null)
// {
// //
// // Create an DTDEntityReference and set its referenced element
// //
// DTDEntityReferenceContent enRef =
// factory.createDTDEntityReferenceContent();
// enRef.setElementReferencedEntity(anEntity);
//
// DTDOccurrenceType occurrenceType =
// DTDOccurrenceType.get(computeMofOccurrence(rn));
// enRef.setOccurrence(occurrenceType);
//
//
// // Add DTDEntityReference to the Group
// parent.getContent().add(enRef);
//
//
// }
// }
// }
// }
// }
// /**
// * Find the real element that is referenced by the current element
// */
// protected DTDElement createOrFindElementGen(String name, Object obj) {
//
// // DTDElement aElement = getDTDFile().findElement(name);
//
//
// DTDElement aElement = (DTDElement) dtdUtil.getElementPool().get(name);
//
//
// if (aElement != null)
// {
// return aElement;
// }
//
//
// String errorMsg =
// DTDCoreMessages.getString("_ERROR_UNDECLARED_ELEMENT_1");
// errorMsg += "\"" + name + "\"";
// errorMsg +=
// DTDCoreMessages.getString("_UI_ERRORPART_UNDECLARED_ELEMENT_2");
//
//
// ErrorMessage dtdError = new ErrorMessage();
//
// dtdError.setErrorMessage(errorMsg);
// addErrorMessage(dtdError, obj);
// // System.out.println(errorMsg);
// // setDTDErrorMessage(errorMsg);
// getDTDFile().setParseError(true);
//
//
// //
// // Create an empty element for the reference to make it valid
// //
//
//
// DTDFactory factory = getFactory();
// DTDElement dtdelement = factory.createDTDElement();
// dtdelement.setName(name);
//
//
// DTDEmptyContent emptyContent = factory.createDTDEmptyContent();
// dtdelement.setContent(emptyContent);
//
//
// getDTDFile().getDTDObject().add(dtdelement);
// dtdUtil.getElementPool().put(name,dtdelement);
// return dtdelement;
// }
// /**
// * Compute the MOF occurrence from the xml4j occurrence
// */
// protected int computeMofOccurrenceGen(CMRepeatableNode rnode) {
//
// int occurrence = rnode.getOccurrence();
// int mofoccur = DTDOccurrenceType.ONE;
//
//
// if (occurrence == CMNodeType.ZERO_OR_MORE)
// {
// mofoccur = DTDOccurrenceType.ZERO_OR_MORE;
// }
// else if (occurrence == CMNodeType.ONE_OR_MORE)
// {
// mofoccur = DTDOccurrenceType.ONE_OR_MORE;
// }
// else if (occurrence == CMNodeType.OPTIONAL)
// {
// mofoccur = DTDOccurrenceType.OPTIONAL;
// }
// return mofoccur;
// }
// /**
// * Compute the MOF model group from the xml4j model group
// */
// protected int computeMofGroupKindGen(int type) {
//
// if (type == CMNodeType.GROUP_CHOICE)
// {
// return DTDGroupKind.CHOICE;
// }
// else
// {
// return DTDGroupKind.SEQUENCE;
// }
// }
// /**
// * @generated
// */
// protected void createAttributesGen(DTDElement element, Attlist attList)
// {
//
// if (attList.getErrorMessage()!=null)
// {
// addErrorMessage(attList.getErrorMessage(), element);
// }
//
//
// for (int i=0;i<attList.size();i++)
// {
// AttNode ad = (AttNode) attList.elementAt(i);
// // DTDAttributeElement dtdAtt= getDTDAttributeElement(a.getName());
//
//
// // only add the AttDef if it is not added yet
// // ignore the dup AttDef as documented in the XML 1.0 specs
// //if( dtdAtt==null)
// addAttribute(element, ad);
// }
// }
// /**
// * Create a DTDAttribute from the xml4j attribute
// */
// protected void addAttributeGen(DTDElement dtdelement, AttNode ad) {
//
// DTDAttribute dtdattr = getFactory().createDTDAttribute();
// dtdelement.getDTDAttribute().add(dtdattr);
// finishAttribute(dtdattr, ad);
// }
// /**
// * @generated
// */
// protected void finishAttributeGen(DTDAttribute dtdattr, AttNode attdef)
// {
//
// boolean parseError = false;
//
//
// if (attdef.name.startsWith("%"))
// {
// String peName = attdef.name.trim();
// DTDEntity en = (DTDEntity) dtdUtil.getPEPool().get(peName);
// if (en!=null)
// {
// dtdattr.setAttributeNameReferencedEntity(en);
// }
// }
//
//
// dtdattr.setName(attdef.name);
//
//
// int attrType = attdef.getDeclaredType();
//
//
// if (attrType==AttNode.PEREFERENCE && attdef.type!=null)
// {
// String peName = attdef.type.trim();
// DTDEntity en = (DTDEntity) dtdUtil.getPEPool().get(peName);
// if (en!=null)
// {
// dtdattr.setAttributeTypeReferencedEntity(en);
// setAttrDTDType(dtdattr, getFactory().getDTDBasicType_CDATA()); // hack,
// so we can get back the default value
// }
// else //set default type
// setAttrDTDType(dtdattr, getFactory().getDTDBasicType_CDATA());
//
//
// }
// else
// {
// switch (attrType)
// {
// case AttNode.CDATA:
// setAttrDTDType(dtdattr, getFactory().getDTDBasicType_CDATA());
// break;
//
//
// case AttNode.ENTITIES:
// setAttrDTDType(dtdattr, getFactory().getDTDBasicType_ENTITIES());
// break;
//
//
// case AttNode.ENTITY:
// setAttrDTDType(dtdattr, getFactory().getDTDBasicType_ENTITY());
// break;
//
//
// case AttNode.ID:
// // check for duplicate ID attribute
// if (hasIDAttribute(dtdattr))
// {
// String errMsg = DTDCoreMessages.getString("_ERROR_DUP_ID_ATTRIBUTE_1");
// errMsg += attdef.name +
// DTDCoreMessages.getString("_UI_ERRORPART_DUP_ID_ATTRIBUTE_2");
// // dtdattr.getDTDElement().getIElement().setDTDErrorMessage(errMsg);
// // dtdattr.getDTDElement().getDTDFile().setParseError(true);
// parseError = true;
// }
// setAttrDTDType(dtdattr, getFactory().getDTDBasicType_ID());
// break;
//
//
// case AttNode.IDREF:
// setAttrDTDType(dtdattr, getFactory().getDTDBasicType_IDREF());
// break;
//
//
// case AttNode.IDREFS:
// setAttrDTDType(dtdattr, getFactory().getDTDBasicType_IDREFS());
// break;
//
//
// case AttNode.ENUMERATION:
// setAttrDTDType(dtdattr, createDTDEnumeration(dtdattr, attdef,
// DTDEnumGroupKind.NAME_TOKEN_GROUP));
// break;
//
//
// case AttNode.NOTATION:
// setAttrDTDType(dtdattr, createDTDEnumeration(dtdattr, attdef,
// DTDEnumGroupKind.NOTATION_GROUP));
// break;
//
//
// case AttNode.NMTOKEN:
// setAttrDTDType(dtdattr, getFactory().getDTDBasicType_NMTOKEN());
// break;
//
//
// case AttNode.NMTOKENS:
// setAttrDTDType(dtdattr, getFactory().getDTDBasicType_NMTOKENS());
// break;
//
//
// default:
// // System.out.println("DTDATTR '" +attdef.name + "'Unknown type..." +
// attrType);
// }
// }
//
//
// int attrDefault = attdef.getDefaultType();
// int defaultKind = DTDDefaultKind.IMPLIED;
// switch (attrDefault)
// {
// case AttNode.FIXED:
// defaultKind = DTDDefaultKind.FIXED;
// break;
//
//
// case AttNode.IMPLIED:
// defaultKind = DTDDefaultKind.IMPLIED;
// break;
//
//
// case AttNode.REQUIRED:
// defaultKind = DTDDefaultKind.REQUIRED;
// break;
//
//
// case AttNode.NOFIXED:
// defaultKind = DTDDefaultKind.NOFIXED;
// break;
//
//
// default:
// // System.out.println("DTDATTR '" +attdef.name + "' Unknown default
// type... " + attrDefault);
// }
//
// DTDDefaultKind defaultKindObj = DTDDefaultKind.get(defaultKind);
// dtdattr.setDefaultKind(defaultKindObj);
//
// if (parseError)
// {
// return;
// }
//
//
// String defaultValue = attdef.defaultValue;
// if (defaultValue != null)
// {
// if (attrType == AttNode.ENUMERATION || attrType == AttNode.NOTATION)
// {
// if (! isDefaultEnumValueValid(attdef,defaultValue))
// {
// String typeString =
// (attrType==AttNode.ENUMERATION?"enumeration":"notation");
// String errMsg =
// DTDCoreMessages.getString("_ERROR_INVALID_DEFAULT_ATTR_VALUE_1");
// errMsg += typeString +
// DTDCoreMessages.getString("_UI_ERRORPART_INVALID_DEFAULT_ATTR_VALUE_2");
// errMsg += attdef.name + "'";
//
//
// // dtdattr.getDTDElement().getIElement().setDTDErrorMessage(errMsg);
// // dtdattr.getDTDElement().getDTDFile().setParseError(true);
// return;
// }
// }
// dtdattr.setDefaultValueString(defaultValue);
// }
// // System.out.println("DTDAttr - toMof getDefaultValueString " +
// getDefaultValueString());
// // System.out.println("DTDAttr - toMof getDefaultValue: " +
// getDefaultValue());
// }
// /**
// * @generated
// */
// protected boolean hasIDAttributeGen(DTDAttribute dtdattr) {
//
// boolean hasID = false;
//
//
// DTDElement element = dtdattr.getDTDElement();
// EList attrs = element.getDTDAttribute();
//
//
// Iterator i = attrs.iterator();
// while (i.hasNext())
// {
// DTDAttribute attr = (DTDAttribute) i.next();
// DTDType dType = attr.getDTDType();
// if (dType instanceof DTDBasicType)
// {
// if ( ((DTDBasicType)dType).getKind().getValue() == DTDBasicTypeKind.ID)
// {
// hasID = true;
// break;
// }
// }
// }
// return hasID;
// }
// /**
// * @generated
// */
// protected DTDEnumerationType createDTDEnumerationGen(DTDAttribute
// dtdattr, String[] enumValues, int enumKind) {
//
// DTDEnumerationType enum = getFactory().createDTDEnumerationType();
// // This is gross, but this is what was done before.
// DTDAttributeImpl dtdattrimpl = (DTDAttributeImpl) dtdattr;
// // enum.setID("Enum_" +
// ((DTDElement)dtdattrimpl.getMOFDomain()).getName() + "_" +
// dtdattr.getName());
// DTDEnumGroupKind groupKind = DTDEnumGroupKind.get(enumKind);
// enum.setKind(groupKind);
// // Enumeration values
// if (enumValues!=null)
// {
// for(int i=0;i<enumValues.length;i++)
// {
// EEnumLiteral enumLiteral = createEEnumLiteral();
// // enumVal.setXMIDocument(dtdattr.getXMIDocument());
// enumLiteral.refSetLiteral(enumValues[i]);
// // enumLiteral.setNumber(i);
// enum.getEnumLiterals().add(enumLiteral);
// }
// }
// dtdattr.getDTDElement().getDTDFile().getDTDEnumerationType().add(enum);
// return enum;
// }
// /**
// * @generated
// */
// protected EEnumLiteral createEEnumLiteralGen() {
//
// EcorePackage ePackage =
// (EcorePackage)EPackage.Registry.INSTANCE.getEPackage(EcorePackage.eNS_URI);
// return ((EcoreFactory)ePackage.getFactory()).createEEnumLiteral();
// }
// /**
// * @generated
// */
// protected DTDEnumerationType createDTDEnumerationGen(DTDAttribute
// dtdattr, AttNode attdef, int enumKind) {
//
// DTDEnumerationType enum = getFactory().createDTDEnumerationType();
// // This is gross, but this is what was done before.
// DTDAttributeImpl dtdattrimpl = (DTDAttributeImpl) dtdattr;
// // enum.setID("Enum_" +
// ((DTDElement)dtdattrimpl.getMOFDomain()).getName() + "_" +
// dtdattr.getName());
// DTDEnumGroupKind groupKind = DTDEnumGroupKind.get(enumKind);
// enum.setKind(groupKind);
// dtdattr.getDTDElement().getDTDFile().getDTDEnumerationType().add(enum);
//
//
// // Enumeration values
// Enumeration tokenIter = attdef.elements();
// if (tokenIter != null) {
// int i=0;
// while (tokenIter.hasMoreElements())
// {
// String val = (String)tokenIter.nextElement();
// EEnumLiteral enumLiteral = createEEnumLiteral();
// // enumLiteral.setXMIDocument(dtdattr.getXMIDocument());
//
//
// enumLiteral.refSetLiteral(val);
// // enumLiteral.setNumber(i++);
// enum.getEnumLiterals().add(enumLiteral);
// }
// }
//
//
// return enum;
// }
// /**
// * @generated
// */
// protected boolean isDefaultEnumValueValidGen(AttNode attdef, String
// defaultValue) {
//
// boolean valid = false;
// boolean containsPercent = false;
//
//
// // Enumeration values
// Enumeration enumValues = attdef.elements();
// while (enumValues.hasMoreElements())
// {
// String val = (String)enumValues.nextElement();
// if (val.equals(defaultValue))
// {
// valid = true;
// break;
// }
// if (val.indexOf('%') >= 0)
// {
// containsPercent = true;
// }
// }
// return valid || containsPercent;
// }
// /**
// * @generated
// */
// protected void setAttrDTDTypeGen(DTDAttribute dtdattr, DTDType type) {
//
// dtdattr.setDTDType(type);
// }
// /**
// * @generated
// */
// protected void addErrorMessageGen(ErrorMessage errMsg, Object obj) {
//
// errMsg.setObject(obj);
// dtdUtil.addErrorMessage(errMsg);
// }
}