| /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
| ~ Licensed to the Apache Software Foundation (ASF) under one |
| ~ or more contributor license agreements. See the NOTICE file |
| ~ distributed with this work for additional information |
| ~ regarding copyright ownership. The ASF licenses this file |
| ~ to you under the Apache License, Version 2.0 (the |
| ~ "License"); you may not use this file except in compliance |
| ~ with the License. You may obtain a copy of the License at |
| ~ |
| ~ http://www.apache.org/licenses/LICENSE-2.0 |
| ~ |
| ~ Unless required by applicable law or agreed to in writing, |
| ~ software distributed under the License is distributed on an |
| ~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| ~ KIND, either express or implied. See the License for the |
| ~ specific language governing permissions and limitations |
| ~ under the License. |
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/ |
| package org.apache.sling.commons.compiler.source; |
| |
| import java.util.HashSet; |
| import java.util.Set; |
| import java.util.regex.Matcher; |
| import java.util.regex.Pattern; |
| |
| import org.jetbrains.annotations.NotNull; |
| |
| /** |
| * The {@code JavaEscapeHelper} class provides various methods which can be used to generate valid Java identifiers or package / class |
| * names, especially when generating them from a transcompiler. |
| */ |
| public final class JavaEscapeHelper { |
| |
| private static final Set<String> javaKeywords = new HashSet<>(); |
| private static final Set<String> literals = new HashSet<>(); |
| private static final Set<String> specialIdentifiers = new HashSet<>(); |
| private static final Pattern ESCAPED_CHAR_PATTERN = Pattern.compile("(__[0-9a-f]{4}__)"); |
| |
| private JavaEscapeHelper() { |
| } |
| |
| static { |
| javaKeywords.add("abstract"); |
| javaKeywords.add("assert"); |
| javaKeywords.add("boolean"); |
| javaKeywords.add("break"); |
| javaKeywords.add("byte"); |
| javaKeywords.add("case"); |
| javaKeywords.add("catch"); |
| javaKeywords.add("char"); |
| javaKeywords.add("class"); |
| javaKeywords.add("const"); |
| javaKeywords.add("continue"); |
| javaKeywords.add("default"); |
| javaKeywords.add("do"); |
| javaKeywords.add("double"); |
| javaKeywords.add("else"); |
| javaKeywords.add("enum"); |
| javaKeywords.add("extends"); |
| javaKeywords.add("final"); |
| javaKeywords.add("finally"); |
| javaKeywords.add("float"); |
| javaKeywords.add("for"); |
| javaKeywords.add("goto"); |
| javaKeywords.add("if"); |
| javaKeywords.add("implements"); |
| javaKeywords.add("import"); |
| javaKeywords.add("instanceof"); |
| javaKeywords.add("int"); |
| javaKeywords.add("interface"); |
| javaKeywords.add("long"); |
| javaKeywords.add("native"); |
| javaKeywords.add("new"); |
| javaKeywords.add("package"); |
| javaKeywords.add("private"); |
| javaKeywords.add("protected"); |
| javaKeywords.add("public"); |
| javaKeywords.add("return"); |
| javaKeywords.add("short"); |
| javaKeywords.add("static"); |
| javaKeywords.add("strictfp"); |
| javaKeywords.add("super"); |
| javaKeywords.add("switch"); |
| javaKeywords.add("synchronized"); |
| javaKeywords.add("this"); |
| javaKeywords.add("throw"); |
| javaKeywords.add("throws"); |
| javaKeywords.add("transient"); |
| javaKeywords.add("try"); |
| javaKeywords.add("void"); |
| javaKeywords.add("volatile"); |
| javaKeywords.add("while"); |
| javaKeywords.add("_"); |
| |
| literals.add("true"); |
| literals.add("false"); |
| literals.add("null"); |
| |
| specialIdentifiers.add("var"); |
| } |
| |
| /** |
| * Converts the given identifier to a legal Java identifier. |
| * |
| * @param identifier the identifier to convert |
| * @return legal Java identifier corresponding to the given identifier |
| */ |
| public static @NotNull String getJavaIdentifier(@NotNull String identifier) { |
| StringBuilder modifiedIdentifier = new StringBuilder(); |
| char[] identifierChars = new char[identifier.length()]; |
| identifier.getChars(0, identifier.length(), identifierChars, 0); |
| for (int i = 0; i < identifierChars.length; i++) { |
| char ch = identifierChars[i]; |
| if (i == 0 && !Character.isJavaIdentifierStart(ch)) { |
| modifiedIdentifier.append(escapeChar(ch)); |
| } else { |
| if (!Character.isJavaIdentifierPart(ch)) { |
| modifiedIdentifier.append(escapeChar(ch)); |
| } else { |
| modifiedIdentifier.append(ch); |
| } |
| } |
| } |
| String currentIdentifier = modifiedIdentifier.toString(); |
| if (isJavaKeyword(currentIdentifier) || isJavaLiteral(currentIdentifier) || isSpecialIdentifier(currentIdentifier)) { |
| return escapeChar(currentIdentifier.charAt(0)) + currentIdentifier.substring(1); |
| } |
| return currentIdentifier; |
| } |
| |
| /** |
| * Escapes the provided character so that it's a valid Java identifier character. This method does not check if the provided |
| * character is valid and will escape any character into a sequence matching the {@code (__[0-9a-f]{4}__)} pattern, by using the |
| * character's decimal code and converting it to hexadecimal. |
| * |
| * @param ch the character to escape |
| * @return the escaped character representation |
| */ |
| public static @NotNull String escapeChar(char ch) { |
| return String.format("__%04x__", (int) ch); |
| } |
| |
| /** |
| * Returns the original character that was escaped, given an {@code escapeSequence}. The {@code escapeSequence} has to match the |
| * {@code (__[0-9a-f]{4}__)} pattern. |
| * |
| * @param escapeSequence the escaped string |
| * @return the original character |
| * @throws IllegalArgumentException if the {@code escaped} string does not match the (__[0-9a-f]{4}__) pattern |
| */ |
| public static char unescape(@NotNull String escapeSequence) { |
| Matcher matcher = ESCAPED_CHAR_PATTERN.matcher(escapeSequence); |
| if (matcher.matches() && matcher.groupCount() == 1) { |
| String toProcess = escapeSequence.replace("__", ""); |
| return (char) Integer.parseInt(toProcess, 16); |
| } |
| throw new IllegalArgumentException( |
| String.format("String '%s' does not match pattern %s.", escapeSequence, ESCAPED_CHAR_PATTERN.pattern())); |
| } |
| |
| /** |
| * Provided a string which could contain escape sequences generated through {@link #escapeChar(char)}, this method will unescape all |
| * such sequences. |
| * |
| * @param input a string containing escaped characters |
| * @return a string with all escaped sequences produced by {@link #escapeChar(char)} replaced by the original character |
| */ |
| public static @NotNull String unescapeAll(@NotNull String input) { |
| String unescaped = input; |
| Matcher matcher = ESCAPED_CHAR_PATTERN.matcher(unescaped); |
| while (matcher.find()) { |
| String group = matcher.group(); |
| char unescapedChar = unescape(group); |
| unescaped = unescaped.replace(group, Character.toString(unescapedChar)); |
| } |
| return unescaped; |
| } |
| |
| /** |
| * Converts the given {@code path} to a Java package or fully-qualified class name, depending on the {@code path}'s value. |
| * |
| * @param path the path to convert |
| * @return Java package / fully-qualified class name corresponding to the given path |
| */ |
| public static @NotNull String makeJavaPackage(@NotNull String path) { |
| String[] classNameComponents = path.split("/|\\\\"); |
| StringBuilder legalClassNames = new StringBuilder(); |
| for (int i = 0; i < classNameComponents.length; i++) { |
| String classNameComponent = classNameComponents[i]; |
| if (classNameComponent.isEmpty()) { |
| continue; |
| } |
| legalClassNames.append(getJavaIdentifier(classNameComponent)); |
| if (i < classNameComponents.length - 1) { |
| legalClassNames.append('.'); |
| } |
| } |
| return legalClassNames.toString(); |
| } |
| |
| /** |
| * Test whether the argument is a Java keyword, according to the |
| * <a href="https://docs.oracle.com/javase/specs/jls/se13/html/jls-3.html#jls-3.9">Java Language Specification</a>. |
| * |
| * @param key the String to test |
| * @return {@code true} if the String is a Java keyword, {@code false} otherwise |
| */ |
| public static boolean isJavaKeyword(@NotNull String key) { |
| return javaKeywords.contains(key); |
| } |
| |
| /** |
| * Test whether the argument is a Java literal, according to the |
| * <a href="https://docs.oracle.com/javase/specs/jls/se13/html/jls-3.html#jls-3.9">Java Language Specification</a>.. |
| * |
| * @param key the String to test |
| * @return {@code true} if the String is a Java literal, {@code false} otherwise |
| */ |
| public static boolean isJavaLiteral(@NotNull String key) { |
| return literals.contains(key); |
| } |
| |
| /** |
| * Test whether the argument is a special identifier, according to the |
| * a href="https://docs.oracle.com/javase/specs/jls/se13/html/jls-3.html#jls-3.9">Java Language Specification</a>.. |
| * |
| * @param key the String to test |
| * @return {@code true} if the String is a Java special identifier, {@code false} otherwise |
| */ |
| public static boolean isSpecialIdentifier(@NotNull String key) { |
| return specialIdentifiers.contains(key); |
| } |
| |
| |
| } |
