bundles/org.eclipse.wst.dtd.core/emfmodel/org/eclipse/wst/dtd/core/internal/emf/util/DTDModelBuilder.java

/*******************************************************************************
 * Copyright (c) 2001, 2004 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);
	// }
}