Index: src/org/apache/poi/hssf/usermodel/contrib/HSSFCellUtil.java =================================================================== RCS file: /home/cvspublic/jakarta-poi/src/contrib/src/org/apache/poi/hssf/usermodel/contrib/HSSFCellUtil.java,v retrieving revision 1.6 diff -u -r1.6 HSSFCellUtil.java --- src/org/apache/poi/hssf/usermodel/contrib/HSSFCellUtil.java 3 May 2003 18:58:44 -0000 1.6 +++ src/org/apache/poi/hssf/usermodel/contrib/HSSFCellUtil.java 18 Jul 2003 09:51:54 -0000 @@ -78,7 +78,17 @@ public class HSSFCellUtil { - private static HashMap unicodeMappings = new HashMap(); + private static Map unicodeMappings = new HashMap(); + + /** + * Return the Map file of HTML escape to unicode mappings. + * Currently protected as only the test cases needs access. + * + *@return The map where the key is the html and value is the Unicode. + */ + protected static Map getUnicodeMappings(){ + return unicodeMappings; + } /** @@ -249,7 +259,9 @@ /** * Looks for text in the cell that should be unicode, like α and provides the - * unicode version of it. + * unicode version of it. It seems like CASE matters, for instance there are as HTML + * escapes both ← and ⇐, which are different. Not sure if we want to deal + * with those or not... * *@param cell The cell to check for unicode values *@return transalted to unicode @@ -264,7 +276,7 @@ { Map.Entry entry = (Map.Entry) i.next(); String key = (String) entry.getKey(); - if ( s.toLowerCase().indexOf( key ) != -1 ) + if ( s.indexOf( key ) != -1 ) { s = StringUtils.replace( s, key, "" + entry.getValue().toString() + "" ); foundUnicode = true; @@ -278,23 +290,342 @@ return cell; } - + static { - unicodeMappings.put( "α", "\u03B1" ); - unicodeMappings.put( "β", "\u03B2" ); - unicodeMappings.put( "γ", "\u03B3" ); - unicodeMappings.put( "δ", "\u03B4" ); - unicodeMappings.put( "ε", "\u03B5" ); - unicodeMappings.put( "ζ", "\u03B6" ); - unicodeMappings.put( "η", "\u03B7" ); - unicodeMappings.put( "θ", "\u03B8" ); - unicodeMappings.put( "ι", "\u03B9" ); - unicodeMappings.put( "κ", "\u03BA" ); - unicodeMappings.put( "λ", "\u03BB" ); - unicodeMappings.put( "μ", "\u03BC" ); - unicodeMappings.put( "ν", "\u03BD" ); - unicodeMappings.put( "ξ", "\u03BE" ); - unicodeMappings.put( "ο", "\u03BF" ); + // Portions © International Organization for Standardization 1986 + // Permission to copy in any form is granted for use with + // conforming SGML systems and applications as defined in + // ISO 8879, provided this notice is included in all copies. + // Character entity set. Typical invocation: + // + // %HTMLlat1; + unicodeMappings.put (" ", "\u00a0"); // no-break space = non-breaking space, U+00A0 ISOnum + unicodeMappings.put ("¡", "\u00a1"); // inverted exclamation mark, U+00A1 ISOnum + unicodeMappings.put ("¢", "\u00a2"); // cent sign, U+00A2 ISOnum + unicodeMappings.put ("£", "\u00a3"); // pound sign, U+00A3 ISOnum + unicodeMappings.put ("¤", "\u00a4"); // currency sign, U+00A4 ISOnum + unicodeMappings.put ("¥", "\u00a5"); // yen sign = yuan sign, U+00A5 ISOnum + unicodeMappings.put ("¦", "\u00a6"); // broken bar = broken vertical bar, U+00A6 ISOnum + unicodeMappings.put ("§", "\u00a7"); // section sign, U+00A7 ISOnum + unicodeMappings.put ("¨", "\u00a8"); // diaeresis = spacing diaeresis, U+00A8 ISOdia + unicodeMappings.put ("©", "\u00a9"); // copyright sign, U+00A9 ISOnum + unicodeMappings.put ("ª", "\u00aa"); // feminine ordinal indicator, U+00AA ISOnum + unicodeMappings.put ("«", "\u00ab"); // left-pointing double angle quotation mark = left pointing guillemet, U+00AB ISOnum + unicodeMappings.put ("¬", "\u00ac"); // not sign, U+00AC ISOnum + unicodeMappings.put ("­", "\u00ad"); // soft hyphen = discretionary hyphen, U+00AD ISOnum + unicodeMappings.put ("®", "\u00ae"); // registered sign = registered trade mark sign, U+00AE ISOnum + unicodeMappings.put ("¯", "\u00af"); // macron = spacing macron = overline = APL overbar, U+00AF ISOdia + unicodeMappings.put ("°", "\u00b0"); // degree sign, U+00B0 ISOnum + unicodeMappings.put ("±", "\u00b1"); // plus-minus sign = plus-or-minus sign, U+00B1 ISOnum + unicodeMappings.put ("²", "\u00b2"); // superscript two = superscript digit two = squared, U+00B2 ISOnum + unicodeMappings.put ("³", "\u00b3"); // superscript three = superscript digit three = cubed, U+00B3 ISOnum + unicodeMappings.put ("´", "\u00b4"); // acute accent = spacing acute, U+00B4 ISOdia + unicodeMappings.put ("µ", "\u00b5"); // micro sign, U+00B5 ISOnum + unicodeMappings.put ("¶", "\u00b6"); // pilcrow sign = paragraph sign, U+00B6 ISOnum + unicodeMappings.put ("·", "\u00b7"); // middle dot = Georgian comma = Greek middle dot, U+00B7 ISOnum + unicodeMappings.put ("¸", "\u00b8"); // cedilla = spacing cedilla, U+00B8 ISOdia + unicodeMappings.put ("¹", "\u00b9"); // superscript one = superscript digit one, U+00B9 ISOnum + unicodeMappings.put ("º", "\u00ba"); // masculine ordinal indicator, U+00BA ISOnum + unicodeMappings.put ("»", "\u00bb"); // right-pointing double angle quotation mark = right pointing guillemet, U+00BB ISOnum + unicodeMappings.put ("¼", "\u00bc"); // vulgar fraction one quarter = fraction one quarter, U+00BC ISOnum + unicodeMappings.put ("½", "\u00bd"); // vulgar fraction one half = fraction one half, U+00BD ISOnum + unicodeMappings.put ("¾", "\u00be"); // vulgar fraction three quarters = fraction three quarters, U+00BE ISOnum + unicodeMappings.put ("¿", "\u00bf"); // inverted question mark = turned question mark, U+00BF ISOnum + unicodeMappings.put ("À", "\u00c0"); // latin capital letter A with grave = latin capital letter A grave, U+00C0 ISOlat1 + unicodeMappings.put ("Á", "\u00c1"); // latin capital letter A with acute, U+00C1 ISOlat1 + unicodeMappings.put ("Â", "\u00c2"); // latin capital letter A with circumflex, U+00C2 ISOlat1 + unicodeMappings.put ("Ã", "\u00c3"); // latin capital letter A with tilde, U+00C3 ISOlat1 + unicodeMappings.put ("Ä", "\u00c4"); // latin capital letter A with diaeresis, U+00C4 ISOlat1 + unicodeMappings.put ("Å", "\u00c5"); // latin capital letter A with ring above = latin capital letter A ring, U+00C5 ISOlat1 + unicodeMappings.put ("Æ", "\u00c6"); // latin capital letter AE = latin capital ligature AE, U+00C6 ISOlat1 + unicodeMappings.put ("Ç", "\u00c7"); // latin capital letter C with cedilla, U+00C7 ISOlat1 + unicodeMappings.put ("È", "\u00c8"); // latin capital letter E with grave, U+00C8 ISOlat1 + unicodeMappings.put ("É", "\u00c9"); // latin capital letter E with acute, U+00C9 ISOlat1 + unicodeMappings.put ("Ê", "\u00ca"); // latin capital letter E with circumflex, U+00CA ISOlat1 + unicodeMappings.put ("Ë", "\u00cb"); // latin capital letter E with diaeresis, U+00CB ISOlat1 + unicodeMappings.put ("Ì", "\u00cc"); // latin capital letter I with grave, U+00CC ISOlat1 + unicodeMappings.put ("Í", "\u00cd"); // latin capital letter I with acute, U+00CD ISOlat1 + unicodeMappings.put ("Î", "\u00ce"); // latin capital letter I with circumflex, U+00CE ISOlat1 + unicodeMappings.put ("Ï", "\u00cf"); // latin capital letter I with diaeresis, U+00CF ISOlat1 + unicodeMappings.put ("Ð", "\u00d0"); // latin capital letter ETH, U+00D0 ISOlat1 + unicodeMappings.put ("Ñ", "\u00d1"); // latin capital letter N with tilde, U+00D1 ISOlat1 + unicodeMappings.put ("Ò", "\u00d2"); // latin capital letter O with grave, U+00D2 ISOlat1 + unicodeMappings.put ("Ó", "\u00d3"); // latin capital letter O with acute, U+00D3 ISOlat1 + unicodeMappings.put ("Ô", "\u00d4"); // latin capital letter O with circumflex, U+00D4 ISOlat1 + unicodeMappings.put ("Õ", "\u00d5"); // latin capital letter O with tilde, U+00D5 ISOlat1 + unicodeMappings.put ("Ö", "\u00d6"); // latin capital letter O with diaeresis, U+00D6 ISOlat1 + unicodeMappings.put ("×", "\u00d7"); // multiplication sign, U+00D7 ISOnum + unicodeMappings.put ("Ø", "\u00d8"); // latin capital letter O with stroke = latin capital letter O slash, U+00D8 ISOlat1 + unicodeMappings.put ("Ù", "\u00d9"); // latin capital letter U with grave, U+00D9 ISOlat1 + unicodeMappings.put ("Ú", "\u00da"); // latin capital letter U with acute, U+00DA ISOlat1 + unicodeMappings.put ("Û", "\u00db"); // latin capital letter U with circumflex, U+00DB ISOlat1 + unicodeMappings.put ("Ü", "\u00dc"); // latin capital letter U with diaeresis, U+00DC ISOlat1 + unicodeMappings.put ("Ý", "\u00dd"); // latin capital letter Y with acute, U+00DD ISOlat1 + unicodeMappings.put ("Þ", "\u00de"); // latin capital letter THORN, U+00DE ISOlat1 + unicodeMappings.put ("ß", "\u00df"); // latin small letter sharp s = ess-zed, U+00DF ISOlat1 + unicodeMappings.put ("à", "\u00e0"); // latin small letter a with grave = latin small letter a grave, U+00E0 ISOlat1 + unicodeMappings.put ("á", "\u00e1"); // latin small letter a with acute, U+00E1 ISOlat1 + unicodeMappings.put ("â", "\u00e2"); // latin small letter a with circumflex, U+00E2 ISOlat1 + unicodeMappings.put ("ã", "\u00e3"); // latin small letter a with tilde, U+00E3 ISOlat1 + unicodeMappings.put ("ä", "\u00e4"); // latin small letter a with diaeresis, U+00E4 ISOlat1 + unicodeMappings.put ("å", "\u00e5"); // latin small letter a with ring above = latin small letter a ring, U+00E5 ISOlat1 + unicodeMappings.put ("æ", "\u00e6"); // latin small letter ae = latin small ligature ae, U+00E6 ISOlat1 + unicodeMappings.put ("ç", "\u00e7"); // latin small letter c with cedilla, U+00E7 ISOlat1 + unicodeMappings.put ("è", "\u00e8"); // latin small letter e with grave, U+00E8 ISOlat1 + unicodeMappings.put ("é", "\u00e9"); // latin small letter e with acute, U+00E9 ISOlat1 + unicodeMappings.put ("ê", "\u00ea"); // latin small letter e with circumflex, U+00EA ISOlat1 + unicodeMappings.put ("ë", "\u00eb"); // latin small letter e with diaeresis, U+00EB ISOlat1 + unicodeMappings.put ("ì", "\u00ec"); // latin small letter i with grave, U+00EC ISOlat1 + unicodeMappings.put ("í", "\u00ed"); // latin small letter i with acute, U+00ED ISOlat1 + unicodeMappings.put ("î", "\u00ee"); // latin small letter i with circumflex, U+00EE ISOlat1 + unicodeMappings.put ("ï", "\u00ef"); // latin small letter i with diaeresis, U+00EF ISOlat1 + unicodeMappings.put ("ð", "\u00f0"); // latin small letter eth, U+00F0 ISOlat1 + unicodeMappings.put ("ñ", "\u00f1"); // latin small letter n with tilde, U+00F1 ISOlat1 + unicodeMappings.put ("ò", "\u00f2"); // latin small letter o with grave, U+00F2 ISOlat1 + unicodeMappings.put ("ó", "\u00f3"); // latin small letter o with acute, U+00F3 ISOlat1 + unicodeMappings.put ("ô", "\u00f4"); // latin small letter o with circumflex, U+00F4 ISOlat1 + unicodeMappings.put ("õ", "\u00f5"); // latin small letter o with tilde, U+00F5 ISOlat1 + unicodeMappings.put ("ö", "\u00f6"); // latin small letter o with diaeresis, U+00F6 ISOlat1 + unicodeMappings.put ("÷", "\u00f7"); // division sign, U+00F7 ISOnum + unicodeMappings.put ("ø", "\u00f8"); // latin small letter o with stroke, = latin small letter o slash, U+00F8 ISOlat1 + unicodeMappings.put ("ù", "\u00f9"); // latin small letter u with grave, U+00F9 ISOlat1 + unicodeMappings.put ("ú", "\u00fa"); // latin small letter u with acute, U+00FA ISOlat1 + unicodeMappings.put ("û", "\u00fb"); // latin small letter u with circumflex, U+00FB ISOlat1 + unicodeMappings.put ("ü", "\u00fc"); // latin small letter u with diaeresis, U+00FC ISOlat1 + unicodeMappings.put ("ý", "\u00fd"); // latin small letter y with acute, U+00FD ISOlat1 + unicodeMappings.put ("þ", "\u00fe"); // latin small letter thorn, U+00FE ISOlat1 + unicodeMappings.put ("ÿ", "\u00ff"); // latin small letter y with diaeresis, U+00FF ISOlat1 + // Mathematical, Greek and Symbolic characters for HTML + // Character entity set. Typical invocation: + // + // %HTMLsymbol; + // Portions © International Organization for Standardization 1986: + // Permission to copy in any form is granted for use with + // conforming SGML systems and applications as defined in + // ISO 8879, provided this notice is included in all copies. + // Relevant ISO entity set is given unless names are newly introduced. + // New names (i.e., not in ISO 8879 list) do not clash with any + // existing ISO 8879 entity names. ISO 10646 character numbers + // are given for each character, in hex. CDATA values are decimal + // conversions of the ISO 10646 values and refer to the document + // character set. Names are ISO 10646 names. + // Latin Extended-B + unicodeMappings.put ("ƒ", "\u0192"); // latin small f with hook = function = florin, U+0192 ISOtech + // Greek + unicodeMappings.put ("Α", "\u0391"); // greek capital letter alpha, U+0391 + unicodeMappings.put ("Β", "\u0392"); // greek capital letter beta, U+0392 + unicodeMappings.put ("Γ", "\u0393"); // greek capital letter gamma, U+0393 ISOgrk3 + unicodeMappings.put ("Δ", "\u0394"); // greek capital letter delta, U+0394 ISOgrk3 + unicodeMappings.put ("Ε", "\u0395"); // greek capital letter epsilon, U+0395 + unicodeMappings.put ("Ζ", "\u0396"); // greek capital letter zeta, U+0396 + unicodeMappings.put ("Η", "\u0397"); // greek capital letter eta, U+0397 + unicodeMappings.put ("Θ", "\u0398"); // greek capital letter theta, U+0398 ISOgrk3 + unicodeMappings.put ("Ι", "\u0399"); // greek capital letter iota, U+0399 + unicodeMappings.put ("Κ", "\u039a"); // greek capital letter kappa, U+039A + unicodeMappings.put ("Λ", "\u039b"); // greek capital letter lambda, U+039B ISOgrk3 + unicodeMappings.put ("Μ", "\u039c"); // greek capital letter mu, U+039C + unicodeMappings.put ("Ν", "\u039d"); // greek capital letter nu, U+039D + unicodeMappings.put ("Ξ", "\u039e"); // greek capital letter xi, U+039E ISOgrk3 + unicodeMappings.put ("Ο", "\u039f"); // greek capital letter omicron, U+039F + unicodeMappings.put ("Π", "\u03a0"); // greek capital letter pi, U+03A0 ISOgrk3 + unicodeMappings.put ("Ρ", "\u03a1"); // greek capital letter rho, U+03A1 + // there is no Sigmaf, and no U+03A2 character either + unicodeMappings.put ("Σ", "\u03a3"); // greek capital letter sigma, U+03A3 ISOgrk3 + unicodeMappings.put ("Τ", "\u03a4"); // greek capital letter tau, U+03A4 + unicodeMappings.put ("Υ", "\u03a5"); // greek capital letter upsilon, U+03A5 ISOgrk3 + unicodeMappings.put ("Φ", "\u03a6"); // greek capital letter phi, U+03A6 ISOgrk3 + unicodeMappings.put ("Χ", "\u03a7"); // greek capital letter chi, U+03A7 + unicodeMappings.put ("Ψ", "\u03a8"); // greek capital letter psi, U+03A8 ISOgrk3 + unicodeMappings.put ("Ω", "\u03a9"); // greek capital letter omega, U+03A9 ISOgrk3 + unicodeMappings.put ("α", "\u03b1"); // greek small letter alpha, U+03B1 ISOgrk3 + unicodeMappings.put ("β", "\u03b2"); // greek small letter beta, U+03B2 ISOgrk3 + unicodeMappings.put ("γ", "\u03b3"); // greek small letter gamma, U+03B3 ISOgrk3 + unicodeMappings.put ("δ", "\u03b4"); // greek small letter delta, U+03B4 ISOgrk3 + unicodeMappings.put ("ε", "\u03b5"); // greek small letter epsilon, U+03B5 ISOgrk3 + unicodeMappings.put ("ζ", "\u03b6"); // greek small letter zeta, U+03B6 ISOgrk3 + unicodeMappings.put ("η", "\u03b7"); // greek small letter eta, U+03B7 ISOgrk3 + unicodeMappings.put ("θ", "\u03b8"); // greek small letter theta, U+03B8 ISOgrk3 + unicodeMappings.put ("ι", "\u03b9"); // greek small letter iota, U+03B9 ISOgrk3 + unicodeMappings.put ("κ", "\u03ba"); // greek small letter kappa, U+03BA ISOgrk3 + unicodeMappings.put ("λ", "\u03bb"); // greek small letter lambda, U+03BB ISOgrk3 + unicodeMappings.put ("μ", "\u03bc"); // greek small letter mu, U+03BC ISOgrk3 + unicodeMappings.put ("ν", "\u03bd"); // greek small letter nu, U+03BD ISOgrk3 + unicodeMappings.put ("ξ", "\u03be"); // greek small letter xi, U+03BE ISOgrk3 + unicodeMappings.put ("ο", "\u03bf"); // greek small letter omicron, U+03BF NEW + unicodeMappings.put ("π", "\u03c0"); // greek small letter pi, U+03C0 ISOgrk3 + unicodeMappings.put ("ρ", "\u03c1"); // greek small letter rho, U+03C1 ISOgrk3 + unicodeMappings.put ("ς", "\u03c2"); // greek small letter final sigma, U+03C2 ISOgrk3 + unicodeMappings.put ("σ", "\u03c3"); // greek small letter sigma, U+03C3 ISOgrk3 + unicodeMappings.put ("τ", "\u03c4"); // greek small letter tau, U+03C4 ISOgrk3 + unicodeMappings.put ("υ", "\u03c5"); // greek small letter upsilon, U+03C5 ISOgrk3 + unicodeMappings.put ("φ", "\u03c6"); // greek small letter phi, U+03C6 ISOgrk3 + unicodeMappings.put ("χ", "\u03c7"); // greek small letter chi, U+03C7 ISOgrk3 + unicodeMappings.put ("ψ", "\u03c8"); // greek small letter psi, U+03C8 ISOgrk3 + unicodeMappings.put ("ω", "\u03c9"); // greek small letter omega, U+03C9 ISOgrk3 + unicodeMappings.put ("ϑ", "\u03d1"); // greek small letter theta symbol, U+03D1 NEW + unicodeMappings.put ("ϒ", "\u03d2"); // greek upsilon with hook symbol, U+03D2 NEW + unicodeMappings.put ("ϖ", "\u03d6"); // greek pi symbol, U+03D6 ISOgrk3 + // General Punctuation + unicodeMappings.put ("•", "\u2022"); // bullet = black small circle, U+2022 ISOpub + // bullet is NOT the same as bullet operator, U+2219 + unicodeMappings.put ("…", "\u2026"); // horizontal ellipsis = three dot leader, U+2026 ISOpub + unicodeMappings.put ("′", "\u2032"); // prime = minutes = feet, U+2032 ISOtech + unicodeMappings.put ("″", "\u2033"); // double prime = seconds = inches, U+2033 ISOtech + unicodeMappings.put ("‾", "\u203e"); // overline = spacing overscore, U+203E NEW + unicodeMappings.put ("⁄", "\u2044"); // fraction slash, U+2044 NEW + // Letterlike Symbols + unicodeMappings.put ("℘", "\u2118"); // script capital P = power set = Weierstrass p, U+2118 ISOamso + unicodeMappings.put ("ℑ", "\u2111"); // blackletter capital I = imaginary part, U+2111 ISOamso + unicodeMappings.put ("ℜ", "\u211c"); // blackletter capital R = real part symbol, U+211C ISOamso + unicodeMappings.put ("™", "\u2122"); // trade mark sign, U+2122 ISOnum + unicodeMappings.put ("ℵ", "\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 + unicodeMappings.put ("←", "\u2190"); // leftwards arrow, U+2190 ISOnum + unicodeMappings.put ("↑", "\u2191"); // upwards arrow, U+2191 ISOnum + unicodeMappings.put ("→", "\u2192"); // rightwards arrow, U+2192 ISOnum + unicodeMappings.put ("↓", "\u2193"); // downwards arrow, U+2193 ISOnum + unicodeMappings.put ("↔", "\u2194"); // left right arrow, U+2194 ISOamsa + unicodeMappings.put ("↵", "\u21b5"); // downwards arrow with corner leftwards = carriage return, U+21B5 NEW + unicodeMappings.put ("⇐", "\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 + unicodeMappings.put ("⇑", "\u21d1"); // upwards double arrow, U+21D1 ISOamsa + unicodeMappings.put ("⇒", "\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 + unicodeMappings.put ("⇓", "\u21d3"); // downwards double arrow, U+21D3 ISOamsa + unicodeMappings.put ("⇔", "\u21d4"); // left right double arrow, U+21D4 ISOamsa + // Mathematical Operators + unicodeMappings.put ("∀", "\u2200"); // for all, U+2200 ISOtech + unicodeMappings.put ("∂", "\u2202"); // partial differential, U+2202 ISOtech + unicodeMappings.put ("∃", "\u2203"); // there exists, U+2203 ISOtech + unicodeMappings.put ("∅", "\u2205"); // empty set = null set = diameter, U+2205 ISOamso + unicodeMappings.put ("∇", "\u2207"); // nabla = backward difference, U+2207 ISOtech + unicodeMappings.put ("∈", "\u2208"); // element of, U+2208 ISOtech + unicodeMappings.put ("∉", "\u2209"); // not an element of, U+2209 ISOtech + unicodeMappings.put ("∋", "\u220b"); // contains as member, U+220B ISOtech + // should there be a more memorable name than 'ni'? + unicodeMappings.put ("∏", "\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 + unicodeMappings.put ("∑", "\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 + unicodeMappings.put ("−", "\u2212"); // minus sign, U+2212 ISOtech + unicodeMappings.put ("∗", "\u2217"); // asterisk operator, U+2217 ISOtech + unicodeMappings.put ("√", "\u221a"); // square root = radical sign, U+221A ISOtech + unicodeMappings.put ("∝", "\u221d"); // proportional to, U+221D ISOtech + unicodeMappings.put ("∞", "\u221e"); // infinity, U+221E ISOtech + unicodeMappings.put ("∠", "\u2220"); // angle, U+2220 ISOamso + unicodeMappings.put ("∧", "\u2227"); // logical and = wedge, U+2227 ISOtech + unicodeMappings.put ("∨", "\u2228"); // logical or = vee, U+2228 ISOtech + unicodeMappings.put ("∩", "\u2229"); // intersection = cap, U+2229 ISOtech + unicodeMappings.put ("∪", "\u222a"); // union = cup, U+222A ISOtech + unicodeMappings.put ("∫", "\u222b"); // integral, U+222B ISOtech + unicodeMappings.put ("∴", "\u2234"); // therefore, U+2234 ISOtech + unicodeMappings.put ("∼", "\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 + unicodeMappings.put ("≅", "\u2245"); // approximately equal to, U+2245 ISOtech + unicodeMappings.put ("≈", "\u2248"); // almost equal to = asymptotic to, U+2248 ISOamsr + unicodeMappings.put ("≠", "\u2260"); // not equal to, U+2260 ISOtech + unicodeMappings.put ("≡", "\u2261"); // identical to, U+2261 ISOtech + unicodeMappings.put ("≤", "\u2264"); // less-than or equal to, U+2264 ISOtech + unicodeMappings.put ("≥", "\u2265"); // greater-than or equal to, U+2265 ISOtech + unicodeMappings.put ("⊂", "\u2282"); // subset of, U+2282 ISOtech + unicodeMappings.put ("⊃", "\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 + unicodeMappings.put ("⊄", "\u2284"); // not a subset of, U+2284 ISOamsn + unicodeMappings.put ("⊆", "\u2286"); // subset of or equal to, U+2286 ISOtech + unicodeMappings.put ("⊇", "\u2287"); // superset of or equal to, U+2287 ISOtech + unicodeMappings.put ("⊕", "\u2295"); // circled plus = direct sum, U+2295 ISOamsb + unicodeMappings.put ("⊗", "\u2297"); // circled times = vector product, U+2297 ISOamsb + unicodeMappings.put ("⊥", "\u22a5"); // up tack = orthogonal to = perpendicular, U+22A5 ISOtech + unicodeMappings.put ("⋅", "\u22c5"); // dot operator, U+22C5 ISOamsb + // dot operator is NOT the same character as U+00B7 middle dot + // Miscellaneous Technical + unicodeMappings.put ("⌈", "\u2308"); // left ceiling = apl upstile, U+2308 ISOamsc + unicodeMappings.put ("⌉", "\u2309"); // right ceiling, U+2309 ISOamsc + unicodeMappings.put ("⌊", "\u230a"); // left floor = apl downstile, U+230A ISOamsc + unicodeMappings.put ("⌋", "\u230b"); // right floor, U+230B ISOamsc + unicodeMappings.put ("⟨", "\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' + unicodeMappings.put ("⟩", "\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 + unicodeMappings.put ("◊", "\u25ca"); // lozenge, U+25CA ISOpub + // Miscellaneous Symbols + unicodeMappings.put ("♠", "\u2660"); // black spade suit, U+2660 ISOpub + // black here seems to mean filled as opposed to hollow + unicodeMappings.put ("♣", "\u2663"); // black club suit = shamrock, U+2663 ISOpub + unicodeMappings.put ("♥", "\u2665"); // black heart suit = valentine, U+2665 ISOpub + unicodeMappings.put ("♦", "\u2666"); // black diamond suit, U+2666 ISOpub + // Special characters for HTML + // Character entity set. Typical invocation: + // + // %HTMLspecial; + // Portions © International Organization for Standardization 1986: + // Permission to copy in any form is granted for use with + // conforming SGML systems and applications as defined in + // ISO 8879, provided this notice is included in all copies. + // Relevant ISO entity set is given unless names are newly introduced. + // New names (i.e., not in ISO 8879 list) do not clash with any + // existing ISO 8879 entity names. ISO 10646 character numbers + // are given for each character, in hex. CDATA values are decimal + // conversions of the ISO 10646 values and refer to the document + // character set. Names are ISO 10646 names. + // C0 Controls and Basic Latin + + // epugh This is a werid one.. If I list it as \u0022, then it doesn't complile, because I think it is a double quote! + unicodeMappings.put (""", "\""); // quotation mark = APL quote, U+0022 ISOnum + unicodeMappings.put ("&", "\u0026"); // ampersand, U+0026 ISOnum + unicodeMappings.put ("<", "\u003c"); // less-than sign, U+003C ISOnum + unicodeMappings.put (">", "\u003e"); // greater-than sign, U+003E ISOnum + // Latin Extended-A + unicodeMappings.put ("Œ", "\u0152"); // latin capital ligature OE, U+0152 ISOlat2 + unicodeMappings.put ("œ", "\u0153"); // latin small ligature oe, U+0153 ISOlat2 + // ligature is a misnomer, this is a separate character in some languages + unicodeMappings.put ("Š", "\u0160"); // latin capital letter S with caron, U+0160 ISOlat2 + unicodeMappings.put ("š", "\u0161"); // latin small letter s with caron, U+0161 ISOlat2 + unicodeMappings.put ("Ÿ", "\u0178"); // latin capital letter Y with diaeresis, U+0178 ISOlat2 + // Spacing Modifier Letters + unicodeMappings.put ("ˆ", "\u02c6"); // modifier letter circumflex accent, U+02C6 ISOpub + unicodeMappings.put ("˜", "\u02dc"); // small tilde, U+02DC ISOdia + // General Punctuation + unicodeMappings.put (" ", "\u2002"); // en space, U+2002 ISOpub + unicodeMappings.put (" ", "\u2003"); // em space, U+2003 ISOpub + unicodeMappings.put (" ", "\u2009"); // thin space, U+2009 ISOpub + unicodeMappings.put ("‌", "\u200c"); // zero width non-joiner, U+200C NEW RFC 2070 + unicodeMappings.put ("‍", "\u200d"); // zero width joiner, U+200D NEW RFC 2070 + unicodeMappings.put ("‎", "\u200e"); // left-to-right mark, U+200E NEW RFC 2070 + unicodeMappings.put ("‏", "\u200f"); // right-to-left mark, U+200F NEW RFC 2070 + unicodeMappings.put ("–", "\u2013"); // en dash, U+2013 ISOpub + unicodeMappings.put ("—", "\u2014"); // em dash, U+2014 ISOpub + unicodeMappings.put ("‘", "\u2018"); // left single quotation mark, U+2018 ISOnum + unicodeMappings.put ("’", "\u2019"); // right single quotation mark, U+2019 ISOnum + unicodeMappings.put ("‚", "\u201a"); // single low-9 quotation mark, U+201A NEW + unicodeMappings.put ("“", "\u201c"); // left double quotation mark, U+201C ISOnum + unicodeMappings.put ("”", "\u201d"); // right double quotation mark, U+201D ISOnum + unicodeMappings.put ("„", "\u201e"); // double low-9 quotation mark, U+201E NEW + unicodeMappings.put ("†", "\u2020"); // dagger, U+2020 ISOpub + unicodeMappings.put ("‡", "\u2021"); // double dagger, U+2021 ISOpub + unicodeMappings.put ("‰", "\u2030"); // per mille sign, U+2030 ISOtech + unicodeMappings.put ("‹", "\u2039"); // single left-pointing angle quotation mark, U+2039 ISO proposed + // lsaquo is proposed but not yet ISO standardized + unicodeMappings.put ("›", "\u203a"); // single right-pointing angle quotation mark, U+203A ISO proposed + // rsaquo is proposed but not yet ISO standardized + unicodeMappings.put ("€", "\u20ac"); // euro sign, U+20AC NEW } }