    001    /*
    002     * Licensed to the Apache Software Foundation (ASF) under one or more
    003     * contributor license agreements.  See the NOTICE file distributed with
    004     * this work for additional information regarding copyright ownership.
    005     * The ASF licenses this file to You under the Apache License, Version 2.0
    006     * (the "License"); you may not use this file except in compliance with
    007     * the License.  You may obtain a copy of the License at
    008     *
    009     *      http://www.apache.org/licenses/LICENSE-2.0
    010     *
    011     * Unless required by applicable law or agreed to in writing, software
    012     * distributed under the License is distributed on an "AS IS" BASIS,
    013     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    014     * See the License for the specific language governing permissions and
    015     * limitations under the License.
    016     */
    017    package org.apache.commons.lang3.text.translate;
    018
    019    import java.io.IOException;
    020    import java.io.Writer;
    021    import java.util.Arrays;
    022    import java.util.EnumSet;
    023
    024    /**
    025     * Translate XML numeric entities of the form &#[xX]?\d+;? to
    026     * the specific codepoint.
    027     *
    028     * Note that the semi-colon is optional.
    029     *
    030     * @since 3.0
    031     * @version $Id: NumericEntityUnescaper.java 1199894 2011-11-09 17:53:59Z ggregory $
    032     */
    033    public class NumericEntityUnescaper extends CharSequenceTranslator {
    034
    035        public static enum OPTION { semiColonRequired, semiColonOptional, errorIfNoSemiColon }
    036
    037        // TODO?: Create an OptionsSet class to hide some of the conditional logic below
    038        private final EnumSet<OPTION> options;
    039
    040        /**
    041         * Create a UnicodeUnescaper.
    042         *
    043         * The constructor takes a list of options, only one type of which is currently
    044         * available (whether to allow, error or ignore the semi-colon on the end of a
    045         * numeric entity to being missing).
    046         *
    047         * For example, to support numeric entities without a ';':
    048         *    new NumericEntityUnescaper(NumericEntityUnescaper.OPTION.semiColonOptional)
    049         * and to throw an IllegalArgumentException when they're missing:
    050         *    new NumericEntityUnescaper(NumericEntityUnescaper.OPTION.errorIfNoSemiColon)
    051         *
    052         * Note that the default behaviour is to ignore them.
    053         *
    054         * @param options to apply to this unescaper
    055         */
    056        public NumericEntityUnescaper(OPTION... options) {
    057            if(options.length > 0) {
    058                this.options = EnumSet.copyOf(Arrays.asList(options));
    059            } else {
    060                this.options = EnumSet.copyOf(Arrays.asList(new OPTION[] { OPTION.semiColonRequired }));
    061            }
    062        }
    063
    064        /**
    065         * Whether the passed in option is currently set.
    066         *
    067         * @param option to check state of
    068         * @return whether the option is set
    069         */
    070        public boolean isSet(OPTION option) {
    071            return options == null ? false : options.contains(option);
    072        }
    073
    074        /**
    075         * {@inheritDoc}
    076         */
    077        @Override
    078        public int translate(CharSequence input, int index, Writer out) throws IOException {
    079            int seqEnd = input.length();
    080            // Uses -2 to ensure there is something after the &#
    081            if(input.charAt(index) == '&' && index < seqEnd - 2 && input.charAt(index + 1) == '#') {
    082                int start = index + 2;
    083                boolean isHex = false;
    084
    085                char firstChar = input.charAt(start);
    086                if(firstChar == 'x' || firstChar == 'X') {
    087                    start++;
    088                    isHex = true;
    089
    090                    // Check there's more than just an x after the &#
    091                    if(start == seqEnd) {
    092                        return 0;
    093                    }
    094                }
    095
    096                int end = start;
    097                // Note that this supports character codes without a ; on the end
    098                while(end < seqEnd && ( input.charAt(end) >= '0' && input.charAt(end) <= '9' ||
    099                                        input.charAt(end) >= 'a' && input.charAt(end) <= 'f' ||
    100                                        input.charAt(end) >= 'A' && input.charAt(end) <= 'F' ) )
    101                {
    102                    end++;
    103                }
    104
    105                boolean semiNext = end != seqEnd && input.charAt(end) == ';';
    106
    107                if(!semiNext) {
    108                    if(isSet(OPTION.semiColonRequired)) {
    109                        return 0;
    110                    } else
    111                    if(isSet(OPTION.errorIfNoSemiColon)) {
    112                        throw new IllegalArgumentException("Semi-colon required at end of numeric entity");
    113                    }
    114                }
    115
    116                int entityValue;
    117                try {
    118                    if(isHex) {
    119                        entityValue = Integer.parseInt(input.subSequence(start, end).toString(), 16);
    120                    } else {
    121                        entityValue = Integer.parseInt(input.subSequence(start, end).toString(), 10);
    122                    }
    123                } catch(NumberFormatException nfe) {
    124                    return 0;
    125                }
    126
    127                if(entityValue > 0xFFFF) {
    128                    char[] chrs = Character.toChars(entityValue);
    129                    out.write(chrs[0]);
    130                    out.write(chrs[1]);
    131                } else {
    132                    out.write(entityValue);
    133                }
    134
    135                return 2 + end - start + (isHex ? 1 : 0) + (semiNext ? 1 : 0);
    136            }
    137            return 0;
    138        }
    139    }