All Downloads are FREE. Search and download functionalities are using the official Maven repository.

com.lowagie.text.xml.simpleparser.EntitiesToUnicode Maven / Gradle / Ivy

There is a newer version: 1.2.2.1-jre17
Show newest version
/*
 * $Id: EntitiesToUnicode.java 3373 2008-05-12 16:21:24Z xlv $
 *
 * Copyright 2003-2007 Paulo Soares and Bruno Lowagie.
 *
 * The contents of this file are subject to the Mozilla Public License Version 1.1
 * (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.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
 * for the specific language governing rights and limitations under the License.
 *
 * The Original Code is 'iText, a free JAVA-PDF library'.
 *
 * The Initial Developer of the Original Code is Bruno Lowagie. Portions created by
 * the Initial Developer are Copyright (C) 1999, 2000, 2001, 2002 by Bruno Lowagie.
 * All Rights Reserved.
 * Co-Developer of the code is Paulo Soares. Portions created by the Co-Developer
 * are Copyright (C) 2000, 2001, 2002 by Paulo Soares. All Rights Reserved.
 *
 * Contributor(s): all the names of the contributors are added in the source code
 * where applicable.
 *
 * Alternatively, the contents of this file may be used under the terms of the
 * LGPL license (the "GNU LIBRARY GENERAL PUBLIC LICENSE"), in which case the
 * provisions of LGPL are applicable instead of those above.  If you wish to
 * allow use of your version of this file only under the terms of the LGPL
 * License and not to allow others to use your version of this file under
 * the MPL, indicate your decision by deleting the provisions above and
 * replace them with the notice and other provisions required by the LGPL.
 * If you do not delete the provisions above, a recipient may use your version
 * of this file under either the MPL or the GNU LIBRARY GENERAL PUBLIC LICENSE.
 *
 * This library is free software; you can redistribute it and/or modify it
 * under the terms of the MPL as stated above or under the terms of the GNU
 * Library General Public License as published by the Free Software Foundation;
 * either version 2 of the License, or any later version.
 *
 * This library 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 Library general Public License for more
 * details.
 *
 * If you didn't download this code from the following link, you should check if
 * you aren't using an obsolete version:
 * https://github.com/LibrePDF/OpenPDF
 */

package com.lowagie.text.xml.simpleparser;

import java.util.HashMap;
import java.util.Map;

/**
 * This class contains entities that can be used in an entity tag.
 */

@SuppressWarnings("deprecated")
public class EntitiesToUnicode {

    public static Map getMap() {
        return map;
    }

    /**
     * This is a map that contains the names of entities and their unicode value.
     *
     * @deprecated use the getter ({@link EntitiesToUnicode#getMap()}) instead of accessing this field directly
     */
    @Deprecated
    public static final HashMap map = new HashMap<>();

    static {
        map.put("nbsp", '\u00a0'); // no-break space = non-breaking space, U+00A0 ISOnum
        map.put("iexcl", '\u00a1'); // inverted exclamation mark, U+00A1 ISOnum
        map.put("cent", '\u00a2'); // cent sign, U+00A2 ISOnum
        map.put("pound", '\u00a3'); // pound sign, U+00A3 ISOnum
        map.put("curren", '\u00a4'); // currency sign, U+00A4 ISOnum
        map.put("yen", '\u00a5'); // yen sign = yuan sign, U+00A5 ISOnum
        map.put("brvbar", '\u00a6'); // broken bar = broken vertical bar, U+00A6 ISOnum
        map.put("sect", '\u00a7'); // section sign, U+00A7 ISOnum
        map.put("uml", '\u00a8'); // diaeresis = spacing diaeresis, U+00A8 ISOdia
        map.put("copy", '\u00a9'); // copyright sign, U+00A9 ISOnum
        map.put("ordf", '\u00aa'); // feminine ordinal indicator, U+00AA ISOnum
        map.put("laquo", '\u00ab'); // left-pointing double angle quotation mark = left pointing guillemet, U+00AB ISOnum
        map.put("not", '\u00ac'); // not sign, U+00AC ISOnum
        map.put("shy", '\u00ad'); // soft hyphen = discretionary hyphen, U+00AD ISOnum
        map.put("reg", '\u00ae'); // registered sign = registered trade mark sign, U+00AE ISOnum
        map.put("macr", '\u00af'); // macron = spacing macron = overline = APL overbar, U+00AF ISOdia
        map.put("deg", '\u00b0'); // degree sign, U+00B0 ISOnum
        map.put("plusmn", '\u00b1'); // plus-minus sign = plus-or-minus sign, U+00B1 ISOnum
        map.put("sup2", '\u00b2'); // superscript two = superscript digit two = squared, U+00B2 ISOnum
        map.put("sup3", '\u00b3'); // superscript three = superscript digit three = cubed, U+00B3 ISOnum
        map.put("acute", '\u00b4'); // acute accent = spacing acute, U+00B4 ISOdia
        map.put("micro", '\u00b5'); // micro sign, U+00B5 ISOnum
        map.put("para", '\u00b6'); // pilcrow sign = paragraph sign, U+00B6 ISOnum
        map.put("middot", '\u00b7'); // middle dot = Georgian comma = Greek middle dot, U+00B7 ISOnum
        map.put("cedil", '\u00b8'); // cedilla = spacing cedilla, U+00B8 ISOdia
        map.put("sup1", '\u00b9'); // superscript one = superscript digit one, U+00B9 ISOnum
        map.put("ordm", '\u00ba'); // masculine ordinal indicator, U+00BA ISOnum
        map.put("raquo", '\u00bb'); // right-pointing double angle quotation mark = right pointing guillemet, U+00BB ISOnum
        map.put("frac14", '\u00bc'); // vulgar fraction one quarter = fraction one quarter, U+00BC ISOnum
        map.put("frac12", '\u00bd'); // vulgar fraction one half = fraction one half, U+00BD ISOnum
        map.put("frac34", '\u00be'); // vulgar fraction three quarters = fraction three quarters, U+00BE ISOnum
        map.put("iquest", '\u00bf'); // inverted question mark = turned question mark, U+00BF ISOnum
        map.put("Agrave", '\u00c0'); // latin capital letter A with grave = latin capital letter A grave, U+00C0 ISOlat1
        map.put("Aacute", '\u00c1'); // latin capital letter A with acute, U+00C1 ISOlat1
        map.put("Acirc", '\u00c2'); // latin capital letter A with circumflex, U+00C2 ISOlat1
        map.put("Atilde", '\u00c3'); // latin capital letter A with tilde, U+00C3 ISOlat1
        map.put("Auml", '\u00c4'); // latin capital letter A with diaeresis, U+00C4 ISOlat1
        map.put("Aring", '\u00c5'); // latin capital letter A with ring above = latin capital letter A ring, U+00C5 ISOlat1
        map.put("AElig", '\u00c6'); // latin capital letter AE = latin capital ligature AE, U+00C6 ISOlat1
        map.put("Ccedil", '\u00c7'); // latin capital letter C with cedilla, U+00C7 ISOlat1
        map.put("Egrave", '\u00c8'); // latin capital letter E with grave, U+00C8 ISOlat1
        map.put("Eacute", '\u00c9'); // latin capital letter E with acute, U+00C9 ISOlat1
        map.put("Ecirc", '\u00ca'); // latin capital letter E with circumflex, U+00CA ISOlat1
        map.put("Euml", '\u00cb'); // latin capital letter E with diaeresis, U+00CB ISOlat1
        map.put("Igrave", '\u00cc'); // latin capital letter I with grave, U+00CC ISOlat1
        map.put("Iacute", '\u00cd'); // latin capital letter I with acute, U+00CD ISOlat1
        map.put("Icirc", '\u00ce'); // latin capital letter I with circumflex, U+00CE ISOlat1
        map.put("Iuml", '\u00cf'); // latin capital letter I with diaeresis, U+00CF ISOlat1
        map.put("ETH", '\u00d0'); // latin capital letter ETH, U+00D0 ISOlat1
        map.put("Ntilde", '\u00d1'); // latin capital letter N with tilde, U+00D1 ISOlat1
        map.put("Ograve", '\u00d2'); // latin capital letter O with grave, U+00D2 ISOlat1
        map.put("Oacute", '\u00d3'); // latin capital letter O with acute, U+00D3 ISOlat1
        map.put("Ocirc", '\u00d4'); // latin capital letter O with circumflex, U+00D4 ISOlat1
        map.put("Otilde", '\u00d5'); // latin capital letter O with tilde, U+00D5 ISOlat1
        map.put("Ouml", '\u00d6'); // latin capital letter O with diaeresis, U+00D6 ISOlat1
        map.put("times", '\u00d7'); // multiplication sign, U+00D7 ISOnum
        map.put("Oslash", '\u00d8'); // latin capital letter O with stroke = latin capital letter O slash, U+00D8 ISOlat1
        map.put("Ugrave", '\u00d9'); // latin capital letter U with grave, U+00D9 ISOlat1
        map.put("Uacute", '\u00da'); // latin capital letter U with acute, U+00DA ISOlat1
        map.put("Ucirc", '\u00db'); // latin capital letter U with circumflex, U+00DB ISOlat1
        map.put("Uuml", '\u00dc'); // latin capital letter U with diaeresis, U+00DC ISOlat1
        map.put("Yacute", '\u00dd'); // latin capital letter Y with acute, U+00DD ISOlat1
        map.put("THORN", '\u00de'); // latin capital letter THORN, U+00DE ISOlat1
        map.put("szlig", '\u00df'); // latin small letter sharp s = ess-zed, U+00DF ISOlat1
        map.put("agrave", '\u00e0'); // latin small letter a with grave = latin small letter a grave, U+00E0 ISOlat1
        map.put("aacute", '\u00e1'); // latin small letter a with acute, U+00E1 ISOlat1
        map.put("acirc", '\u00e2'); // latin small letter a with circumflex, U+00E2 ISOlat1
        map.put("atilde", '\u00e3'); // latin small letter a with tilde, U+00E3 ISOlat1
        map.put("auml", '\u00e4'); // latin small letter a with diaeresis, U+00E4 ISOlat1
        map.put("aring", '\u00e5'); // latin small letter a with ring above = latin small letter a ring, U+00E5 ISOlat1
        map.put("aelig", '\u00e6'); // latin small letter ae = latin small ligature ae, U+00E6 ISOlat1
        map.put("ccedil", '\u00e7'); // latin small letter c with cedilla, U+00E7 ISOlat1
        map.put("egrave", '\u00e8'); // latin small letter e with grave, U+00E8 ISOlat1
        map.put("eacute", '\u00e9'); // latin small letter e with acute, U+00E9 ISOlat1
        map.put("ecirc", '\u00ea'); // latin small letter e with circumflex, U+00EA ISOlat1
        map.put("euml", '\u00eb'); // latin small letter e with diaeresis, U+00EB ISOlat1
        map.put("igrave", '\u00ec'); // latin small letter i with grave, U+00EC ISOlat1
        map.put("iacute", '\u00ed'); // latin small letter i with acute, U+00ED ISOlat1
        map.put("icirc", '\u00ee'); // latin small letter i with circumflex, U+00EE ISOlat1
        map.put("iuml", '\u00ef'); // latin small letter i with diaeresis, U+00EF ISOlat1
        map.put("eth", '\u00f0'); // latin small letter eth, U+00F0 ISOlat1
        map.put("ntilde", '\u00f1'); // latin small letter n with tilde, U+00F1 ISOlat1
        map.put("ograve", '\u00f2'); // latin small letter o with grave, U+00F2 ISOlat1
        map.put("oacute", '\u00f3'); // latin small letter o with acute, U+00F3 ISOlat1
        map.put("ocirc", '\u00f4'); // latin small letter o with circumflex, U+00F4 ISOlat1
        map.put("otilde", '\u00f5'); // latin small letter o with tilde, U+00F5 ISOlat1
        map.put("ouml", '\u00f6'); // latin small letter o with diaeresis, U+00F6 ISOlat1
        map.put("divide", '\u00f7'); // division sign, U+00F7 ISOnum
        map.put("oslash", '\u00f8'); // latin small letter o with stroke, = latin small letter o slash, U+00F8 ISOlat1
        map.put("ugrave", '\u00f9'); // latin small letter u with grave, U+00F9 ISOlat1
        map.put("uacute", '\u00fa'); // latin small letter u with acute, U+00FA ISOlat1
        map.put("ucirc", '\u00fb'); // latin small letter u with circumflex, U+00FB ISOlat1
        map.put("uuml", '\u00fc'); // latin small letter u with diaeresis, U+00FC ISOlat1
        map.put("yacute", '\u00fd'); // latin small letter y with acute, U+00FD ISOlat1
        map.put("thorn", '\u00fe'); // latin small letter thorn, U+00FE ISOlat1
        map.put("yuml", '\u00ff'); // latin small letter y with diaeresis, U+00FF ISOlat1
        // Latin Extended-B
        map.put("fnof", '\u0192'); // latin small f with hook = function = florin, U+0192 ISOtech
        // Greek
        map.put("Alpha", '\u0391'); // greek capital letter alpha, U+0391
        map.put("Beta", '\u0392'); // greek capital letter beta, U+0392
        map.put("Gamma", '\u0393'); // greek capital letter gamma, U+0393 ISOgrk3
        map.put("Delta", '\u0394'); // greek capital letter delta, U+0394 ISOgrk3
        map.put("Epsilon", '\u0395'); // greek capital letter epsilon, U+0395
        map.put("Zeta", '\u0396'); // greek capital letter zeta, U+0396
        map.put("Eta", '\u0397'); // greek capital letter eta, U+0397
        map.put("Theta", '\u0398'); // greek capital letter theta, U+0398 ISOgrk3
        map.put("Iota", '\u0399'); // greek capital letter iota, U+0399
        map.put("Kappa", '\u039a'); // greek capital letter kappa, U+039A
        map.put("Lambda", '\u039b'); // greek capital letter lambda, U+039B ISOgrk3
        map.put("Mu", '\u039c'); // greek capital letter mu, U+039C
        map.put("Nu", '\u039d'); // greek capital letter nu, U+039D
        map.put("Xi", '\u039e'); // greek capital letter xi, U+039E ISOgrk3
        map.put("Omicron", '\u039f'); // greek capital letter omicron, U+039F
        map.put("Pi", '\u03a0'); // greek capital letter pi, U+03A0 ISOgrk3
        map.put("Rho", '\u03a1'); // greek capital letter rho, U+03A1
        // there is no Sigmaf, and no U+03A2 character either
        map.put("Sigma", '\u03a3'); // greek capital letter sigma, U+03A3 ISOgrk3
        map.put("Tau", '\u03a4'); // greek capital letter tau, U+03A4
        map.put("Upsilon", '\u03a5'); // greek capital letter upsilon, U+03A5 ISOgrk3
        map.put("Phi", '\u03a6'); // greek capital letter phi, U+03A6 ISOgrk3
        map.put("Chi", '\u03a7'); // greek capital letter chi, U+03A7
        map.put("Psi", '\u03a8'); // greek capital letter psi, U+03A8 ISOgrk3
        map.put("Omega", '\u03a9'); // greek capital letter omega, U+03A9 ISOgrk3
        map.put("alpha", '\u03b1'); // greek small letter alpha, U+03B1 ISOgrk3
        map.put("beta", '\u03b2'); // greek small letter beta, U+03B2 ISOgrk3
        map.put("gamma", '\u03b3'); // greek small letter gamma, U+03B3 ISOgrk3
        map.put("delta", '\u03b4'); // greek small letter delta, U+03B4 ISOgrk3
        map.put("epsilon", '\u03b5'); // greek small letter epsilon, U+03B5 ISOgrk3
        map.put("zeta", '\u03b6'); // greek small letter zeta, U+03B6 ISOgrk3
        map.put("eta", '\u03b7'); // greek small letter eta, U+03B7 ISOgrk3
        map.put("theta", '\u03b8'); // greek small letter theta, U+03B8 ISOgrk3
        map.put("iota", '\u03b9'); // greek small letter iota, U+03B9 ISOgrk3
        map.put("kappa", '\u03ba'); // greek small letter kappa, U+03BA ISOgrk3
        map.put("lambda", '\u03bb'); // greek small letter lambda, U+03BB ISOgrk3
        map.put("mu", '\u03bc'); // greek small letter mu, U+03BC ISOgrk3
        map.put("nu", '\u03bd'); // greek small letter nu, U+03BD ISOgrk3
        map.put("xi", '\u03be'); // greek small letter xi, U+03BE ISOgrk3
        map.put("omicron", '\u03bf'); // greek small letter omicron, U+03BF NEW
        map.put("pi", '\u03c0'); // greek small letter pi, U+03C0 ISOgrk3
        map.put("rho", '\u03c1'); // greek small letter rho, U+03C1 ISOgrk3
        map.put("sigmaf", '\u03c2'); // greek small letter final sigma, U+03C2 ISOgrk3
        map.put("sigma", '\u03c3'); // greek small letter sigma, U+03C3 ISOgrk3
        map.put("tau", '\u03c4'); // greek small letter tau, U+03C4 ISOgrk3
        map.put("upsilon", '\u03c5'); // greek small letter upsilon, U+03C5 ISOgrk3
        map.put("phi", '\u03c6'); // greek small letter phi, U+03C6 ISOgrk3
        map.put("chi", '\u03c7'); // greek small letter chi, U+03C7 ISOgrk3
        map.put("psi", '\u03c8'); // greek small letter psi, U+03C8 ISOgrk3
        map.put("omega", '\u03c9'); // greek small letter omega, U+03C9 ISOgrk3
        map.put("thetasym", '\u03d1'); // greek small letter theta symbol, U+03D1 NEW
        map.put("upsih", '\u03d2'); // greek upsilon with hook symbol, U+03D2 NEW
        map.put("piv", '\u03d6'); // greek pi symbol, U+03D6 ISOgrk3
        // General Punctuation
        map.put("bull", '\u2022'); // bullet = black small circle, U+2022 ISOpub
        // bullet is NOT the same as bullet operator, U+2219
        map.put("hellip", '\u2026'); // horizontal ellipsis = three dot leader, U+2026 ISOpub
        map.put("prime", '\u2032'); // prime = minutes = feet, U+2032 ISOtech
        map.put("Prime", '\u2033'); // double prime = seconds = inches, U+2033 ISOtech
        map.put("oline", '\u203e'); // overline = spacing overscore, U+203E NEW
        map.put("frasl", '\u2044'); // fraction slash, U+2044 NEW
        // Letterlike Symbols
        map.put("weierp", '\u2118'); // script capital P = power set = Weierstrass p, U+2118 ISOamso
        map.put("image", '\u2111'); // blackletter capital I = imaginary part, U+2111 ISOamso
        map.put("real", '\u211c'); // blackletter capital R = real part symbol, U+211C ISOamso
        map.put("trade", '\u2122'); // trade mark sign, U+2122 ISOnum
        map.put("alefsym", '\u2135'); // alef symbol = first transfinite cardinal, U+2135 NEW
        // alef symbol is NOT the same as hebrew letter alef,
        // U+05D0 although the same glyph could be used to depict both characters
        // Arrows
        map.put("larr", '\u2190'); // leftwards arrow, U+2190 ISOnum
        map.put("uarr", '\u2191'); // upwards arrow, U+2191 ISOnum
        map.put("rarr", '\u2192'); // rightwards arrow, U+2192 ISOnum
        map.put("darr", '\u2193'); // downwards arrow, U+2193 ISOnum
        map.put("harr", '\u2194'); // left right arrow, U+2194 ISOamsa
        map.put("crarr", '\u21b5'); // downwards arrow with corner leftwards = carriage return, U+21B5 NEW
        map.put("lArr", '\u21d0'); // leftwards double arrow, U+21D0 ISOtech
        // ISO 10646 does not say that lArr is the same as the 'is implied by' arrow
        // but also does not have any other character for that function. So ? lArr can
        // be used for 'is implied by' as ISOtech suggests
        map.put("uArr", '\u21d1'); // upwards double arrow, U+21D1 ISOamsa
        map.put("rArr", '\u21d2'); // rightwards double arrow, U+21D2 ISOtech
        // ISO 10646 does not say this is the 'implies' character but does not have 
        // another character with this function so ?
        // rArr can be used for 'implies' as ISOtech suggests
        map.put("dArr", '\u21d3'); // downwards double arrow, U+21D3 ISOamsa
        map.put("hArr", '\u21d4'); // left right double arrow, U+21D4 ISOamsa
        // Mathematical Operators
        map.put("forall", '\u2200'); // for all, U+2200 ISOtech
        map.put("part", '\u2202'); // partial differential, U+2202 ISOtech
        map.put("exist", '\u2203'); // there exists, U+2203 ISOtech
        map.put("empty", '\u2205'); // empty set = null set = diameter, U+2205 ISOamso
        map.put("nabla", '\u2207'); // nabla = backward difference, U+2207 ISOtech
        map.put("isin", '\u2208'); // element of, U+2208 ISOtech
        map.put("notin", '\u2209'); // not an element of, U+2209 ISOtech
        map.put("ni", '\u220b'); // contains as member, U+220B ISOtech
        // should there be a more memorable name than 'ni'?
        map.put("prod", '\u220f'); // n-ary product = product sign, U+220F ISOamsb
        // prod is NOT the same character as U+03A0 'greek capital letter pi' though
        // the same glyph might be used for both
        map.put("sum", '\u2211'); // n-ary sumation, U+2211 ISOamsb
        // sum is NOT the same character as U+03A3 'greek capital letter sigma'
        // though the same glyph might be used for both
        map.put("minus", '\u2212'); // minus sign, U+2212 ISOtech
        map.put("lowast", '\u2217'); // asterisk operator, U+2217 ISOtech
        map.put("radic", '\u221a'); // square root = radical sign, U+221A ISOtech
        map.put("prop", '\u221d'); // proportional to, U+221D ISOtech
        map.put("infin", '\u221e'); // infinity, U+221E ISOtech
        map.put("ang", '\u2220'); // angle, U+2220 ISOamso
        map.put("and", '\u2227'); // logical and = wedge, U+2227 ISOtech
        map.put("or", '\u2228'); // logical or = vee, U+2228 ISOtech
        map.put("cap", '\u2229'); // intersection = cap, U+2229 ISOtech
        map.put("cup", '\u222a'); // union = cup, U+222A ISOtech
        map.put("int", '\u222b'); // integral, U+222B ISOtech
        map.put("there4", '\u2234'); // therefore, U+2234 ISOtech
        map.put("sim", '\u223c'); // tilde operator = varies with = similar to, U+223C ISOtech
        // tilde operator is NOT the same character as the tilde, U+007E,
        // although the same glyph might be used to represent both
        map.put("cong", '\u2245'); // approximately equal to, U+2245 ISOtech
        map.put("asymp", '\u2248'); // almost equal to = asymptotic to, U+2248 ISOamsr
        map.put("ne", '\u2260'); // not equal to, U+2260 ISOtech
        map.put("equiv", '\u2261'); // identical to, U+2261 ISOtech
        map.put("le", '\u2264'); // less-than or equal to, U+2264 ISOtech
        map.put("ge", '\u2265'); // greater-than or equal to, U+2265 ISOtech
        map.put("sub", '\u2282'); // subset of, U+2282 ISOtech
        map.put("sup", '\u2283'); // superset of, U+2283 ISOtech
        // note that nsup, 'not a superset of, U+2283' is not covered by the Symbol 
        // font encoding and is not included. Should it be, for symmetry?
        // It is in ISOamsn
        map.put("nsub", '\u2284'); // not a subset of, U+2284 ISOamsn
        map.put("sube", '\u2286'); // subset of or equal to, U+2286 ISOtech
        map.put("supe", '\u2287'); // superset of or equal to, U+2287 ISOtech
        map.put("oplus", '\u2295'); // circled plus = direct sum, U+2295 ISOamsb
        map.put("otimes", '\u2297'); // circled times = vector product, U+2297 ISOamsb
        map.put("perp", '\u22a5'); // up tack = orthogonal to = perpendicular, U+22A5 ISOtech
        map.put("sdot", '\u22c5'); // dot operator, U+22C5 ISOamsb
        // dot operator is NOT the same character as U+00B7 middle dot
        // Miscellaneous Technical
        map.put("lceil", '\u2308'); // left ceiling = apl upstile, U+2308 ISOamsc
        map.put("rceil", '\u2309'); // right ceiling, U+2309 ISOamsc
        map.put("lfloor", '\u230a'); // left floor = apl downstile, U+230A ISOamsc
        map.put("rfloor", '\u230b'); // right floor, U+230B ISOamsc
        map.put("lang", '\u2329'); // left-pointing angle bracket = bra, U+2329 ISOtech
        // lang is NOT the same character as U+003C 'less than' 
        // or U+2039 'single left-pointing angle quotation mark'
        map.put("rang", '\u232a'); // right-pointing angle bracket = ket, U+232A ISOtech
        // rang is NOT the same character as U+003E 'greater than' 
        // or U+203A 'single right-pointing angle quotation mark'
        // Geometric Shapes
        map.put("loz", '\u25ca'); // lozenge, U+25CA ISOpub
        // Miscellaneous Symbols
        map.put("spades", '\u2660'); // black spade suit, U+2660 ISOpub
        // black here seems to mean filled as opposed to hollow
        map.put("clubs", '\u2663'); // black club suit = shamrock, U+2663 ISOpub
        map.put("hearts", '\u2665'); // black heart suit = valentine, U+2665 ISOpub
        map.put("diams", '\u2666'); // black diamond suit, U+2666 ISOpub
        // C0 Controls and Basic Latin
        map.put("quot", '\u0022'); // quotation mark = APL quote, U+0022 ISOnum
        map.put("amp", '\u0026'); // ampersand, U+0026 ISOnum
        map.put("apos", '\'');
        map.put("lt", '\u003c'); // less-than sign, U+003C ISOnum
        map.put("gt", '\u003e'); // greater-than sign, U+003E ISOnum
        // Latin Extended-A
        map.put("OElig", '\u0152'); // latin capital ligature OE, U+0152 ISOlat2
        map.put("oelig", '\u0153'); // latin small ligature oe, U+0153 ISOlat2
        // ligature is a misnomer, this is a separate character in some languages
        map.put("Scaron", '\u0160'); // latin capital letter S with caron, U+0160 ISOlat2
        map.put("scaron", '\u0161'); // latin small letter s with caron, U+0161 ISOlat2
        map.put("Yuml", '\u0178'); // latin capital letter Y with diaeresis, U+0178 ISOlat2
        // Spacing Modifier Letters
        map.put("circ", '\u02c6'); // modifier letter circumflex accent, U+02C6 ISOpub
        map.put("tilde", '\u02dc'); // small tilde, U+02DC ISOdia
        // General Punctuation
        map.put("ensp", '\u2002'); // en space, U+2002 ISOpub
        map.put("emsp", '\u2003'); // em space, U+2003 ISOpub
        map.put("thinsp", '\u2009'); // thin space, U+2009 ISOpub
        map.put("zwnj", '\u200c'); // zero width non-joiner, U+200C NEW RFC 2070
        map.put("zwj", '\u200d'); // zero width joiner, U+200D NEW RFC 2070
        map.put("lrm", '\u200e'); // left-to-right mark, U+200E NEW RFC 2070
        map.put("rlm", '\u200f'); // right-to-left mark, U+200F NEW RFC 2070
        map.put("ndash", '\u2013'); // en dash, U+2013 ISOpub
        map.put("mdash", '\u2014'); // em dash, U+2014 ISOpub
        map.put("lsquo", '\u2018'); // left single quotation mark, U+2018 ISOnum
        map.put("rsquo", '\u2019'); // right single quotation mark, U+2019 ISOnum
        map.put("sbquo", '\u201a'); // single low-9 quotation mark, U+201A NEW
        map.put("ldquo", '\u201c'); // left double quotation mark, U+201C ISOnum
        map.put("rdquo", '\u201d'); // right double quotation mark, U+201D ISOnum
        map.put("bdquo", '\u201e'); // double low-9 quotation mark, U+201E NEW
        map.put("dagger", '\u2020'); // dagger, U+2020 ISOpub
        map.put("Dagger", '\u2021'); // double dagger, U+2021 ISOpub
        map.put("permil", '\u2030'); // per mille sign, U+2030 ISOtech
        map.put("lsaquo", '\u2039'); // single left-pointing angle quotation mark, U+2039 ISO proposed
        // lsaquo is proposed but not yet ISO standardized
        map.put("rsaquo", '\u203a'); // single right-pointing angle quotation mark, U+203A ISO proposed
        // rsaquo is proposed but not yet ISO standardized
        map.put("euro", '\u20ac'); // euro sign, U+20AC NEW
    }
    

    /**
     * Translates an entity to a unicode character.
     *
     * @param    name    the name of the entity
     * @return    the corresponding unicode character
     */
    public static char decodeEntity(String name) {
        if (name.startsWith("#x")) {
            try {
                return (char)Integer.parseInt(name.substring(2),16);
            }
            catch(NumberFormatException nfe) {
                return '\0';
            }
        }
        if (name.startsWith("#")) {
            try {
                return (char)Integer.parseInt(name.substring(1));
            }
            catch(NumberFormatException nfe) {
                return '\0';
            }
        }
        Character c = map.get(name);
        if (c == null)
            return '\0';
        else
            return c;
    }
    
    /**
     * Translates a String with entities {@literal (&...;)} to a String without entities,
     * replacing the entity with the right (unicode) character.
     *
     * @param s string to be decoded
     * @return a ddecoded string
     */
    public static String decodeString(String s) {
        int pos_amp = s.indexOf('&');
        if (pos_amp == -1) return s;
        
        int pos_sc;
        int pos_a;
        StringBuilder buf = new StringBuilder(s.substring(0, pos_amp));
        char replace;
        while (true) {
            pos_sc = s.indexOf(';', pos_amp);
            if (pos_sc == -1) {
                buf.append(s.substring(pos_amp));
                return buf.toString();
            }
            pos_a = s.indexOf('&', pos_amp + 1);
            while (pos_a != -1 && pos_a < pos_sc) {
                buf.append(s, pos_amp, pos_a);
                pos_amp = pos_a;
                pos_a = s.indexOf('&', pos_amp + 1);
            }
            replace = decodeEntity(s.substring(pos_amp + 1, pos_sc));
            if (s.length() < pos_sc + 1) {
                return buf.toString();
            }
            if (replace == '\0') {
                buf.append(s, pos_amp, pos_sc + 1);
            }
            else {
                buf.append(replace);
            }
            pos_amp = s.indexOf('&', pos_sc);
            if (pos_amp == -1) {
                buf.append(s.substring(pos_sc + 1));
                return buf.toString();
            }
            else {
                buf.append(s, pos_sc + 1, pos_amp);
            }
        }
    }
}




© 2015 - 2024 Weber Informatics LLC | Privacy Policy