* Copyright (c) 2000, 2011 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

*******************************************************************************/

* @see IClasspathEntry

*/

 

  public static class AssertionFailedException extends RuntimeException {

   

    private static final long serialVersionUID = -171699380721189572L;

    public AssertionFailedException(String message) {

      super(message);

    }

  }

  public static final String TAG_CLASSPATH = "classpath"; //$NON-NLS-1$

  public static final String TAG_CLASSPATHENTRY = "classpathentry"; //$NON-NLS-1$

  public static final String TAG_REFERENCED_ENTRY = "referencedentry"; //$NON-NLS-1$

  public static final String TAG_OUTPUT = "output"; //$NON-NLS-1$

  public static final String TAG_KIND = "kind"; //$NON-NLS-1$

  public static final String TAG_PATH = "path"; //$NON-NLS-1$

  public static final String TAG_SOURCEPATH = "sourcepath"; //$NON-NLS-1$

  public static final String TAG_ROOTPATH = "rootpath"; //$NON-NLS-1$

  public static final String TAG_EXPORTED = "exported"; //$NON-NLS-1$

  public static final String TAG_INCLUDING = "including"; //$NON-NLS-1$

  public static final String TAG_EXCLUDING = "excluding"; //$NON-NLS-1$

  public static final String TAG_ATTRIBUTES = "attributes"; //$NON-NLS-1$

  public static final String TAG_ATTRIBUTE = "attribute"; //$NON-NLS-1$

  public static final String TAG_ATTRIBUTE_NAME = "name"; //$NON-NLS-1$

  public static final String TAG_ATTRIBUTE_VALUE = "value"; //$NON-NLS-1$

  public static final String TAG_COMBINE_ACCESS_RULES = "combineaccessrules"; //$NON-NLS-1$

  public static final String TAG_ACCESS_RULES = "accessrules"; //$NON-NLS-1$

  public static final String TAG_ACCESS_RULE = "accessrule"; //$NON-NLS-1$

  public static final String TAG_PATTERN = "pattern"; //$NON-NLS-1$

  public static final String TAG_ACCESSIBLE = "accessible"; //$NON-NLS-1$

  public static final String TAG_NON_ACCESSIBLE = "nonaccessible"; //$NON-NLS-1$

  public static final String TAG_DISCOURAGED = "discouraged"; //$NON-NLS-1$

  public static final String TAG_IGNORE_IF_BETTER = "ignoreifbetter"; //$NON-NLS-1$

  /**

   * Describes the kind of classpath entry - one of

   * CPE_PROJECT, CPE_LIBRARY, CPE_SOURCE, CPE_VARIABLE or CPE_CONTAINER

   */

  public int entryKind;

  /**

   * Describes the kind of package fragment roots found on

   * this classpath entry - either K_BINARY or K_SOURCE or

   * K_OUTPUT.

   */

  public int contentKind;

  /**

   * The meaning of the path of a classpath entry depends on its entry kind:<ul>

   *  <li>Source code in the current project (<code>CPE_SOURCE</code>) -

   *      The path associated with this entry is the absolute path to the root folder. </li>

   *  <li>A binary library in the current project (<code>CPE_LIBRARY</code>) - the path

   *    associated with this entry is the absolute path to the JAR (or root folder), and

   *    in case it refers to an external JAR, then there is no associated resource in

   *    the workbench.

   *  <li>A required project (<code>CPE_PROJECT</code>) - the path of the entry denotes the

   *    path to the corresponding project resource.</li>

   *  <li>A variable entry (<code>CPE_VARIABLE</code>) - the first segment of the path

   *      is the name of a classpath variable. If this classpath variable

   *    is bound to the path <it>P</it>, the path of the corresponding classpath entry

   *    is computed by appending to <it>P</it> the segments of the returned

   *    path without the variable.</li>

   *  <li> A container entry (<code>CPE_CONTAINER</code>) - the first segment of the path is denoting

   *     the unique container identifier (for which a <code>ClasspathContainerInitializer</code> could be

   *   registered), and the remaining segments are used as additional hints for resolving the container entry to

   *   an actual <code>IClasspathContainer</code>.</li>

   */

  public IPath path;

  /**

   * Patterns allowing to include/exclude portions of the resource tree denoted by this entry path.

   */

  private IPath[] inclusionPatterns;

  private char[][] fullInclusionPatternChars;

  private IPath[] exclusionPatterns;

  private char[][] fullExclusionPatternChars;

  private final static char[][] UNINIT_PATTERNS = new char[][] { "Non-initialized yet".toCharArray() }; //$NON-NLS-1$

  public final static ClasspathEntry[] NO_ENTRIES = new ClasspathEntry[0];

  private final static IPath[] NO_PATHS = new IPath[0];

  private final static IWorkspaceRoot workspaceRoot = ResourcesPlugin.getWorkspace().getRoot();

  private boolean combineAccessRules;

  private String rootID;

  private AccessRuleSet accessRuleSet;

    String[] attributes;

    ArrayList children;

  }

  /*

   * Default inclusion pattern set

   */

  public final static IPath[] INCLUDE_ALL = {};

  /*

   * Default exclusion pattern set

   */

  public final static IPath[] EXCLUDE_NONE = {};

  /*

   * Default extra attributes

   */

  public final static IClasspathAttribute[] NO_EXTRA_ATTRIBUTES = {};

  /*

   * Default access rules

   */

  public final static IAccessRule[] NO_ACCESS_RULES = {};

  /**

   * Describes the path to the source archive associated with this

   * classpath entry, or <code>null</code> if this classpath entry has no

   * source attachment.

   * <p>

   * Only library and variable classpath entries may have source attachments.

   * For library classpath entries, the result path (if present) locates a source

   * archive. For variable classpath entries, the result path (if present) has

   * an analogous form and meaning as the variable path, namely the first segment

   * is the name of a classpath variable.

   */

  public IPath sourceAttachmentPath;

  /**

   * Describes the path within the source archive where package fragments

   * are located. An empty path indicates that packages are located at

   * the root of the source archive. Returns a non-<code>null</code> value

   * if and only if <code>getSourceAttachmentPath</code> returns

   * a non-<code>null</code> value.

   */

  public IPath sourceAttachmentRootPath;

 

  /**

   * See {@link IClasspathEntry#getReferencingEntry()}

   */

  public IClasspathEntry referencingEntry;

  /**

   * Specific output location (for this source entry)

   */

  public IPath specificOutputLocation;

  /**

   * A constant indicating an output location.

   */

  public static final int K_OUTPUT = 10;

 

  public static final String DOT_DOT = ".."; //$NON-NLS-1$

  /**

   * The export flag

   */

  public boolean isExported;

  /**

   * The extra attributes

   */

  public IClasspathAttribute[] extraAttributes;

  public ClasspathEntry(

      int contentKind,

      int entryKind,

      IPath path,

      IPath[] inclusionPatterns,

      IPath[] exclusionPatterns,

      IPath sourceAttachmentPath,

      IPath sourceAttachmentRootPath,

      IPath specificOutputLocation,

      boolean isExported,

      IAccessRule[] accessRules,

      boolean combineAccessRules,

      IClasspathAttribute[] extraAttributes) {

    this(  contentKind,

        entryKind,

        path,

        inclusionPatterns,

        exclusionPatterns,

        sourceAttachmentPath,

        sourceAttachmentRootPath,

        specificOutputLocation,

        null,

        isExported,

        accessRules,

        combineAccessRules,

        extraAttributes);

  }

 

  /**

   * Creates a class path entry of the specified kind with the given path.

   */

  public ClasspathEntry(

    int contentKind,

    int entryKind,

    IPath path,

    IPath[] inclusionPatterns,

    IPath[] exclusionPatterns,

    IPath sourceAttachmentPath,

    IPath sourceAttachmentRootPath,

    IPath specificOutputLocation,

    IClasspathEntry referencingEntry,

    boolean isExported,

    IAccessRule[] accessRules,

    boolean combineAccessRules,

    IClasspathAttribute[] extraAttributes) {

    this.contentKind = contentKind;

    this.entryKind = entryKind;

    this.path = path;

    this.inclusionPatterns = inclusionPatterns;

    this.exclusionPatterns = exclusionPatterns;

    this.referencingEntry = referencingEntry;

   

    int length;

    if (accessRules != null && (length = accessRules.length) > 0) {

      AccessRule[] rules = new AccessRule[length];

      System.arraycopy(accessRules, 0, rules, 0, length);

      byte classpathEntryType;

      String classpathEntryName;

      JavaModelManager manager = JavaModelManager.getJavaModelManager();

      if (this.entryKind == CPE_PROJECT || this.entryKind == CPE_SOURCE) { // can be remote source entry when reconciling

        classpathEntryType = AccessRestriction.PROJECT;

        classpathEntryName = manager.intern(getPath().segment(0));

      } else {

        classpathEntryType = AccessRestriction.LIBRARY;

        Object target = JavaModel.getWorkspaceTarget(path);

        if (target == null) {

          classpathEntryName = manager.intern(path.toOSString());

        } else {

          classpathEntryName = manager.intern(path.makeRelative().toString());

        }

      }

      this.accessRuleSet = new AccessRuleSet(rules, classpathEntryType, classpathEntryName);

    }

//      this.accessRuleSet = null;

//    }

    this.combineAccessRules = combineAccessRules;

    this.extraAttributes = extraAttributes;

      if (inclusionPatterns != INCLUDE_ALL && inclusionPatterns.length > 0) {

      this.fullInclusionPatternChars = UNINIT_PATTERNS;

      }

      if (exclusionPatterns.length > 0) {

      this.fullExclusionPatternChars = UNINIT_PATTERNS;

      }

    this.sourceAttachmentPath = sourceAttachmentPath;

    this.sourceAttachmentRootPath = sourceAttachmentRootPath;

    this.specificOutputLocation = specificOutputLocation;

    this.isExported = isExported;

  }

  public boolean combineAccessRules() {

    return this.combineAccessRules;

  }

  /**

   * Used to perform export/restriction propagation across referring projects/containers

   */

  public ClasspathEntry combineWith(ClasspathEntry referringEntry) {

    if (referringEntry == null) return this;

    if (referringEntry.isExported() || referringEntry.getAccessRuleSet() != null ) {

      boolean combine = this.entryKind == CPE_SOURCE || referringEntry.combineAccessRules();

      return new ClasspathEntry(

                getContentKind(),

                getEntryKind(),

                getPath(),

                this.inclusionPatterns,

                this.exclusionPatterns,

                getSourceAttachmentPath(),

                getSourceAttachmentRootPath(),

                getOutputLocation(),

                referringEntry.isExported() || this.isExported, // duplicate container entry for tagging it as exported

                combine(referringEntry.getAccessRules(), getAccessRules(), combine),

                this.combineAccessRules,

                this.extraAttributes);

    }

    // no need to clone

    return this;

  }

  private IAccessRule[] combine(IAccessRule[] referringRules, IAccessRule[] rules, boolean combine) {

    if (!combine) return rules;

    if (rules == null || rules.length == 0) return referringRules;

    // concat access rules

    int referringRulesLength = referringRules.length;

    int accessRulesLength = rules.length;

    int rulesLength = referringRulesLength + accessRulesLength;

    IAccessRule[] result = new IAccessRule[rulesLength];

    System.arraycopy(referringRules, 0, result, 0, referringRulesLength);

    System.arraycopy(rules, 0, result, referringRulesLength, accessRulesLength);

    return result;

  }

  static IClasspathAttribute[] decodeExtraAttributes(NodeList attributes) {

    if (attributes == null) return NO_EXTRA_ATTRIBUTES;

    int length = attributes.getLength();

    if (length == 0) return NO_EXTRA_ATTRIBUTES;

    IClasspathAttribute[] result = new IClasspathAttribute[length];

    int index = 0;

    for (int i = 0; i < length; ++i) {

      Node node = attributes.item(i);

      if (node.getNodeType() == Node.ELEMENT_NODE) {

        Element attribute = (Element)node;

        String name = attribute.getAttribute(TAG_ATTRIBUTE_NAME);

        if (name == null) continue;

        String value = attribute.getAttribute(TAG_ATTRIBUTE_VALUE);

        if (value == null) continue;

        result[index++] = new ClasspathAttribute(name, value);

      }

    }

    if (index != length)

      System.arraycopy(result, 0, result = new IClasspathAttribute[index], 0, index);

    return result;

  }

  static IAccessRule[] decodeAccessRules(NodeList list) {

    if (list == null) return null;

    int length = list.getLength();

    if (length == 0) return null;

    IAccessRule[] result = new IAccessRule[length];

    int index = 0;

    for (int i = 0; i < length; i++) {

      Node accessRule = list.item(i);

      if (accessRule.getNodeType() == Node.ELEMENT_NODE) {

        Element elementAccessRule = (Element) accessRule;

        String pattern = elementAccessRule.getAttribute(TAG_PATTERN);

        if (pattern == null) continue;

        String tagKind =  elementAccessRule.getAttribute(TAG_KIND);

        int kind;

        if (TAG_ACCESSIBLE.equals(tagKind))

          kind = IAccessRule.K_ACCESSIBLE;

        else if (TAG_NON_ACCESSIBLE.equals(tagKind))

          kind = IAccessRule.K_NON_ACCESSIBLE;

        else if (TAG_DISCOURAGED.equals(tagKind))

          kind = IAccessRule.K_DISCOURAGED;

        else

          continue;

        boolean ignoreIfBetter = "true".equals(elementAccessRule.getAttribute(TAG_IGNORE_IF_BETTER)); //$NON-NLS-1$

        result[index++] = new ClasspathAccessRule(new Path(pattern), ignoreIfBetter ? kind | IAccessRule.IGNORE_IF_BETTER : kind);

      }

    }

    if (index != length)

      System.arraycopy(result, 0, result = new IAccessRule[index], 0, index);

    return result;

  }

  /**

   * Decode some element tag containing a sequence of patterns into IPath[]

   */

  private static IPath[] decodePatterns(NamedNodeMap nodeMap, String tag) {

    String sequence = removeAttribute(tag, nodeMap);

    if (!sequence.equals("")) { //$NON-NLS-1$

      char[][] patterns = CharOperation.splitOn('|', sequence.toCharArray());

      int patternCount;

      if ((patternCount = patterns.length) > 0) {

        IPath[] paths = new IPath[patternCount];

        int index = 0;

        for (int j = 0; j < patternCount; j++) {

          char[] pattern = patterns[j];

          if (pattern.length == 0) continue; // see https://bugs.eclipse.org/bugs/show_bug.cgi?id=105581

          paths[index++] = new Path(new String(pattern));

        }

        if (index < patternCount)

          System.arraycopy(paths, 0, paths = new IPath[index], 0, index);

        return paths;

      }

    }

    return null;

  }

  private static void decodeUnknownNode(Node node, StringBuffer buffer, IJavaProject project) {

    ByteArrayOutputStream s = new ByteArrayOutputStream();

    OutputStreamWriter writer;

    try {

      writer = new OutputStreamWriter(s, "UTF8"); //$NON-NLS-1$

      XMLWriter xmlWriter = new XMLWriter(writer, project, false/*don't print XML version*/);

      decodeUnknownNode(node, xmlWriter, true/*insert new line*/);

      xmlWriter.flush();

      xmlWriter.close();

      buffer.append(s.toString("UTF8")); //$NON-NLS-1$

    } catch (UnsupportedEncodingException e) {

      // ignore (UTF8 is always supported)

    }

  }

  private static void decodeUnknownNode(Node node, XMLWriter xmlWriter, boolean insertNewLine) {

    switch (node.getNodeType()) {

    case Node.ELEMENT_NODE:

      NamedNodeMap attributes;

      HashMap parameters = null;

      if ((attributes = node.getAttributes()) != null) {

        int length = attributes.getLength();

        if (length > 0) {

          parameters = new HashMap();

          for (int i = 0; i < length; i++) {

            Node attribute = attributes.item(i);

            parameters.put(attribute.getNodeName(), attribute.getNodeValue());

          }

        }

      }

      NodeList children = node.getChildNodes();

      int childrenLength = children.getLength();

      String nodeName = node.getNodeName();

      xmlWriter.printTag(nodeName, parameters, false/*don't insert tab*/, false/*don't insert new line*/, childrenLength == 0/*close tag if no children*/);

      if (childrenLength > 0) {

        for (int i = 0; i < childrenLength; i++) {

          decodeUnknownNode(children.item(i), xmlWriter, false/*don't insert new line*/);

        }

        xmlWriter.endTag(nodeName, false/*don't insert tab*/, insertNewLine);

      }

      break;

    case Node.TEXT_NODE:

      String data = ((Text) node).getData();

      xmlWriter.printString(data, false/*don't insert tab*/, false/*don't insert new line*/);

      break;

    }

  }

  /*

   * Returns a char based representation of the exclusions patterns full path.

   */

  public char[][] fullExclusionPatternChars() {

    if (this.fullExclusionPatternChars == UNINIT_PATTERNS) {

      int length = this.exclusionPatterns.length;

      this.fullExclusionPatternChars = new char[length][];

      IPath prefixPath = this.path.removeTrailingSeparator();

      for (int i = 0; i < length; i++) {

        this.fullExclusionPatternChars[i] =

          prefixPath.append(this.exclusionPatterns[i]).toString().toCharArray();

      }

    }

    return this.fullExclusionPatternChars;

  }

  /*

   * Returns a char based representation of the exclusions patterns full path.

   */

  public char[][] fullInclusionPatternChars() {

    if (this.fullInclusionPatternChars == UNINIT_PATTERNS) {

      int length = this.inclusionPatterns.length;

      this.fullInclusionPatternChars = new char[length][];

      IPath prefixPath = this.path.removeTrailingSeparator();

      for (int i = 0; i < length; i++) {

        this.fullInclusionPatternChars[i] =

          prefixPath.append(this.inclusionPatterns[i]).toString().toCharArray();

      }

    }

    return this.fullInclusionPatternChars;

  }

  /**

   * Returns the XML encoding of the class path.

   */

  public void elementEncode(XMLWriter writer, IPath projectPath, boolean indent, boolean newLine, Map unknownElements, boolean isReferencedEntry) {

    HashMap parameters = new HashMap();

    parameters.put(TAG_KIND, ClasspathEntry.kindToString(this.entryKind));

    IPath xmlPath = this.path;

    if (this.entryKind != IClasspathEntry.CPE_VARIABLE && this.entryKind != IClasspathEntry.CPE_CONTAINER) {

      // translate to project relative from absolute (unless a device path)

      if (xmlPath.isAbsolute()) {

        if (projectPath != null && projectPath.isPrefixOf(xmlPath)) {

          if (xmlPath.segment(0).equals(projectPath.segment(0))) {

            xmlPath = xmlPath.removeFirstSegments(1);

            xmlPath = xmlPath.makeRelative();

          } else {

            xmlPath = xmlPath.makeAbsolute();

          }

        }

      }

    }

    parameters.put(TAG_PATH, String.valueOf(xmlPath));

    if (this.sourceAttachmentPath != null) {

      xmlPath = this.sourceAttachmentPath;

      // translate to project relative from absolute

      if (this.entryKind != IClasspathEntry.CPE_VARIABLE && projectPath != null && projectPath.isPrefixOf(xmlPath)) {

        if (xmlPath.segment(0).equals(projectPath.segment(0))) {

          xmlPath = xmlPath.removeFirstSegments(1);

          xmlPath = xmlPath.makeRelative();

        }

      }

      parameters.put(TAG_SOURCEPATH, String.valueOf(xmlPath));

    }

    if (this.sourceAttachmentRootPath != null) {

      parameters.put(TAG_ROOTPATH, String.valueOf(this.sourceAttachmentRootPath));

    }

    if (this.isExported) {

      parameters.put(TAG_EXPORTED, "true");//$NON-NLS-1$

    }

    encodePatterns(this.inclusionPatterns, TAG_INCLUDING, parameters);

    encodePatterns(this.exclusionPatterns, TAG_EXCLUDING, parameters);

    if (this.entryKind == CPE_PROJECT && !this.combineAccessRules)

      parameters.put(TAG_COMBINE_ACCESS_RULES, "false"); //$NON-NLS-1$

    // unknown attributes

    UnknownXmlElements unknownXmlElements = unknownElements == null ? null : (UnknownXmlElements) unknownElements.get(this.path);

    String[] unknownAttributes;

    if (unknownXmlElements != null && (unknownAttributes = unknownXmlElements.attributes) != null)

      for (int i = 0, length = unknownAttributes.length; i < length; i+=2) {

        String tagName = unknownAttributes[i];

        String tagValue = unknownAttributes[i+1];

        parameters.put(tagName, tagValue);

      }

    if (this.specificOutputLocation != null) {

      IPath outputLocation = this.specificOutputLocation.removeFirstSegments(1);

      outputLocation = outputLocation.makeRelative();

      parameters.put(TAG_OUTPUT, String.valueOf(outputLocation));

    }

    boolean hasExtraAttributes = this.extraAttributes.length != 0;

    boolean hasRestrictions = getAccessRuleSet() != null; // access rule set is null if no access rules

    ArrayList unknownChildren = unknownXmlElements != null ? unknownXmlElements.children : null;

    boolean hasUnknownChildren = unknownChildren != null;

   

    /* close tag if no extra attributes, no restriction and no unknown children */

    String tagName = isReferencedEntry ? TAG_REFERENCED_ENTRY : TAG_CLASSPATHENTRY;

    writer.printTag(

      tagName,

      parameters,

      indent,

      newLine,

      !hasExtraAttributes && !hasRestrictions && !hasUnknownChildren);

    if (hasExtraAttributes)

      encodeExtraAttributes(writer, indent, newLine);

    if (hasRestrictions)

      encodeAccessRules(writer, indent, newLine);

    if (hasUnknownChildren)

      encodeUnknownChildren(writer, indent, newLine, unknownChildren);

    if (hasExtraAttributes || hasRestrictions || hasUnknownChildren)

      writer.endTag(tagName, indent, true/*insert new line*/);

  }

  void encodeExtraAttributes(XMLWriter writer, boolean indent, boolean newLine) {

    writer.startTag(TAG_ATTRIBUTES, indent);

    for (int i = 0; i < this.extraAttributes.length; i++) {

      IClasspathAttribute attribute = this.extraAttributes[i];

      HashMap parameters = new HashMap();

        parameters.put(TAG_ATTRIBUTE_NAME, attribute.getName());

      parameters.put(TAG_ATTRIBUTE_VALUE, attribute.getValue());

      writer.printTag(TAG_ATTRIBUTE, parameters, indent, newLine, true);

    }

    writer.endTag(TAG_ATTRIBUTES, indent, true/*insert new line*/);

  }

  void encodeAccessRules(XMLWriter writer, boolean indent, boolean newLine) {

    writer.startTag(TAG_ACCESS_RULES, indent);

    AccessRule[] rules = getAccessRuleSet().getAccessRules();

    for (int i = 0, length = rules.length; i < length; i++) {

      encodeAccessRule(rules[i], writer, indent, newLine);

    }

    writer.endTag(TAG_ACCESS_RULES, indent, true/*insert new line*/);

  }

  private void encodeAccessRule(AccessRule accessRule, XMLWriter writer, boolean indent, boolean newLine) {

    HashMap parameters = new HashMap();

    parameters.put(TAG_PATTERN, new String(accessRule.pattern));

    switch (accessRule.getProblemId()) {

      case IProblem.ForbiddenReference:

        parameters.put(TAG_KIND, TAG_NON_ACCESSIBLE);

        break;

      case IProblem.DiscouragedReference:

        parameters.put(TAG_KIND, TAG_DISCOURAGED);

        break;

      default:

        parameters.put(TAG_KIND, TAG_ACCESSIBLE);

        break;

    }

    if (accessRule.ignoreIfBetter())

      parameters.put(TAG_IGNORE_IF_BETTER, "true"); //$NON-NLS-1$

    writer.printTag(TAG_ACCESS_RULE, parameters, indent, newLine, true);

  }

  private void encodeUnknownChildren(XMLWriter writer, boolean indent, boolean newLine, ArrayList unknownChildren) {

    for (int i = 0, length = unknownChildren.size(); i < length; i++) {

      String child = (String) unknownChildren.get(i);

      writer.printString(child, indent, false/*don't insert new line*/);

    }

  }

  public static IClasspathEntry elementDecode(Element element, IJavaProject project, Map unknownElements) {

    IPath projectPath = project.getProject().getFullPath();

    NamedNodeMap attributes = element.getAttributes();

    NodeList children = element.getChildNodes();

    boolean[] foundChildren = new boolean[children.getLength()];

    String kindAttr = removeAttribute(TAG_KIND, attributes);

    String pathAttr = removeAttribute(TAG_PATH, attributes);

    // ensure path is absolute

    IPath path = new Path(pathAttr);

    int kind = kindFromString(kindAttr);

    if (kind != IClasspathEntry.CPE_VARIABLE && kind != IClasspathEntry.CPE_CONTAINER && !path.isAbsolute()) {

      if (!(path.segmentCount() > 0 && path.segment(0).equals(ClasspathEntry.DOT_DOT))) {

        path = projectPath.append(path);

      }

    }

    // source attachment info (optional)

    IPath sourceAttachmentPath =

      element.hasAttribute(TAG_SOURCEPATH)

      ? new Path(removeAttribute(TAG_SOURCEPATH, attributes))

      : null;

    if (kind != IClasspathEntry.CPE_VARIABLE && sourceAttachmentPath != null && !sourceAttachmentPath.isAbsolute()) {

      sourceAttachmentPath = projectPath.append(sourceAttachmentPath);

    }

    IPath sourceAttachmentRootPath =

      element.hasAttribute(TAG_ROOTPATH)

      ? new Path(removeAttribute(TAG_ROOTPATH, attributes))

      : null;

    // exported flag (optional)

    boolean isExported = removeAttribute(TAG_EXPORTED, attributes).equals("true"); //$NON-NLS-1$

    // inclusion patterns (optional)

    IPath[] inclusionPatterns = decodePatterns(attributes, TAG_INCLUDING);

    if (inclusionPatterns == null) inclusionPatterns = INCLUDE_ALL;

    // exclusion patterns (optional)

    IPath[] exclusionPatterns = decodePatterns(attributes, TAG_EXCLUDING);

    if (exclusionPatterns == null) exclusionPatterns = EXCLUDE_NONE;

    // access rules (optional)

    NodeList attributeList = getChildAttributes(TAG_ACCESS_RULES, children, foundChildren);

    IAccessRule[] accessRules = decodeAccessRules(attributeList);

    // backward compatibility

    if (accessRules == null) {

      accessRules = getAccessRules(inclusionPatterns, exclusionPatterns);

    }

    // combine access rules (optional)

    boolean combineAccessRestrictions = !removeAttribute(TAG_COMBINE_ACCESS_RULES, attributes).equals("false"); //$NON-NLS-1$

    // extra attributes (optional)

    attributeList = getChildAttributes(TAG_ATTRIBUTES, children, foundChildren);

    IClasspathAttribute[] extraAttributes = decodeExtraAttributes(attributeList);

    // custom output location

    IPath outputLocation = element.hasAttribute(TAG_OUTPUT) ? projectPath.append(removeAttribute(TAG_OUTPUT, attributes)) : null;

    String[] unknownAttributes = null;

    ArrayList unknownChildren = null;

    if (unknownElements != null) {

      // unknown attributes

      int unknownAttributeLength = attributes.getLength();

      if (unknownAttributeLength != 0) {

        unknownAttributes = new String[unknownAttributeLength*2];

        for (int i = 0; i < unknownAttributeLength; i++) {

          Node attribute = attributes.item(i);

          unknownAttributes[i*2] = attribute.getNodeName();

          unknownAttributes[i*2 + 1] = attribute.getNodeValue();

        }

      }

      // unknown children

      for (int i = 0, length = foundChildren.length; i < length; i++) {

        if (!foundChildren[i]) {

          Node node = children.item(i);

          if (node.getNodeType() != Node.ELEMENT_NODE) continue;

          if (unknownChildren == null)

            unknownChildren = new ArrayList();

          StringBuffer buffer = new StringBuffer();

          decodeUnknownNode(node, buffer, project);

          unknownChildren.add(buffer.toString());

        }

      }

    }

    // recreate the CP entry

    IClasspathEntry entry = null;

    switch (kind) {

      case IClasspathEntry.CPE_PROJECT :

        entry = new ClasspathEntry(

                        IPackageFragmentRoot.K_SOURCE,

                        IClasspathEntry.CPE_PROJECT,

                        path,

                        ClasspathEntry.INCLUDE_ALL, // inclusion patterns

                        ClasspathEntry.EXCLUDE_NONE, // exclusion patterns

                        null, // source attachment

                        null, // source attachment root

                        null, // specific output folder

                        isExported,

                        accessRules,

                        combineAccessRestrictions,

                        extraAttributes);

        break;

      case IClasspathEntry.CPE_LIBRARY :

        entry = JavaCore.newLibraryEntry(

                        path,

                        sourceAttachmentPath,

                        sourceAttachmentRootPath,

                        accessRules,

                        extraAttributes,

                        isExported);

        break;

      case IClasspathEntry.CPE_SOURCE :

        // must be an entry in this project or specify another project

        String projSegment = path.segment(0);

        if (projSegment != null && projSegment.equals(project.getElementName())) { // this project

          entry = JavaCore.newSourceEntry(

                        path,

                        inclusionPatterns,

                        exclusionPatterns,

                        outputLocation,

                        extraAttributes);

        } else {

          if (path.segmentCount() == 1) {

            // another project

            entry = JavaCore.newProjectEntry(

                        path,

                        accessRules,

                        combineAccessRestrictions,

                        extraAttributes,

                        isExported);

          } else {

            // an invalid source folder

            entry = JavaCore.newSourceEntry(

                        path,

                        inclusionPatterns,

                        exclusionPatterns,

                        outputLocation,

                        extraAttributes);

          }

        }

        break;

      case IClasspathEntry.CPE_VARIABLE :

        entry = JavaCore.newVariableEntry(

                        path,

                        sourceAttachmentPath,

                        sourceAttachmentRootPath,

                        accessRules,

                        extraAttributes,

                        isExported);

        break;

      case IClasspathEntry.CPE_CONTAINER :

        entry = JavaCore.newContainerEntry(

                        path,

                        accessRules,

                        extraAttributes,

                        isExported);

        break;

      case ClasspathEntry.K_OUTPUT :

        if (!path.isAbsolute()) return null;

        entry = new ClasspathEntry(

                        ClasspathEntry.K_OUTPUT,

                        IClasspathEntry.CPE_LIBRARY,

                        path,

                        INCLUDE_ALL,

                        EXCLUDE_NONE,

                        null, // source attachment

                        null, // source attachment root

                        null, // custom output location

                        false,

                        null, // no access rules

                        false, // no accessible files to combine

                        NO_EXTRA_ATTRIBUTES);

        break;

      default :

        throw new AssertionFailedException(Messages.bind(Messages.classpath_unknownKind, kindAttr));

    }

    if (unknownAttributes != null || unknownChildren != null) {

      UnknownXmlElements unknownXmlElements = new UnknownXmlElements();

      unknownXmlElements.attributes = unknownAttributes;

      unknownXmlElements.children = unknownChildren;

      unknownElements.put(path, unknownXmlElements);

    }

    return entry;

  }

 

  /*

   * Returns whether the given path as a ".." segment

   */

  public static boolean hasDotDot(IPath path) {

    for (int i = 0, length = path.segmentCount(); i < length; i++) {

      if (DOT_DOT.equals(path.segment(i)))

        return true;

    }

    return false;

  }

  public static NodeList getChildAttributes(String childName, NodeList children, boolean[] foundChildren) {

    for (int i = 0, length = foundChildren.length; i < length; i++) {

      Node node = children.item(i);

      if (childName.equals(node.getNodeName())) {

        foundChildren[i] = true;

        return node.getChildNodes();

      }

    }

    return null;

  }

  private static String removeAttribute(String nodeName, NamedNodeMap nodeMap) {

    Node node = removeNode(nodeName, nodeMap);

    if (node == null)

      return ""; // //$NON-NLS-1$

    return node.getNodeValue();

  }

  private static Node removeNode(String nodeName, NamedNodeMap nodeMap) {

    try {

      return nodeMap.removeNamedItem(nodeName);

    } catch (DOMException e) {

      if (e.code != DOMException.NOT_FOUND_ERR)

        throw e;

      return null;

    }

  }

  /*

   * Read the Class-Path clause of the manifest of the jar pointed by this path, and return

   * the corresponding paths.

   */

  public static IPath[] resolvedChainedLibraries(IPath jarPath) {

    ArrayList result = new ArrayList();

    resolvedChainedLibraries(jarPath, new HashSet(), result);

    if (result.size() == 0)

      return NO_PATHS;

    return (IPath[]) result.toArray(new IPath[result.size()]);

  }

 

  private static void resolvedChainedLibraries(IPath jarPath, HashSet visited, ArrayList result) {

    if (visited.contains( jarPath))