1 /*
2 * Copyright 2002 Paulo Soares
3 *
4 * The contents of this file are subject to the Mozilla Public License Version 1.1
5 * (the "License"); you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at http://www.mozilla.org/MPL/
7 *
8 * Software distributed under the License is distributed on an "AS IS" basis,
9 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
10 * for the specific language governing rights and limitations under the License.
11 *
12 * The Original Code is 'iText, a free JAVA-PDF library'.
13 *
14 * The Initial Developer of the Original Code is Bruno Lowagie. Portions created by
15 * the Initial Developer are Copyright (C) 1999, 2000, 2001, 2002 by Bruno Lowagie.
16 * All Rights Reserved.
17 * Co-Developer of the code is Paulo Soares. Portions created by the Co-Developer
18 * are Copyright (C) 2000, 2001, 2002 by Paulo Soares. All Rights Reserved.
19 *
20 * Contributor(s): all the names of the contributors are added in the source code
21 * where applicable.
22 *
23 * Alternatively, the contents of this file may be used under the terms of the
24 * LGPL license (the "GNU LIBRARY GENERAL PUBLIC LICENSE"), in which case the
25 * provisions of LGPL are applicable instead of those above. If you wish to
26 * allow use of your version of this file only under the terms of the LGPL
27 * License and not to allow others to use your version of this file under
28 * the MPL, indicate your decision by deleting the provisions above and
29 * replace them with the notice and other provisions required by the LGPL.
30 * If you do not delete the provisions above, a recipient may use your version
31 * of this file under either the MPL or the GNU LIBRARY GENERAL PUBLIC LICENSE.
32 *
33 * This library is free software; you can redistribute it and/or modify it
34 * under the terms of the MPL as stated above or under the terms of the GNU
35 * Library General Public License as published by the Free Software Foundation;
36 * either version 2 of the License, or any later version.
37 *
38 * This library is distributed in the hope that it will be useful, but WITHOUT
39 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
40 * FOR A PARTICULAR PURPOSE. See the GNU Library general Public License for more
41 * details.
42 *
43 * If you didn't download this code from the following link, you should check if
44 * you aren't using an obsolete version:
45 * http://www.lowagie.com/iText/
46 */
47
48 package com.lowagie.text.pdf;
49 import java.io.BufferedReader;
50 import java.io.IOException;
51 import java.io.InputStream;
52 import java.io.InputStreamReader;
53 import java.io.UnsupportedEncodingException;
54 import java.util.ArrayList;
55 import java.util.HashMap;
56 import java.util.StringTokenizer;
57
58 import com.lowagie.text.ExceptionConverter;
59 /** Supports fast encodings for winansi and PDFDocEncoding.
60 * Supports conversions from CJK encodings to CID.
61 * Supports custom encodings.
62 * @author Paulo Soares (psoares@consiste.pt)
63 */
64 public class PdfEncodings {
65 protected static final int CIDNONE = 0;
66 protected static final int CIDRANGE = 1;
67 protected static final int CIDCHAR = 2;
68
69 static final char winansiByteToChar[] = {
70 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
71 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
72 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
73 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
74 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
75 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95,
76 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111,
77 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127,
78 8364, 65533, 8218, 402, 8222, 8230, 8224, 8225, 710, 8240, 352, 8249, 338, 65533, 381, 65533,
79 65533, 8216, 8217, 8220, 8221, 8226, 8211, 8212, 732, 8482, 353, 8250, 339, 65533, 382, 376,
80 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175,
81 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191,
82 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207,
83 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223,
84 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239,
85 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255};
86
87 static final char pdfEncodingByteToChar[] = {
88 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
89 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
90 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
91 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
92 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
93 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95,
94 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111,
95 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127,
96 0x2022, 0x2020, 0x2021, 0x2026, 0x2014, 0x2013, 0x0192, 0x2044, 0x2039, 0x203a, 0x2212, 0x2030, 0x201e, 0x201c, 0x201d, 0x2018,
97 0x2019, 0x201a, 0x2122, 0xfb01, 0xfb02, 0x0141, 0x0152, 0x0160, 0x0178, 0x017d, 0x0131, 0x0142, 0x0153, 0x0161, 0x017e, 65533,
98 0x20ac, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175,
99 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191,
100 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207,
101 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223,
102 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239,
103 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255};
104
105 static final IntHashtable winansi = new IntHashtable();
106
107 static final IntHashtable pdfEncoding = new IntHashtable();
108
109 static HashMap extraEncodings = new HashMap();
110
111 static {
112 for (int k = 128; k < 161; ++k) {
113 char c = winansiByteToChar[k];
114 if (c != 65533)
115 winansi.put(c, k);
116 }
117
118 for (int k = 128; k < 161; ++k) {
119 char c = pdfEncodingByteToChar[k];
120 if (c != 65533)
121 pdfEncoding.put(c, k);
122 }
123
124 addExtraEncoding("Wingdings", new WingdingsConversion());
125 addExtraEncoding("Symbol", new SymbolConversion(true));
126 addExtraEncoding("ZapfDingbats", new SymbolConversion(false));
127 addExtraEncoding("SymbolTT", new SymbolTTConversion());
128 addExtraEncoding("Cp437", new Cp437Conversion());
129 }
130
131 /** Converts a <CODE>String</CODE> to a </CODE>byte</CODE> array according
132 * to the font's encoding.
133 * @return an array of <CODE>byte</CODE> representing the conversion according to the font's encoding
134 * @param encoding the encoding
135 * @param text the <CODE>String</CODE> to be converted
136 */
137 public static final byte[] convertToBytes(String text, String encoding) {
138 if (text == null)
139 return new byte[0];
140 if (encoding == null || encoding.length() == 0) {
141 int len = text.length();
142 byte b[] = new byte[len];
143 for (int k = 0; k < len; ++k)
144 b[k] = (byte)text.charAt(k);
145 return b;
146 }
147 ExtraEncoding extra = (ExtraEncoding)extraEncodings.get(encoding.toLowerCase());
148 if (extra != null) {
149 byte b[] = extra.charToByte(text, encoding);
150 if (b != null)
151 return b;
152 }
153 IntHashtable hash = null;
154 if (encoding.equals(BaseFont.WINANSI))
155 hash = winansi;
156 else if (encoding.equals(PdfObject.TEXT_PDFDOCENCODING))
157 hash = pdfEncoding;
158 if (hash != null) {
159 char cc[] = text.toCharArray();
160 int len = cc.length;
161 int ptr = 0;
162 byte b[] = new byte[len];
163 int c = 0;
164 for (int k = 0; k < len; ++k) {
165 char char1 = cc[k];
166 if (char1 < 128 || (char1 > 160 && char1 <= 255))
167 c = char1;
168 else
169 c = hash.get(char1);
170 if (c != 0)
171 b[ptr++] = (byte)c;
172 }
173 if (ptr == len)
174 return b;
175 byte b2[] = new byte[ptr];
176 System.arraycopy(b, 0, b2, 0, ptr);
177 return b2;
178 }
179 if (encoding.equals(PdfObject.TEXT_UNICODE)) {
180 // workaround for jdk 1.2.2 bug
181 char cc[] = text.toCharArray();
182 int len = cc.length;
183 byte b[] = new byte[cc.length * 2 + 2];
184 b[0] = -2;
185 b[1] = -1;
186 int bptr = 2;
187 for (int k = 0; k < len; ++k) {
188 char c = cc[k];
189 b[bptr++] = (byte)(c >> 8);
190 b[bptr++] = (byte)(c & 0xff);
191 }
192 return b;
193 }
194 try {
195 return text.getBytes(encoding);
196 }
197 catch (UnsupportedEncodingException e) {
198 throw new ExceptionConverter(e);
199 }
200 }
201
202 /** Converts a <CODE>String</CODE> to a </CODE>byte</CODE> array according
203 * to the font's encoding.
204 * @return an array of <CODE>byte</CODE> representing the conversion according to the font's encoding
205 * @param encoding the encoding
206 * @param char1 the <CODE>char</CODE> to be converted
207 */
208 public static final byte[] convertToBytes(char char1, String encoding) {
209 if (encoding == null || encoding.length() == 0)
210 return new byte[]{(byte)char1};
211 ExtraEncoding extra = (ExtraEncoding)extraEncodings.get(encoding.toLowerCase());
212 if (extra != null) {
213 byte b[] = extra.charToByte(char1, encoding);
214 if (b != null)
215 return b;
216 }
217 IntHashtable hash = null;
218 if (encoding.equals(BaseFont.WINANSI))
219 hash = winansi;
220 else if (encoding.equals(PdfObject.TEXT_PDFDOCENCODING))
221 hash = pdfEncoding;
222 if (hash != null) {
223 int c = 0;
224 if (char1 < 128 || (char1 > 160 && char1 <= 255))
225 c = char1;
226 else
227 c = hash.get(char1);
228 if (c != 0)
229 return new byte[]{(byte)c};
230 else
231 return new byte[0];
232 }
233 if (encoding.equals(PdfObject.TEXT_UNICODE)) {
234 // workaround for jdk 1.2.2 bug
235 byte b[] = new byte[4];
236 b[0] = -2;
237 b[1] = -1;
238 b[2] = (byte)(char1 >> 8);
239 b[3] = (byte)(char1 & 0xff);
240 return b;
241 }
242 try {
243 return String.valueOf(char1).getBytes(encoding);
244 }
245 catch (UnsupportedEncodingException e) {
246 throw new ExceptionConverter(e);
247 }
248 }
249
250 /** Converts a </CODE>byte</CODE> array to a <CODE>String</CODE> according
251 * to the some encoding.
252 * @param bytes the bytes to convert
253 * @param encoding the encoding
254 * @return the converted <CODE>String</CODE>
255 */
256 public static final String convertToString(byte bytes[], String encoding) {
257 if (bytes == null)
258 return PdfObject.NOTHING;
259 if (encoding == null || encoding.length() == 0) {
260 char c[] = new char[bytes.length];
261 for (int k = 0; k < bytes.length; ++k)
262 c[k] = (char)(bytes[k] & 0xff);
263 return new String(c);
264 }
265 ExtraEncoding extra = (ExtraEncoding)extraEncodings.get(encoding.toLowerCase());
266 if (extra != null) {
267 String text = extra.byteToChar(bytes, encoding);
268 if (text != null)
269 return text;
270 }
271 char ch[] = null;
272 if (encoding.equals(BaseFont.WINANSI))
273 ch = winansiByteToChar;
274 else if (encoding.equals(PdfObject.TEXT_PDFDOCENCODING))
275 ch = pdfEncodingByteToChar;
276 if (ch != null) {
277 int len = bytes.length;
278 char c[] = new char[len];
279 for (int k = 0; k < len; ++k) {
280 c[k] = ch[bytes[k] & 0xff];
281 }
282 return new String(c);
283 }
284 try {
285 return new String(bytes, encoding);
286 }
287 catch (UnsupportedEncodingException e) {
288 throw new ExceptionConverter(e);
289 }
290 }
291
292 /** Checks is <CODE>text</CODE> only has PdfDocEncoding characters.
293 * @param text the <CODE>String</CODE> to test
294 * @return <CODE>true</CODE> if only PdfDocEncoding characters are present
295 */
296 public static boolean isPdfDocEncoding(String text) {
297 if (text == null)
298 return true;
299 int len = text.length();
300 for (int k = 0; k < len; ++k) {
301 char char1 = text.charAt(k);
302 if (char1 < 128 || (char1 > 160 && char1 <= 255))
303 continue;
304 if (!pdfEncoding.containsKey(char1))
305 return false;
306 }
307 return true;
308 }
309
310 static final HashMap cmaps = new HashMap();
311 /** Assumes that '\\n' and '\\r\\n' are the newline sequences. It may not work for
312 * all CJK encodings. To be used with loadCmap().
313 */
314 public static final byte CRLF_CID_NEWLINE[][] = new byte[][]{{(byte)'\n'}, {(byte)'\r', (byte)'\n'}};
315
316 /** Clears the CJK cmaps from the cache. If <CODE>name</CODE> is the
317 * empty string then all the cache is cleared. Calling this method
318 * has no consequences other than the need to reload the cmap
319 * if needed.
320 * @param name the name of the cmap to clear or all the cmaps if the empty string
321 */
322 public static void clearCmap(String name) {
323 synchronized (cmaps) {
324 if (name.length() == 0)
325 cmaps.clear();
326 else
327 cmaps.remove(name);
328 }
329 }
330
331 /** Loads a CJK cmap to the cache with the option of associating
332 * sequences to the newline.
333 * @param name the CJK cmap name
334 * @param newline the sequences to be replaced by a newline in the resulting CID. See <CODE>CRLF_CID_NEWLINE</CODE>
335 */
336 public static void loadCmap(String name, byte newline[][]) {
337 try {
338 char planes[][] = null;
339 synchronized (cmaps) {
340 planes = (char[][])cmaps.get(name);
341 }
342 if (planes == null) {
343 planes = readCmap(name, newline);
344 synchronized (cmaps) {
345 cmaps.put(name, planes);
346 }
347 }
348 }
349 catch (IOException e) {
350 throw new ExceptionConverter(e);
351 }
352 }
353
354 /** Converts a <CODE>byte</CODE> array encoded as <CODE>name</CODE>
355 * to a CID string. This is needed to reach some CJK characters
356 * that don't exist in 16 bit Unicode.</p>
357 * The font to use this result must use the encoding "Identity-H"
358 * or "Identity-V".</p>
359 * See ftp://ftp.oreilly.com/pub/examples/nutshell/cjkv/adobe/.
360 * @param name the CJK encoding name
361 * @param seq the <CODE>byte</CODE> array to be decoded
362 * @return the CID string
363 */
364 public static String convertCmap(String name, byte seq[]) {
365 return convertCmap(name, seq, 0, seq.length);
366 }
367
368 /** Converts a <CODE>byte</CODE> array encoded as <CODE>name</CODE>
369 * to a CID string. This is needed to reach some CJK characters
370 * that don't exist in 16 bit Unicode.</p>
371 * The font to use this result must use the encoding "Identity-H"
372 * or "Identity-V".</p>
373 * See ftp://ftp.oreilly.com/pub/examples/nutshell/cjkv/adobe/.
374 * @param name the CJK encoding name
375 * @param start the start offset in the data
376 * @param length the number of bytes to convert
377 * @param seq the <CODE>byte</CODE> array to be decoded
378 * @return the CID string
379 */
380 public static String convertCmap(String name, byte seq[], int start, int length) {
381 try {
382 char planes[][] = null;
383 synchronized (cmaps) {
384 planes = (char[][])cmaps.get(name);
385 }
386 if (planes == null) {
387 planes = readCmap(name, (byte[][])null);
388 synchronized (cmaps) {
389 cmaps.put(name, planes);
390 }
391 }
392 return decodeSequence(seq, start, length, planes);
393 }
394 catch (IOException e) {
395 throw new ExceptionConverter(e);
396 }
397 }
398
399 static String decodeSequence(byte seq[], int start, int length, char planes[][]) {
400 StringBuffer buf = new StringBuffer();
401 int end = start + length;
402 int currentPlane = 0;
403 for (int k = start; k < end; ++k) {
404 int one = seq[k] & 0xff;
405 char plane[] = planes[currentPlane];
406 int cid = plane[one];
407 if ((cid & 0x8000) == 0) {
408 buf.append((char)cid);
409 currentPlane = 0;
410 }
411 else
412 currentPlane = cid & 0x7fff;
413 }
414 return buf.toString();
415 }
416
417 static char[][] readCmap(String name, byte newline[][]) throws IOException {
418 ArrayList planes = new ArrayList();
419 planes.add(new char[256]);
420 readCmap(name, planes);
421 if (newline != null) {
422 for (int k = 0; k < newline.length; ++k)
423 encodeSequence(newline[k].length, newline[k], BaseFont.CID_NEWLINE, planes);
424 }
425 char ret[][] = new char[planes.size()][];
426 return (char[][])planes.toArray(ret);
427 }
428
429 static void readCmap(String name, ArrayList planes) throws IOException {
430 String fullName = BaseFont.RESOURCE_PATH + "cmaps/" + name;
431 InputStream in = BaseFont.getResourceStream(fullName);
432 if (in == null)
433 throw new IOException("The Cmap " + name + " was not found.");
434 encodeStream(in, planes);
435 in.close();
436 }
437
438 static void encodeStream(InputStream in, ArrayList planes) throws IOException {
439 BufferedReader rd = new BufferedReader(new InputStreamReader(in, "iso-8859-1"));
440 String line = null;
441 int state = CIDNONE;
442 byte seqs[] = new byte[7];
443 while ((line = rd.readLine()) != null) {
444 if (line.length() < 6)
445 continue;
446 switch (state) {
447 case CIDNONE: {
448 if (line.indexOf("begincidrange") >= 0)
449 state = CIDRANGE;
450 else if (line.indexOf("begincidchar") >= 0)
451 state = CIDCHAR;
452 else if (line.indexOf("usecmap") >= 0) {
453 StringTokenizer tk = new StringTokenizer(line);
454 String t = tk.nextToken();
455 readCmap(t.substring(1), planes);
456 }
457 break;
458 }
459 case CIDRANGE: {
460 if (line.indexOf("endcidrange") >= 0) {
461 state = CIDNONE;
462 break;
463 }
464 StringTokenizer tk = new StringTokenizer(line);
465 String t = tk.nextToken();
466 int size = t.length() / 2 - 1;
467 long start = Long.parseLong(t.substring(1, t.length() - 1), 16);
468 t = tk.nextToken();
469 long end = Long.parseLong(t.substring(1, t.length() - 1), 16);
470 t = tk.nextToken();
471 int cid = Integer.parseInt(t);
472 for (long k = start; k <= end; ++k) {
473 breakLong(k, size, seqs);
474 encodeSequence(size, seqs, (char)cid, planes);
475 ++cid;
476 }
477 break;
478 }
479 case CIDCHAR: {
480 if (line.indexOf("endcidchar") >= 0) {
481 state = CIDNONE;
482 break;
483 }
484 StringTokenizer tk = new StringTokenizer(line);
485 String t = tk.nextToken();
486 int size = t.length() / 2 - 1;
487 long start = Long.parseLong(t.substring(1, t.length() - 1), 16);
488 t = tk.nextToken();
489 int cid = Integer.parseInt(t);
490 breakLong(start, size, seqs);
491 encodeSequence(size, seqs, (char)cid, planes);
492 break;
493 }
494 }
495 }
496 }
497
498 static void breakLong(long n, int size, byte seqs[]) {
499 for (int k = 0; k < size; ++k) {
500 seqs[k] = (byte)(n >> ((size - 1 - k) * 8));
501 }
502 }
503
504 static void encodeSequence(int size, byte seqs[], char cid, ArrayList planes) {
505 --size;
506 int nextPlane = 0;
507 for (int idx = 0; idx < size; ++idx) {
508 char plane[] = (char[])planes.get(nextPlane);
509 int one = seqs[idx] & 0xff;
510 char c = plane[one];
511 if (c != 0 && (c & 0x8000) == 0)
512 throw new RuntimeException("Inconsistent mapping.");
513 if (c == 0) {
514 planes.add(new char[256]);
515 c = (char)((planes.size() - 1) | 0x8000);
516 plane[one] = c;
517 }
518 nextPlane = c & 0x7fff;
519 }
520 char plane[] = (char[])planes.get(nextPlane);
521 int one = seqs[size] & 0xff;
522 char c = plane[one];
523 if ((c & 0x8000) != 0)
524 throw new RuntimeException("Inconsistent mapping.");
525 plane[one] = cid;
526 }
527
528 /** Adds an extra encoding.
529 * @param name the name of the encoding. The encoding recognition is case insensitive
530 * @param enc the conversion class
531 */
532 public static void addExtraEncoding(String name, ExtraEncoding enc) {
533 synchronized (extraEncodings) { // This serializes concurrent updates
534 HashMap newEncodings = (HashMap)extraEncodings.clone();
535 newEncodings.put(name.toLowerCase(), enc);
536 extraEncodings = newEncodings; // This swap does not require synchronization with reader
537 }
538 }
539
540 private static class WingdingsConversion implements ExtraEncoding {
541
542 public byte[] charToByte(char char1, String encoding) {
543 if (char1 == ' ')
544 return new byte[]{(byte)char1};
545 else if (char1 >= '\u2701' && char1 <= '\u27BE') {
546 byte v = table[char1 - 0x2700];
547 if (v != 0)
548 return new byte[]{v};
549 }
550 return new byte[0];
551 }
552
553 public byte[] charToByte(String text, String encoding) {
554 char cc[] = text.toCharArray();
555 byte b[] = new byte[cc.length];
556 int ptr = 0;
557 int len = cc.length;
558 for (int k = 0; k < len; ++k) {
559 char c = cc[k];
560 if (c == ' ')
561 b[ptr++] = (byte)c;
562 else if (c >= '\u2701' && c <= '\u27BE') {
563 byte v = table[c - 0x2700];
564 if (v != 0)
565 b[ptr++] = v;
566 }
567 }
568 if (ptr == len)
569 return b;
570 byte b2[] = new byte[ptr];
571 System.arraycopy(b, 0, b2, 0, ptr);
572 return b2;
573 }
574
575 public String byteToChar(byte[] b, String encoding) {
576 return null;
577 }
578
579 private final static byte table[] = {
580 0, 35, 34, 0, 0, 0, 41, 62, 81, 42,
581 0, 0, 65, 63, 0, 0, 0, 0, 0, -4,
582 0, 0, 0, -5, 0, 0, 0, 0, 0, 0,
583 86, 0, 88, 89, 0, 0, 0, 0, 0, 0,
584 0, 0, -75, 0, 0, 0, 0, 0, -74, 0,
585 0, 0, -83, -81, -84, 0, 0, 0, 0, 0,
586 0, 0, 0, 124, 123, 0, 0, 0, 84, 0,
587 0, 0, 0, 0, 0, 0, 0, -90, 0, 0,
588 0, 113, 114, 0, 0, 0, 117, 0, 0, 0,
589 0, 0, 0, 125, 126, 0, 0, 0, 0, 0,
590 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
591 0, 0, 0, 0, 0, 0, 0, 0, -116, -115,
592 -114, -113, -112, -111, -110, -109, -108, -107, -127, -126,
593 -125, -124, -123, -122, -121, -120, -119, -118, -116, -115,
594 -114, -113, -112, -111, -110, -109, -108, -107, -24, 0,
595 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
596 0, -24, -40, 0, 0, -60, -58, 0, 0, -16,
597 0, 0, 0, 0, 0, 0, 0, 0, 0, -36,
598 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
599 0
600 };
601 }
602
603 private static class Cp437Conversion implements ExtraEncoding {
604 private static IntHashtable c2b = new IntHashtable();
605
606 public byte[] charToByte(String text, String encoding) {
607 char cc[] = text.toCharArray();
608 byte b[] = new byte[cc.length];
609 int ptr = 0;
610 int len = cc.length;
611 for (int k = 0; k < len; ++k) {
612 char c = cc[k];
613 if (c < 128)
614 b[ptr++] = (byte)c;
615 else {
616 byte v = (byte)c2b.get(c);
617 if (v != 0)
618 b[ptr++] = v;
619 }
620 }
621 if (ptr == len)
622 return b;
623 byte b2[] = new byte[ptr];
624 System.arraycopy(b, 0, b2, 0, ptr);
625 return b2;
626 }
627
628 public byte[] charToByte(char char1, String encoding) {
629 if (char1 < 128)
630 return new byte[]{(byte)char1};
631 else {
632 byte v = (byte)c2b.get(char1);
633 if (v != 0)
634 return new byte[]{v};
635 else
636 return new byte[0];
637 }
638 }
639
640 public String byteToChar(byte[] b, String encoding) {
641 int len = b.length;
642 char cc[] = new char[len];
643 int ptr = 0;
644 for (int k = 0; k < len; ++k) {
645 int c = b[k] & 0xff;
646 if (c < ' ')
647 continue;
648 if (c < 128)
649 cc[ptr++] = (char)c;
650 else {
651 char v = table[c - 128];
652 cc[ptr++] = v;
653 }
654 }
655 return new String(cc, 0, ptr);
656 }
657
658 private final static char table[] = {
659 '\u00C7', '\u00FC', '\u00E9', '\u00E2', '\u00E4', '\u00E0', '\u00E5', '\u00E7', '\u00EA', '\u00EB', '\u00E8', '\u00EF', '\u00EE', '\u00EC', '\u00C4', '\u00C5',
660 '\u00C9', '\u00E6', '\u00C6', '\u00F4', '\u00F6', '\u00F2', '\u00FB', '\u00F9', '\u00FF', '\u00D6', '\u00DC', '\u00A2', '\u00A3', '\u00A5', '\u20A7', '\u0192',
661 '\u00E1', '\u00ED', '\u00F3', '\u00FA', '\u00F1', '\u00D1', '\u00AA', '\u00BA', '\u00BF', '\u2310', '\u00AC', '\u00BD', '\u00BC', '\u00A1', '\u00AB', '\u00BB',
662 '\u2591', '\u2592', '\u2593', '\u2502', '\u2524', '\u2561', '\u2562', '\u2556', '\u2555', '\u2563', '\u2551', '\u2557', '\u255D', '\u255C', '\u255B', '\u2510',
663 '\u2514', '\u2534', '\u252C', '\u251C', '\u2500', '\u253C', '\u255E', '\u255F', '\u255A', '\u2554', '\u2569', '\u2566', '\u2560', '\u2550', '\u256C', '\u2567',
664 '\u2568', '\u2564', '\u2565', '\u2559', '\u2558', '\u2552', '\u2553', '\u256B', '\u256A', '\u2518', '\u250C', '\u2588', '\u2584', '\u258C', '\u2590', '\u2580',
665 '\u03B1', '\u00DF', '\u0393', '\u03C0', '\u03A3', '\u03C3', '\u00B5', '\u03C4', '\u03A6', '\u0398', '\u03A9', '\u03B4', '\u221E', '\u03C6', '\u03B5', '\u2229',
666 '\u2261', '\u00B1', '\u2265', '\u2264', '\u2320', '\u2321', '\u00F7', '\u2248', '\u00B0', '\u2219', '\u00B7', '\u221A', '\u207F', '\u00B2', '\u25A0', '\u00A0'
667 };
668
669 static {
670 for (int k = 0; k < table.length; ++k)
671 c2b.put(table[k], k + 128);
672 }
673 }
674
675 private static class SymbolConversion implements ExtraEncoding {
676
677 private static final IntHashtable t1 = new IntHashtable();
678 private static final IntHashtable t2 = new IntHashtable();
679 private IntHashtable translation;
680
681 SymbolConversion(boolean symbol) {
682 if (symbol)
683 translation = t1;
684 else
685 translation = t2;
686 }
687
688 public byte[] charToByte(String text, String encoding) {
689 char cc[] = text.toCharArray();
690 byte b[] = new byte[cc.length];
691 int ptr = 0;
692 int len = cc.length;
693 for (int k = 0; k < len; ++k) {
694 char c = cc[k];
695 byte v = (byte)translation.get(c);
696 if (v != 0)
697 b[ptr++] = v;
698 }
699 if (ptr == len)
700 return b;
701 byte b2[] = new byte[ptr];
702 System.arraycopy(b, 0, b2, 0, ptr);
703 return b2;
704 }
705
706 public byte[] charToByte(char char1, String encoding) {
707 byte v = (byte)translation.get(char1);
708 if (v != 0)
709 return new byte[]{v};
710 else
711 return new byte[0];
712 }
713
714 public String byteToChar(byte[] b, String encoding) {
715 return null;
716 }
717
718 private final static char table1[] = {
719 ' ','!','\u2200','#','\u2203','%','&','\u220b','(',')','*','+',',','-','.','/',
720 '0','1','2','3','4','5','6','7','8','9',':',';','<','=','>','?',
721 '\u2245','\u0391','\u0392','\u03a7','\u0394','\u0395','\u03a6','\u0393','\u0397','\u0399','\u03d1','\u039a','\u039b','\u039c','\u039d','\u039f',
722 '\u03a0','\u0398','\u03a1','\u03a3','\u03a4','\u03a5','\u03c2','\u03a9','\u039e','\u03a8','\u0396','[','\u2234',']','\u22a5','_',
723 '\u0305','\u03b1','\u03b2','\u03c7','\u03b4','\u03b5','\u03d5','\u03b3','\u03b7','\u03b9','\u03c6','\u03ba','\u03bb','\u03bc','\u03bd','\u03bf',
724 '\u03c0','\u03b8','\u03c1','\u03c3','\u03c4','\u03c5','\u03d6','\u03c9','\u03be','\u03c8','\u03b6','{','|','}','~','\0',
725 '\0','\0','\0','\0','\0','\0','\0','\0','\0','\0','\0','\0','\0','\0','\0','\0',
726 '\0','\0','\0','\0','\0','\0','\0','\0','\0','\0','\0','\0','\0','\0','\0','\0',
727 '\u20ac','\u03d2','\u2032','\u2264','\u2044','\u221e','\u0192','\u2663','\u2666','\u2665','\u2660','\u2194','\u2190','\u2191','\u2192','\u2193',
728 '\u00b0','\u00b1','\u2033','\u2265','\u00d7','\u221d','\u2202','\u2022','\u00f7','\u2260','\u2261','\u2248','\u2026','\u2502','\u2500','\u21b5',
729 '\u2135','\u2111','\u211c','\u2118','\u2297','\u2295','\u2205','\u2229','\u222a','\u2283','\u2287','\u2284','\u2282','\u2286','\u2208','\u2209',
730 '\u2220','\u2207','\u00ae','\u00a9','\u2122','\u220f','\u221a','\u2022','\u00ac','\u2227','\u2228','\u21d4','\u21d0','\u21d1','\u21d2','\u21d3',
731 '\u25ca','\u2329','\0','\0','\0','\u2211','\u239b','\u239c','\u239d','\u23a1','\u23a2','\u23a3','\u23a7','\u23a8','\u23a9','\u23aa',
732 '\0','\u232a','\u222b','\u2320','\u23ae','\u2321','\u239e','\u239f','\u23a0','\u23a4','\u23a5','\u23a6','\u23ab','\u23ac','\u23ad','\0'
733 };
734
735 private final static char table2[] = {
736 '\u0020','\u2701','\u2702','\u2703','\u2704','\u260e','\u2706','\u2707','\u2708','\u2709','\u261b','\u261e','\u270C','\u270D','\u270E','\u270F',
737 '\u2710','\u2711','\u2712','\u2713','\u2714','\u2715','\u2716','\u2717','\u2718','\u2719','\u271A','\u271B','\u271C','\u271D','\u271E','\u271F',
738 '\u2720','\u2721','\u2722','\u2723','\u2724','\u2725','\u2726','\u2727','\u2605','\u2729','\u272A','\u272B','\u272C','\u272D','\u272E','\u272F',
739 '\u2730','\u2731','\u2732','\u2733','\u2734','\u2735','\u2736','\u2737','\u2738','\u2739','\u273A','\u273B','\u273C','\u273D','\u273E','\u273F',
740 '\u2740','\u2741','\u2742','\u2743','\u2744','\u2745','\u2746','\u2747','\u2748','\u2749','\u274A','\u274B','\u25cf','\u274D','\u25a0','\u274F',
741 '\u2750','\u2751','\u2752','\u25b2','\u25bc','\u25c6','\u2756','\u25d7','\u2758','\u2759','\u275A','\u275B','\u275C','\u275D','\u275E','\u0000',
742 '\0','\0','\0','\0','\0','\0','\0','\0','\0','\0','\0','\0','\0','\0','\0','\0',
743 '\0','\0','\0','\0','\0','\0','\0','\0','\0','\0','\0','\0','\0','\0','\0','\0',
744 '\u0000','\u2761','\u2762','\u2763','\u2764','\u2765','\u2766','\u2767','\u2663','\u2666','\u2665','\u2660','\u2460','\u2461','\u2462','\u2463',
745 '\u2464','\u2465','\u2466','\u2467','\u2468','\u2469','\u2776','\u2777','\u2778','\u2779','\u277A','\u277B','\u277C','\u277D','\u277E','\u277F',
746 '\u2780','\u2781','\u2782','\u2783','\u2784','\u2785','\u2786','\u2787','\u2788','\u2789','\u278A','\u278B','\u278C','\u278D','\u278E','\u278F',
747 '\u2790','\u2791','\u2792','\u2793','\u2794','\u2192','\u2194','\u2195','\u2798','\u2799','\u279A','\u279B','\u279C','\u279D','\u279E','\u279F',
748 '\u27A0','\u27A1','\u27A2','\u27A3','\u27A4','\u27A5','\u27A6','\u27A7','\u27A8','\u27A9','\u27AA','\u27AB','\u27AC','\u27AD','\u27AE','\u27AF',
749 '\u0000','\u27B1','\u27B2','\u27B3','\u27B4','\u27B5','\u27B6','\u27B7','\u27B8','\u27B9','\u27BA','\u27BB','\u27BC','\u27BD','\u27BE','\u0000'
750 };
751
752 static {
753 for (int k = 0; k < table1.length; ++k) {
754 int v = table1[k];
755 if (v != 0)
756 t1.put(v, k + 32);
757 }
758 for (int k = 0; k < table2.length; ++k) {
759 int v = table2[k];
760 if (v != 0)
761 t2.put(v, k + 32);
762 }
763 }
764 }
765
766 private static class SymbolTTConversion implements ExtraEncoding {
767
768 public byte[] charToByte(char char1, String encoding) {
769 if ((char1 & 0xff00) == 0 || (char1 & 0xff00) == 0xf000)
770 return new byte[]{(byte)char1};
771 else
772 return new byte[0];
773 }
774
775 public byte[] charToByte(String text, String encoding) {
776 char ch[] = text.toCharArray();
777 byte b[] = new byte[ch.length];
778 int ptr = 0;
779 int len = ch.length;
780 for (int k = 0; k < len; ++k) {
781 char c = ch[k];
782 if ((c & 0xff00) == 0 || (c & 0xff00) == 0xf000)
783 b[ptr++] = (byte)c;
784 }
785 if (ptr == len)
786 return b;
787 byte b2[] = new byte[ptr];
788 System.arraycopy(b, 0, b2, 0, ptr);
789 return b2;
790 }
791
792 public String byteToChar(byte[] b, String encoding) {
793 return null;
794 }
795
796 }
797 }
Save This Page