src/share/classes/com/sun/jndi/cosnaming/CNNameParser.java - platform/external/jetbrains/jdk8u_jdk - Git at Google

 /*
  * Copyright (c) 1999, 2011, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.  Oracle designates this
  * particular file as subject to the "Classpath" exception as provided
  * by Oracle in the LICENSE file that accompanied this code.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  * version 2 for more details (a copy is included in the LICENSE file that
  * accompanied this code).
  *
  * You should have received a copy of the GNU General Public License version
  * 2 along with this work; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  */

 package com.sun.jndi.cosnaming;

 import javax.naming.*;
 import java.util.Properties;
 import java.util.Vector;
 import java.util.Enumeration;

 import org.omg.CosNaming.NameComponent;

 /**
   * Parsing routines for NameParser as well as COS Naming stringified names.
   * This is used by CNCtx to create a NameComponent[] object and vice versa.
   * It follows Section 4.5 of Interoperable Naming Service (INS) 98-10-11.
   * In summary, the stringified form is a left-to-right, forward-slash
   * separated name. id and kinds are separated by '.'. backslash is the
   * escape character.
   *
   * @author Rosanna Lee
   */

 final public class CNNameParser implements NameParser {

     private static final Properties mySyntax = new Properties();
     private static final char kindSeparator = '.';
     private static final char compSeparator = '/';
     private static final char escapeChar = '\\';
     static {
         mySyntax.put("jndi.syntax.direction", "left_to_right");
         mySyntax.put("jndi.syntax.separator", ""+compSeparator);
         mySyntax.put("jndi.syntax.escape", ""+escapeChar);
     };

   /**
     * Constructs a new name parser for parsing names in INS syntax.
     */
     public CNNameParser() {
     }

   /**
     * Returns a CompoundName given a string in INS syntax.
     * @param name The non-null string representation of the name.
     * @return a non-null CompoundName
     */
     public Name parse(String name) throws NamingException {
         Vector<String> comps = insStringToStringifiedComps(name);
         return new CNCompoundName(comps.elements());
     }

     /**
      * Creates a NameComponent[] from a Name structure.
      * Used by CNCtx to convert the input Name arg into a NameComponent[].
      * @param a CompoundName or a CompositeName;
      * each component must be the stringified form of a NameComponent.
      */
     static NameComponent[] nameToCosName(Name name)
         throws InvalidNameException {
             int len = name.size();
             if (len == 0) {
                 return new NameComponent[0];
             }

             NameComponent[] answer = new NameComponent[len];
             for (int i = 0; i < len; i++) {
                 answer[i] = parseComponent(name.get(i));
             }
             return answer;
     }

     /**
      * Returns the INS stringified form of a NameComponent[].
      * Used by CNCtx.getNameInNamespace(), CNCompoundName.toString().
      */
     static String cosNameToInsString(NameComponent[] cname) {
       StringBuffer str = new StringBuffer();
       for ( int i = 0; i < cname.length; i++) {
           if ( i > 0) {
               str.append(compSeparator);
           }
           str.append(stringifyComponent(cname[i]));
       }
       return str.toString();
     }

     /**
      * Creates a CompositeName from a NameComponent[].
      * Used by ExceptionMapper and CNBindingEnumeration to convert
      * a NameComponent[] into a composite name.
      */
     static Name cosNameToName(NameComponent[] cname) {
         Name nm = new CompositeName();
         for ( int i = 0; cname != null && i < cname.length; i++) {
             try {
                 nm.add(stringifyComponent(cname[i]));
             } catch (InvalidNameException e) {
                 // ignore
             }
         }
         return nm;
     }

     /**
      * Converts an INS-syntax string name into a Vector in which
      * each element of the vector contains a stringified form of
      * a NameComponent.
      */
     private static Vector<String> insStringToStringifiedComps(String str)
         throws InvalidNameException {

         int len = str.length();
         Vector<String> components = new Vector<>(10);
         char[] id = new char[len];
         char[] kind = new char[len];
         int idCount, kindCount;
         boolean idMode;
         for (int i = 0; i < len; ) {
             idCount = kindCount = 0; // reset for new component
             idMode = true;           // always start off parsing id
             while (i < len) {
                 if (str.charAt(i) == compSeparator) {
                     break;

                 } else if (str.charAt(i) == escapeChar) {
                     if (i + 1 >= len) {
                         throw new InvalidNameException(str +
                             ": unescaped \\ at end of component");
                     } else if (isMeta(str.charAt(i+1))) {
                         ++i; // skip escape and let meta through
                         if (idMode) {
                             id[idCount++] = str.charAt(i++);
                         } else {
                             kind[kindCount++] = str.charAt(i++);
                         }
                     } else {
                         throw new InvalidNameException(str +
                             ": invalid character being escaped");
                     }

                 } else if (idMode && str.charAt(i) == kindSeparator) {
                     // just look for the first kindSeparator
                     ++i; // skip kind separator
                     idMode = false;

                 } else {
                     if (idMode) {
                         id[idCount++] = str.charAt(i++);
                     } else {
                         kind[kindCount++] = str.charAt(i++);
                     }
                 }
             }
             components.addElement(stringifyComponent(
                 new NameComponent(new String(id, 0, idCount),
                     new String(kind, 0, kindCount))));

             if (i < len) {
                 ++i; // skip separator
             }
         }

         return components;
     }

     /**
      * Return a NameComponent given its stringified form.
      */
     private static NameComponent parseComponent(String compStr)
     throws InvalidNameException {
         NameComponent comp = new NameComponent();
         int kindSep = -1;
         int len = compStr.length();

         int j = 0;
         char[] newStr = new char[len];
         boolean escaped = false;

         // Find the kind separator
         for (int i = 0; i < len && kindSep < 0; i++) {
             if (escaped) {
                 newStr[j++] = compStr.charAt(i);
                 escaped = false;
             } else if (compStr.charAt(i) == escapeChar) {
                 if (i + 1 >= len) {
                     throw new InvalidNameException(compStr +
                             ": unescaped \\ at end of component");
                 } else if (isMeta(compStr.charAt(i+1))) {
                     escaped = true;
                 } else {
                     throw new InvalidNameException(compStr +
                         ": invalid character being escaped");
                 }
             } else if (compStr.charAt(i) == kindSeparator) {
                 kindSep = i;
             } else {
                 newStr[j++] = compStr.charAt(i);
             }
         }

         // Set id
         comp.id = new String(newStr, 0, j);

         // Set kind
         if (kindSep < 0) {
             comp.kind = "";  // no kind separator
         } else {
             // unescape kind
             j = 0;
             escaped = false;
             for (int i = kindSep+1; i < len; i++) {
                 if (escaped) {
                     newStr[j++] = compStr.charAt(i);
                     escaped = false;
                 } else if (compStr.charAt(i) == escapeChar) {
                     if (i + 1 >= len) {
                         throw new InvalidNameException(compStr +
                             ": unescaped \\ at end of component");
                     } else if (isMeta(compStr.charAt(i+1))) {
                         escaped = true;
                     } else {
                         throw new InvalidNameException(compStr +
                             ": invalid character being escaped");
                     }
                 } else {
                     newStr[j++] = compStr.charAt(i);
                 }
             }
             comp.kind = new String(newStr, 0, j);
         }
         return comp;
     }

     private static String stringifyComponent(NameComponent comp) {
         StringBuffer one = new StringBuffer(escape(comp.id));
         if (comp.kind != null && !comp.kind.equals("")) {
             one.append(kindSeparator + escape(comp.kind));
         }
         if (one.length() == 0) {
             return ""+kindSeparator;  // if neither id nor kind specified
         } else {
             return one.toString();
         }
     }

     /**
      * Returns a string with '.', '\', '/' escaped. Used when
      * stringifying the name into its INS stringified form.
      */
     private static String escape(String str) {
         if (str.indexOf(kindSeparator) < 0 &&
             str.indexOf(compSeparator) < 0 &&
             str.indexOf(escapeChar) < 0) {
             return str;                         // no meta characters to escape
         } else {
             int len = str.length();
             int j = 0;
             char[] newStr = new char[len+len];
             for (int i = 0; i < len; i++) {
                 if (isMeta(str.charAt(i))) {
                     newStr[j++] = escapeChar;   // escape meta character
                 }
                 newStr[j++] = str.charAt(i);
             }
             return new String(newStr, 0, j);
         }
     }

     /**
      * In INS, there are three meta characters: '.', '/' and '\'.
      */
     private static boolean isMeta(char ch) {
         switch (ch) {
         case kindSeparator:
         case compSeparator:
         case escapeChar:
             return true;
         }
         return false;
     }

     /**
      * An implementation of CompoundName that bypasses the parsing
      * and stringifying code of the default CompoundName.
      */
     static final class CNCompoundName extends CompoundName {
         CNCompoundName(Enumeration<String> enum_) {
             super(enum_, CNNameParser.mySyntax);
         }

         public Object clone() {
             return new CNCompoundName(getAll());
         }

         public Name getPrefix(int posn) {
             Enumeration<String> comps = super.getPrefix(posn).getAll();
             return new CNCompoundName(comps);
         }

         public Name getSuffix(int posn) {
             Enumeration<String> comps = super.getSuffix(posn).getAll();
             return new CNCompoundName(comps);
         }

         public String toString() {
             try {
                 // Convert Name to NameComponent[] then stringify
                 return cosNameToInsString(nameToCosName(this));
             } catch (InvalidNameException e) {
                 return super.toString();
             }
         }

         private static final long serialVersionUID = -6599252802678482317L;
     }

 // for testing only
 /*
     private static void print(String input) {
         try {
             System.out.println("\n >>>>>> input: " + input);

             System.out.println("--Compound Name: ");
             NameParser parser = new CNNameParser();
             Name name = parser.parse(input);
             for (int i = 0; i < name.size(); i++) {
                 System.out.println("\t" + i + ": " + name.get(i));
                 NameComponent cp = parseComponent(name.get(i));
                 System.out.println("\t\t" + "id: " + cp.id + ";kind: " + cp.kind);
             }
             System.out.println("\t" + name.toString());

             System.out.println("--Composite Name: ");
             Name composite = new CompositeName(input);
             for (int i = 0; i < composite.size(); i++) {
                 System.out.println("\t" + i+": " + composite.get(i));
             }
             System.out.println("\t" + composite.toString());

             System.out.println("--Composite To NameComponent");
             NameComponent[] names = nameToCosName(composite);
             for (int i = 0; i < composite.size(); i++) {
                 System.out.println("\t" + i+": id: " + names[i].id + "; kind: " + names[i].kind);
             }
             System.out.println("\t" + cosNameToInsString(names));
         } catch (NamingException e) {
             System.out.println(e);
         }
     }

     private static void checkName(Name name, String[] comps) throws Exception {
         if (name.size() != comps.length) {
             throw new Exception(
                 "test failed; incorrect component count in " + name + "; " +
                 "expecting " + comps.length + " got " + name.size());
         }
         for (int i = 0; i < name.size(); i++) {
             if (!comps[i].equals(name.get(i))) {
                 throw new Exception (
                     "test failed; invalid component in " + name + "; " +
                     "expecting '" + comps[i] + "' got '" + name.get(i) + "'");
             }
         }
     }

     private static void checkCompound(NameParser parser,
         String input, String[] comps) throws Exception {
         checkName(parser.parse(input), comps);
     }

     private static void checkComposite(String input, String[] comps)
     throws Exception {
         checkName(new CompositeName(input), comps);
     }

     private static String[] compounds = {
         "a/b/c",
         "a.b/c.d",
         "a",
         ".",
         "a.",
         "c.d",
         ".e",
         "a/x\\/y\\/z/b",
         "a\\.b.c\\.d/e.f",
         "a/b\\\\/c",
         "x\\\\.y",
         "x\\.y",
         "x.\\\\y",
         "x.y\\\\",
         "\\\\x.y",
         "a.b\\.c/d"
     };
     private static String[][] compoundComps = {
         {"a", "b", "c"},
         {"a.b", "c.d"},
         {"a"},
         {"."},
         {"a"},
         {"c.d"},
         {".e"},
         {"a", "x\\/y\\/z", "b"},
         {"a\\.b.c\\.d", "e.f"},
         {"a", "b\\\\", "c"},
         {"x\\\\.y"},
         {"x\\.y"},
         {"x.\\\\y"},
         {"x.y\\\\"},
         {"\\\\x.y"},
         {"a.b\\.c", "d"},
     };

     private static String[] composites = {
         "a/b/c",
         "a.b/c.d",
         "a",
         ".",
         "a.",
         "c.d",
         ".e",
         "a/x\\\\\\/y\\\\\\/z/b",
         "a\\\\.b.c\\\\.d/e.f",
         "a/b\\\\\\\\/c",
         "x\\\\\\.y",
         "x\\\\.y",
         "x.\\\\\\\\y",
         "x.y\\\\\\\\",
         "\\\\\\\\x.y"
     };

     private static String[][] compositeComps = {
         {"a", "b", "c"},
         {"a.b", "c.d"},
         {"a"},
         {"."},
         {"a."},  // unlike compound, kind sep is not consumed
         {"c.d"},
         {".e"},
         {"a", "x\\/y\\/z", "b"},
         {"a\\.b.c\\.d", "e.f"},
         {"a", "b\\\\", "c"},
         {"x\\\\.y"},
         {"x\\.y"},
         {"x.\\\\y"},
         {"x.y\\\\"},
         {"\\\\x.y"}
     };

     public static void main(String[] args) throws Exception {
         if (args.length > 0) {
             for (int i = 0; i < args.length; i++) {
                 print(args[0]);
             }
         } else {
             print("x\\\\.y");
             print("x\\.y");
             print("x.\\\\y");
             print("x.y\\\\");
             print("\\\\x.y");
         }

         NameParser parser = new com.sun.jndi.cosnaming.CNNameParser();
         for (int i = 0; i < compounds.length; i++) {
             checkCompound(parser, compounds[i], compoundComps[i]);
         }
         for (int i = 0; i < composites.length; i++) {
             checkComposite(composites[i], compositeComps[i]);
         }

         System.out.println("hardwire");
         NameComponent[] foo = new NameComponent[1];
         foo[0] = new NameComponent("foo\\", "bar");

         System.out.println(cosNameToInsString(foo));
         System.out.println(cosNameToName(foo));
     }
 */
 }
	/*
	* Copyright (c) 1999, 2011, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/

	package com.sun.jndi.cosnaming;

	import javax.naming.*;
	import java.util.Properties;
	import java.util.Vector;
	import java.util.Enumeration;

	import org.omg.CosNaming.NameComponent;

	/**
	* Parsing routines for NameParser as well as COS Naming stringified names.
	* This is used by CNCtx to create a NameComponent[] object and vice versa.
	* It follows Section 4.5 of Interoperable Naming Service (INS) 98-10-11.
	* In summary, the stringified form is a left-to-right, forward-slash
	* separated name. id and kinds are separated by '.'. backslash is the
	* escape character.
	*
	* @author Rosanna Lee
	*/

	final public class CNNameParser implements NameParser {

	private static final Properties mySyntax = new Properties();
	private static final char kindSeparator = '.';
	private static final char compSeparator = '/';
	private static final char escapeChar = '\\';
	static {
	mySyntax.put("jndi.syntax.direction", "left_to_right");
	mySyntax.put("jndi.syntax.separator", ""+compSeparator);
	mySyntax.put("jndi.syntax.escape", ""+escapeChar);
	};

	/**
	* Constructs a new name parser for parsing names in INS syntax.
	*/
	public CNNameParser() {
	}

	/**
	* Returns a CompoundName given a string in INS syntax.
	* @param name The non-null string representation of the name.
	* @return a non-null CompoundName
	*/
	public Name parse(String name) throws NamingException {
	Vector<String> comps = insStringToStringifiedComps(name);
	return new CNCompoundName(comps.elements());
	}

	/**
	* Creates a NameComponent[] from a Name structure.
	* Used by CNCtx to convert the input Name arg into a NameComponent[].
	* @param a CompoundName or a CompositeName;
	* each component must be the stringified form of a NameComponent.
	*/
	static NameComponent[] nameToCosName(Name name)
	throws InvalidNameException {
	int len = name.size();
	if (len == 0) {
	return new NameComponent[0];
	}

	NameComponent[] answer = new NameComponent[len];
	for (int i = 0; i < len; i++) {
	answer[i] = parseComponent(name.get(i));
	}
	return answer;
	}

	/**
	* Returns the INS stringified form of a NameComponent[].
	* Used by CNCtx.getNameInNamespace(), CNCompoundName.toString().
	*/
	static String cosNameToInsString(NameComponent[] cname) {
	StringBuffer str = new StringBuffer();
	for ( int i = 0; i < cname.length; i++) {
	if ( i > 0) {
	str.append(compSeparator);
	}
	str.append(stringifyComponent(cname[i]));
	}
	return str.toString();
	}

	/**
	* Creates a CompositeName from a NameComponent[].
	* Used by ExceptionMapper and CNBindingEnumeration to convert
	* a NameComponent[] into a composite name.
	*/
	static Name cosNameToName(NameComponent[] cname) {
	Name nm = new CompositeName();
	for ( int i = 0; cname != null && i < cname.length; i++) {
	try {
	nm.add(stringifyComponent(cname[i]));
	} catch (InvalidNameException e) {
	// ignore
	}
	}
	return nm;
	}

	/**
	* Converts an INS-syntax string name into a Vector in which
	* each element of the vector contains a stringified form of
	* a NameComponent.
	*/
	private static Vector<String> insStringToStringifiedComps(String str)
	throws InvalidNameException {

	int len = str.length();
	Vector<String> components = new Vector<>(10);
	char[] id = new char[len];
	char[] kind = new char[len];
	int idCount, kindCount;
	boolean idMode;
	for (int i = 0; i < len; ) {
	idCount = kindCount = 0; // reset for new component
	idMode = true; // always start off parsing id
	while (i < len) {
	if (str.charAt(i) == compSeparator) {
	break;

	} else if (str.charAt(i) == escapeChar) {
	if (i + 1 >= len) {
	throw new InvalidNameException(str +
	": unescaped \\ at end of component");
	} else if (isMeta(str.charAt(i+1))) {
	++i; // skip escape and let meta through
	if (idMode) {
	id[idCount++] = str.charAt(i++);
	} else {
	kind[kindCount++] = str.charAt(i++);
	}
	} else {
	throw new InvalidNameException(str +
	": invalid character being escaped");
	}

	} else if (idMode && str.charAt(i) == kindSeparator) {
	// just look for the first kindSeparator
	++i; // skip kind separator
	idMode = false;

	} else {
	if (idMode) {
	id[idCount++] = str.charAt(i++);
	} else {
	kind[kindCount++] = str.charAt(i++);
	}
	}
	}
	components.addElement(stringifyComponent(
	new NameComponent(new String(id, 0, idCount),
	new String(kind, 0, kindCount))));

	if (i < len) {
	++i; // skip separator
	}
	}

	return components;
	}

	/**
	* Return a NameComponent given its stringified form.
	*/
	private static NameComponent parseComponent(String compStr)
	throws InvalidNameException {
	NameComponent comp = new NameComponent();
	int kindSep = -1;
	int len = compStr.length();

	int j = 0;
	char[] newStr = new char[len];
	boolean escaped = false;

	// Find the kind separator
	for (int i = 0; i < len && kindSep < 0; i++) {
	if (escaped) {
	newStr[j++] = compStr.charAt(i);
	escaped = false;
	} else if (compStr.charAt(i) == escapeChar) {
	if (i + 1 >= len) {
	throw new InvalidNameException(compStr +
	": unescaped \\ at end of component");
	} else if (isMeta(compStr.charAt(i+1))) {
	escaped = true;
	} else {
	throw new InvalidNameException(compStr +
	": invalid character being escaped");
	}
	} else if (compStr.charAt(i) == kindSeparator) {
	kindSep = i;
	} else {
	newStr[j++] = compStr.charAt(i);
	}
	}

	// Set id
	comp.id = new String(newStr, 0, j);

	// Set kind
	if (kindSep < 0) {
	comp.kind = ""; // no kind separator
	} else {
	// unescape kind
	j = 0;
	escaped = false;
	for (int i = kindSep+1; i < len; i++) {
	if (escaped) {
	newStr[j++] = compStr.charAt(i);
	escaped = false;
	} else if (compStr.charAt(i) == escapeChar) {
	if (i + 1 >= len) {
	throw new InvalidNameException(compStr +
	": unescaped \\ at end of component");
	} else if (isMeta(compStr.charAt(i+1))) {
	escaped = true;
	} else {
	throw new InvalidNameException(compStr +
	": invalid character being escaped");
	}
	} else {
	newStr[j++] = compStr.charAt(i);
	}
	}
	comp.kind = new String(newStr, 0, j);
	}
	return comp;
	}

	private static String stringifyComponent(NameComponent comp) {
	StringBuffer one = new StringBuffer(escape(comp.id));
	if (comp.kind != null && !comp.kind.equals("")) {
	one.append(kindSeparator + escape(comp.kind));
	}
	if (one.length() == 0) {
	return ""+kindSeparator; // if neither id nor kind specified
	} else {
	return one.toString();
	}
	}

	/**
	* Returns a string with '.', '\', '/' escaped. Used when
	* stringifying the name into its INS stringified form.
	*/
	private static String escape(String str) {
	if (str.indexOf(kindSeparator) < 0 &&
	str.indexOf(compSeparator) < 0 &&
	str.indexOf(escapeChar) < 0) {
	return str; // no meta characters to escape
	} else {
	int len = str.length();
	int j = 0;
	char[] newStr = new char[len+len];
	for (int i = 0; i < len; i++) {
	if (isMeta(str.charAt(i))) {
	newStr[j++] = escapeChar; // escape meta character
	}
	newStr[j++] = str.charAt(i);
	}
	return new String(newStr, 0, j);
	}
	}

	/**
	* In INS, there are three meta characters: '.', '/' and '\'.
	*/
	private static boolean isMeta(char ch) {
	switch (ch) {
	case kindSeparator:
	case compSeparator:
	case escapeChar:
	return true;
	}
	return false;
	}

	/**
	* An implementation of CompoundName that bypasses the parsing
	* and stringifying code of the default CompoundName.
	*/
	static final class CNCompoundName extends CompoundName {
	CNCompoundName(Enumeration<String> enum_) {
	super(enum_, CNNameParser.mySyntax);
	}

	public Object clone() {
	return new CNCompoundName(getAll());
	}

	public Name getPrefix(int posn) {
	Enumeration<String> comps = super.getPrefix(posn).getAll();
	return new CNCompoundName(comps);
	}

	public Name getSuffix(int posn) {
	Enumeration<String> comps = super.getSuffix(posn).getAll();
	return new CNCompoundName(comps);
	}

	public String toString() {
	try {
	// Convert Name to NameComponent[] then stringify
	return cosNameToInsString(nameToCosName(this));
	} catch (InvalidNameException e) {
	return super.toString();
	}
	}

	private static final long serialVersionUID = -6599252802678482317L;
	}

	// for testing only
	/*
	private static void print(String input) {
	try {
	System.out.println("\n >>>>>> input: " + input);

	System.out.println("--Compound Name: ");
	NameParser parser = new CNNameParser();
	Name name = parser.parse(input);
	for (int i = 0; i < name.size(); i++) {
	System.out.println("\t" + i + ": " + name.get(i));
	NameComponent cp = parseComponent(name.get(i));
	System.out.println("\t\t" + "id: " + cp.id + ";kind: " + cp.kind);
	}
	System.out.println("\t" + name.toString());

	System.out.println("--Composite Name: ");
	Name composite = new CompositeName(input);
	for (int i = 0; i < composite.size(); i++) {
	System.out.println("\t" + i+": " + composite.get(i));
	}
	System.out.println("\t" + composite.toString());

	System.out.println("--Composite To NameComponent");
	NameComponent[] names = nameToCosName(composite);
	for (int i = 0; i < composite.size(); i++) {
	System.out.println("\t" + i+": id: " + names[i].id + "; kind: " + names[i].kind);
	}
	System.out.println("\t" + cosNameToInsString(names));
	} catch (NamingException e) {
	System.out.println(e);
	}
	}

	private static void checkName(Name name, String[] comps) throws Exception {
	if (name.size() != comps.length) {
	throw new Exception(
	"test failed; incorrect component count in " + name + "; " +
	"expecting " + comps.length + " got " + name.size());
	}
	for (int i = 0; i < name.size(); i++) {
	if (!comps[i].equals(name.get(i))) {
	throw new Exception (
	"test failed; invalid component in " + name + "; " +
	"expecting '" + comps[i] + "' got '" + name.get(i) + "'");
	}
	}
	}

	private static void checkCompound(NameParser parser,
	String input, String[] comps) throws Exception {
	checkName(parser.parse(input), comps);
	}

	private static void checkComposite(String input, String[] comps)
	throws Exception {
	checkName(new CompositeName(input), comps);
	}

	private static String[] compounds = {
	"a/b/c",
	"a.b/c.d",
	"a",
	".",
	"a.",
	"c.d",
	".e",
	"a/x\\/y\\/z/b",
	"a\\.b.c\\.d/e.f",
	"a/b\\\\/c",
	"x\\\\.y",
	"x\\.y",
	"x.\\\\y",
	"x.y\\\\",
	"\\\\x.y",
	"a.b\\.c/d"
	};
	private static String[][] compoundComps = {
	{"a", "b", "c"},
	{"a.b", "c.d"},
	{"a"},
	{"."},
	{"a"},
	{"c.d"},
	{".e"},
	{"a", "x\\/y\\/z", "b"},
	{"a\\.b.c\\.d", "e.f"},
	{"a", "b\\\\", "c"},
	{"x\\\\.y"},
	{"x\\.y"},
	{"x.\\\\y"},
	{"x.y\\\\"},
	{"\\\\x.y"},
	{"a.b\\.c", "d"},
	};

	private static String[] composites = {
	"a/b/c",
	"a.b/c.d",
	"a",
	".",
	"a.",
	"c.d",
	".e",
	"a/x\\\\\\/y\\\\\\/z/b",
	"a\\\\.b.c\\\\.d/e.f",
	"a/b\\\\\\\\/c",
	"x\\\\\\.y",
	"x\\\\.y",
	"x.\\\\\\\\y",
	"x.y\\\\\\\\",
	"\\\\\\\\x.y"
	};

	private static String[][] compositeComps = {
	{"a", "b", "c"},
	{"a.b", "c.d"},
	{"a"},
	{"."},
	{"a."}, // unlike compound, kind sep is not consumed
	{"c.d"},
	{".e"},
	{"a", "x\\/y\\/z", "b"},
	{"a\\.b.c\\.d", "e.f"},
	{"a", "b\\\\", "c"},
	{"x\\\\.y"},
	{"x\\.y"},
	{"x.\\\\y"},
	{"x.y\\\\"},
	{"\\\\x.y"}
	};

	public static void main(String[] args) throws Exception {
	if (args.length > 0) {
	for (int i = 0; i < args.length; i++) {
	print(args[0]);
	}
	} else {
	print("x\\\\.y");
	print("x\\.y");
	print("x.\\\\y");
	print("x.y\\\\");
	print("\\\\x.y");
	}

	NameParser parser = new com.sun.jndi.cosnaming.CNNameParser();
	for (int i = 0; i < compounds.length; i++) {
	checkCompound(parser, compounds[i], compoundComps[i]);
	}
	for (int i = 0; i < composites.length; i++) {
	checkComposite(composites[i], compositeComps[i]);
	}

	System.out.println("hardwire");
	NameComponent[] foo = new NameComponent[1];
	foo[0] = new NameComponent("foo\\", "bar");

	System.out.println(cosNameToInsString(foo));
	System.out.println(cosNameToName(foo));
	}
	*/
	}