<change id="TreeUtilities.exotic">

             <api name="general"/>

             <summary>Added support for encoding/decoding exotic identifiers to TreeUtilities.</summary>

             <version major="0" minor="56"/>

             <date day="24" month="2" year="2010"/>

             <author login="jlahoda"/>

             <compatibility addition="yes" binary="compatible" deletion="no" deprecation="no" modification="no" semantic="compatible" source="compatible"/>

             <description>

                Added support for encoding/decoding exotic identifiers to <code>TreeUtilities</code>.

             </description>

             <class package="org.netbeans.api.java.source" name="TreeUtilities"/>

             <issue number="999999"/>

        </change>

import org.netbeans.api.annotations.common.NonNull;

import org.netbeans.api.lexer.Token;

    /**Decode escapes defined in: http://wikis.sun.com/display/mlvm/ProjectCoinProposal, 3.1-3.9.

     * Must be a full token text, including possible #".

     *

     * @param text to decode

     * @return decoded escapes from the identifier

     * @see http://wikis.sun.com/display/mlvm/ProjectCoinProposal

     * @since 0.56

     */

    public @NonNull CharSequence decodeIdentifier(@NonNull CharSequence text) {

        return decodeIdentifierInternal(text);

    }

    /**Encode identifier using escapes defined in: http://wikis.sun.com/display/mlvm/ProjectCoinProposal, 3.1-3.9.

     *

     * @param text to encode

     * @return encoded identifier, including #" if necessary

     * @see http://wikis.sun.com/display/mlvm/ProjectCoinProposal

     * @since 0.56

     */

    public @NonNull CharSequence encodeIdentifier(@NonNull CharSequence ident) {

        return encodeIdentifierInternal(ident);

    }

    static @NonNull CharSequence decodeIdentifierInternal(@NonNull CharSequence text) {

        if (text.charAt(0) != '#') {

            return text;

        }

        int count = text.charAt(text.length() - 1) == '"' ? text.length() - 1 : text.length();

        StringBuilder sb = new StringBuilder(text.length());

        for (int c = 2; c < count; c++) {

            if (text.charAt(c) == '\\' && ++c < count) {

                if (EXOTIC_ESCAPE.contains(text.charAt(c))) {

                    sb.append('\\');

                    sb.append(text.charAt(c));

                } else {

                    //XXX: handle \012

                    Character remaped = ESCAPE_UNENCODE.get(text.charAt(c));

                    if (remaped != null) {

                        sb.append(remaped);

                    } else {

                        //TODO: illegal?

                        sb.append(text.charAt(c));

                    }

                }

            } else {

                sb.append(text.charAt(c));

            }

        }

        return sb.toString();

    }

    static @NonNull CharSequence encodeIdentifierInternal(@NonNull CharSequence ident) {

        if (ident.length() == 0) {

            //???

            return ident;

        }

        StringBuilder sb = new StringBuilder(ident.length());

        boolean needsExotic = Character.isJavaIdentifierStart(ident.charAt(0));

        //XXX: code points?

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

            char c = ident.charAt(i);

            if (Character.isJavaIdentifierPart(c)) {

                sb.append(c);

                continue;

            }

            needsExotic = true;

            Character target = ESCAPE_ENCODE.get(c);

            if (target != null) {

                sb.append('\\');

                sb.append(target);

            } else {

                sb.append(c);

            }

        }

        if (needsExotic) {

            sb.append("\"");

            sb.insert(0, "#\"");

            return sb.toString();

        } else {

            return ident;

        }

    }

    static Set<Character> EXOTIC_ESCAPE = new HashSet<Character>(

            Arrays.<Character>asList('!', '#', '$', '%', '&', '(', ')', '*', '+', ',', '-',

                                     ':', '=', '?', '@', '^', '_', '`', '{', '|', '}')

    );

    private static final Map<Character, Character> ESCAPE_UNENCODE;

    private static final Map<Character, Character> ESCAPE_ENCODE;

    static {

        Map<Character, Character> unencode = new HashMap<Character, Character>();

        unencode.put('n', '\n');

        unencode.put('t', '\t');

        unencode.put('b', '\b');

        unencode.put('r', '\r');

        ESCAPE_UNENCODE = Collections.unmodifiableMap(unencode);

        Map<Character, Character> encode = new HashMap<Character, Character>();

        encode.put('\n', 'n');

        encode.put('\t', 't');

        encode.put('\b', 'b');

        encode.put('\r', 'r');

        ESCAPE_ENCODE = Collections.unmodifiableMap(encode);

    }

    public void testExoticIdentifiers() throws Exception {

        performExoticIdentiferDecodeTest("#\"a\"", "a");

        for (char c : TreeUtilities.EXOTIC_ESCAPE) {

            performExoticIdentiferDecodeTest("#\"\\" + c + "\"", "\\" + c);

        }

        performExoticIdentiferDecodeTest("#\"\\n\"", "\n");

        performExoticIdentiferDecodeTest("a", "a");

        performExoticIdentiferEncodeTest("\n", "#\"\\n\"");

    }

    private void performExoticIdentiferDecodeTest(String exotic, String golden) throws Exception {

        assertEquals(golden, TreeUtilities.decodeIdentifierInternal(exotic).toString());

    }

    private void performExoticIdentiferEncodeTest(String exotic, String golden) throws Exception {

        assertEquals(golden, TreeUtilities.encodeIdentifierInternal(exotic).toString());

    }