Gitiles
Code Review Sign In
gerrit.witaqua.org / frameworks_base / 025ec882be3de274ddc935c7d669c4e86a74e0eb / . / icu4j / java / android / icu / text / ArabicShaping.java
blob: 13e2175340a3a4333033520a63ee94abee9171fd [file] [log] [blame]
Doug Felte8e45f22010-03-29 14:58:40 -0700[diff] [blame]1/*
2*******************************************************************************
3* Copyright (C) 2001-2009, International Business Machines
4* Corporation and others. All Rights Reserved.
5*******************************************************************************
6*/
7
8/*
9 * Ported with minor modifications from ICU4J 4.2's
10 * com.ibm.icu.text.ArabicShaping class.
11 */
12
13package android.icu.text;
14
15
16/**
17 * Shape Arabic text on a character basis.
18 *
19 * <p>ArabicShaping performs basic operations for "shaping" Arabic text. It is most
20 * useful for use with legacy data formats and legacy display technology
21 * (simple terminals). All operations are performed on Unicode characters.</p>
22 *
23 * <p>Text-based shaping means that some character code points in the text are
24 * replaced by others depending on the context. It transforms one kind of text
25 * into another. In comparison, modern displays for Arabic text select
26 * appropriate, context-dependent font glyphs for each text element, which means
27 * that they transform text into a glyph vector.</p>
28 *
29 * <p>Text transformations are necessary when modern display technology is not
30 * available or when text needs to be transformed to or from legacy formats that
31 * use "shaped" characters. Since the Arabic script is cursive, connecting
32 * adjacent letters to each other, computers select images for each letter based
33 * on the surrounding letters. This usually results in four images per Arabic
34 * letter: initial, middle, final, and isolated forms. In Unicode, on the other
35 * hand, letters are normally stored abstract, and a display system is expected
36 * to select the necessary glyphs. (This makes searching and other text
37 * processing easier because the same letter has only one code.) It is possible
38 * to mimic this with text transformations because there are characters in
39 * Unicode that are rendered as letters with a specific shape
40 * (or cursive connectivity). They were included for interoperability with
41 * legacy systems and codepages, and for unsophisticated display systems.</p>
42 *
43 * <p>A second kind of text transformations is supported for Arabic digits:
44 * For compatibility with legacy codepages that only include European digits,
45 * it is possible to replace one set of digits by another, changing the
46 * character code points. These operations can be performed for either
47 * Arabic-Indic Digits (U+0660...U+0669) or Eastern (Extended) Arabic-Indic
48 * digits (U+06f0...U+06f9).</p>
49 *
50 * <p>Some replacements may result in more or fewer characters (code points).
51 * By default, this means that the destination buffer may receive text with a
52 * length different from the source length. Some legacy systems rely on the
53 * length of the text to be constant. They expect extra spaces to be added
54 * or consumed either next to the affected character or at the end of the
55 * text.</p>
56 * @stable ICU 2.0
57 *
58 * @hide
59 */
60public class ArabicShaping {
61 private final int options;
62 private boolean isLogical; // convenience
63 private boolean spacesRelativeToTextBeginEnd;
64 private char tailChar;
65
66 public static final ArabicShaping SHAPER = new ArabicShaping(
67 ArabicShaping.TEXT_DIRECTION_LOGICAL |
68 ArabicShaping.LENGTH_FIXED_SPACES_NEAR |
69 ArabicShaping.LETTERS_SHAPE |
70 ArabicShaping.DIGITS_NOOP);
71
72 /**
73 * Convert a range of text in the source array, putting the result
74 * into a range of text in the destination array, and return the number
75 * of characters written.
76 *
77 * @param source An array containing the input text
78 * @param sourceStart The start of the range of text to convert
79 * @param sourceLength The length of the range of text to convert
80 * @param dest The destination array that will receive the result.
81 * It may be <code>NULL</code> only if <code>destSize</code> is 0.
82 * @param destStart The start of the range of the destination buffer to use.
83 * @param destSize The size (capacity) of the destination buffer.
84 * If <code>destSize</code> is 0, then no output is produced,
85 * but the necessary buffer size is returned ("preflighting"). This
86 * does not validate the text against the options, for example,
87 * if letters are being unshaped, and spaces are being consumed
88 * following lamalef, this will not detect a lamalef without a
89 * corresponding space. An error will be thrown when the actual
90 * conversion is attempted.
91 * @return The number of chars written to the destination buffer.
92 * If an error occurs, then no output was written, or it may be
93 * incomplete.
94 * @throws ArabicShapingException if the text cannot be converted according to the options.
95 * @stable ICU 2.0
96 */
97 public int shape(char[] source, int sourceStart, int sourceLength,
98 char[] dest, int destStart, int destSize) throws ArabicShapingException {
99 if (source == null) {
100 throw new IllegalArgumentException("source can not be null");
101 }
102 if (sourceStart < 0 || sourceLength < 0 || sourceStart + sourceLength > source.length) {
103 throw new IllegalArgumentException("bad source start (" + sourceStart +
104 ") or length (" + sourceLength +
105 ") for buffer of length " + source.length);
106 }
107 if (dest == null && destSize != 0) {
108 throw new IllegalArgumentException("null dest requires destSize == 0");
109 }
110 if ((destSize != 0) &&
111 (destStart < 0 || destSize < 0 || destStart + destSize > dest.length)) {
112 throw new IllegalArgumentException("bad dest start (" + destStart +
113 ") or size (" + destSize +
114 ") for buffer of length " + dest.length);
115 }
116 /* Validate input options */
117 if ( ((options&TASHKEEL_MASK) > 0) &&
118 !(((options & TASHKEEL_MASK)==TASHKEEL_BEGIN) ||
119 ((options & TASHKEEL_MASK)==TASHKEEL_END ) ||
120 ((options & TASHKEEL_MASK)==TASHKEEL_RESIZE )||
121 ((options & TASHKEEL_MASK)==TASHKEEL_REPLACE_BY_TATWEEL)) ){
122 throw new IllegalArgumentException("Wrong Tashkeel argument");
123 }
124
125 ///CLOVER:OFF
126 //According to Steven Loomis, the code is unreachable when you OR all the constants within the if statements
127 if(((options&LAMALEF_MASK) > 0)&&
128 !(((options & LAMALEF_MASK)==LAMALEF_BEGIN) ||
129 ((options & LAMALEF_MASK)==LAMALEF_END ) ||
130 ((options & LAMALEF_MASK)==LAMALEF_RESIZE )||
131 ((options & LAMALEF_MASK)==LAMALEF_AUTO) ||
132 ((options & LAMALEF_MASK)==LAMALEF_NEAR))){
133 throw new IllegalArgumentException("Wrong Lam Alef argument");
134 }
135 ///CLOVER:ON
136
137 /* Validate Tashkeel (Tashkeel replacement options should be enabled in shaping mode only)*/
138 if(((options&TASHKEEL_MASK) > 0) && (options&LETTERS_MASK) == LETTERS_UNSHAPE) {
139 throw new IllegalArgumentException("Tashkeel replacement should not be enabled in deshaping mode ");
140 }
141 return internalShape(source, sourceStart, sourceLength, dest, destStart, destSize);
142 }
143
144 /**
145 * Convert a range of text in place. This may only be used if the Length option
146 * does not grow or shrink the text.
147 *
148 * @param source An array containing the input text
149 * @param start The start of the range of text to convert
150 * @param length The length of the range of text to convert
151 * @throws ArabicShapingException if the text cannot be converted according to the options.
152 * @stable ICU 2.0
153 */
154 public void shape(char[] source, int start, int length) throws ArabicShapingException {
155 if ((options & LAMALEF_MASK) == LAMALEF_RESIZE) {
156 throw new ArabicShapingException("Cannot shape in place with length option resize.");
157 }
158 shape(source, start, length, source, start, length);
159 }
160
161 /**
162 * Convert a string, returning the new string.
163 *
164 * @param text the string to convert
165 * @return the converted string
166 * @throws ArabicShapingException if the string cannot be converted according to the options.
167 * @stable ICU 2.0
168 */
169 public String shape(String text) throws ArabicShapingException {
170 char[] src = text.toCharArray();
171 char[] dest = src;
172 if (((options & LAMALEF_MASK) == LAMALEF_RESIZE) &&
173 ((options & LETTERS_MASK) == LETTERS_UNSHAPE)) {
174
175 dest = new char[src.length * 2]; // max
176 }
177 int len = shape(src, 0, src.length, dest, 0, dest.length);
178
179 return new String(dest, 0, len);
180 }
181
182 /**
183 * Construct ArabicShaping using the options flags.
184 * The flags are as follows:<br>
185 * 'LENGTH' flags control whether the text can change size, and if not,
186 * how to maintain the size of the text when LamAlef ligatures are
187 * formed or broken.<br>
188 * 'TEXT_DIRECTION' flags control whether the text is read and written
189 * in visual order or in logical order.<br>
190 * 'LETTERS_SHAPE' flags control whether conversion is to or from
191 * presentation forms.<br>
192 * 'DIGITS' flags control whether digits are shaped, and whether from
193 * European to Arabic-Indic or vice-versa.<br>
194 * 'DIGIT_TYPE' flags control whether standard or extended Arabic-Indic
195 * digits are used when performing digit conversion.
196 * @stable ICU 2.0
197 */
198 public ArabicShaping(int options) {
199 this.options = options;
200 if ((options & DIGITS_MASK) > 0x80) {
201 throw new IllegalArgumentException("bad DIGITS options");
202 }
203
204 isLogical = ( (options & TEXT_DIRECTION_MASK) == TEXT_DIRECTION_LOGICAL );
205 /* Validate options */
206 spacesRelativeToTextBeginEnd = ( (options & SPACES_RELATIVE_TO_TEXT_MASK) == SPACES_RELATIVE_TO_TEXT_BEGIN_END );
207 if ( (options&SHAPE_TAIL_TYPE_MASK) == SHAPE_TAIL_NEW_UNICODE){
208 tailChar = NEW_TAIL_CHAR;
209 } else {
210 tailChar = OLD_TAIL_CHAR;
211 }
212 }
213
214 /* Seen Tail options */
215 /**
216 * Memory option: the result must have the same length as the source.
217 * Shaping mode: The SEEN family character will expand into two characters using space near
218 * the SEEN family character(i.e. the space after the character).
219 * if there are no spaces found, ArabicShapingException will be thrown
220 *
221 * De-shaping mode: Any Seen character followed by Tail character will be
222 * replaced by one cell Seen and a space will replace the Tail.
223 * Affects: Seen options
224 */
225 public static final int SEEN_TWOCELL_NEAR = 0x200000;
226
227 /** Bit mask for Seen memory options. */
228 public static final int SEEN_MASK = 0x700000;
229
230 /* YehHamza options */
231 /**
232 * Memory option: the result must have the same length as the source.
233 * Shaping mode: The YEHHAMZA character will expand into two characters using space near it
234 * (i.e. the space after the character)
235 * if there are no spaces found, ArabicShapingException will be thrown
236 *
237 * De-shaping mode: Any Yeh (final or isolated) character followed by Hamza character will be
238 * replaced by one cell YehHamza and space will replace the Hamza.
239 * Affects: YehHamza options
240 */
241 public static final int YEHHAMZA_TWOCELL_NEAR = 0x1000000;
242
243
244 /** Bit mask for YehHamza memory options. */
245 public static final int YEHHAMZA_MASK = 0x3800000;
246
247 /* New Tashkeel options */
248 /**
249 * Memory option: the result must have the same length as the source.
250 * Shaping mode: Tashkeel characters will be replaced by spaces.
251 * Spaces will be placed at beginning of the buffer
252 *
253 * De-shaping mode: N/A
254 * Affects: Tashkeel options
255 */
256 public static final int TASHKEEL_BEGIN = 0x40000;
257
258 /**
259 * Memory option: the result must have the same length as the source.
260 * Shaping mode: Tashkeel characters will be replaced by spaces.
261 * Spaces will be placed at end of the buffer
262 *
263 * De-shaping mode: N/A
264 * Affects: Tashkeel options
265 */
266 public static final int TASHKEEL_END = 0x60000;
267
268 /**
269 * Memory option: allow the result to have a different length than the source.
270 * Shaping mode: Tashkeel characters will be removed, buffer length will shrink.
271 * De-shaping mode: N/A
272 *
273 * Affects: Tashkeel options
274 */
275 public static final int TASHKEEL_RESIZE = 0x80000;
276
277 /**
278 * Memory option: the result must have the same length as the source.
279 * Shaping mode: Tashkeel characters will be replaced by Tatweel if it is connected to adjacent
280 * characters (i.e. shaped on Tatweel) or replaced by space if it is not connected.
281 *
282 * De-shaping mode: N/A
283 * Affects: YehHamza options
284 */
285 public static final int TASHKEEL_REPLACE_BY_TATWEEL = 0xC0000;
286
287 /** Bit mask for Tashkeel replacement with Space or Tatweel memory options. */
288 public static final int TASHKEEL_MASK = 0xE0000;
289
290 /* Space location Control options */
291 /**
292 * This option effects the meaning of BEGIN and END options. if this option is not used the default
293 * for BEGIN and END will be as following:
294 * The Default (for both Visual LTR, Visual RTL and Logical Text)
295 * 1. BEGIN always refers to the start address of physical memory.
296 * 2. END always refers to the end address of physical memory.
297 *
298 * If this option is used it will swap the meaning of BEGIN and END only for Visual LTR text.
299 *
300 * The affect on BEGIN and END Memory Options will be as following:
301 * A. BEGIN For Visual LTR text: This will be the beginning (right side) of the visual text
302 * (corresponding to the physical memory address end, same as END in default behavior)
303 * B. BEGIN For Logical text: Same as BEGIN in default behavior.
304 * C. END For Visual LTR text: This will be the end (left side) of the visual text. (corresponding to
305 * the physical memory address beginning, same as BEGIN in default behavior)
306 * D. END For Logical text: Same as END in default behavior.
307 * Affects: All LamAlef BEGIN, END and AUTO options.
308 */
309 public static final int SPACES_RELATIVE_TO_TEXT_BEGIN_END = 0x4000000;
310
311 /** Bit mask for swapping BEGIN and END for Visual LTR text */
312 public static final int SPACES_RELATIVE_TO_TEXT_MASK = 0x4000000;
313
314 /**
315 * If this option is used, shaping will use the new Unicode code point for TAIL (i.e. 0xFE73).
316 * If this option is not specified (Default), old unofficial Unicode TAIL code point is used (i.e. 0x200B)
317 * De-shaping will not use this option as it will always search for both the new Unicode code point for the
318 * TAIL (i.e. 0xFE73) or the old unofficial Unicode TAIL code point (i.e. 0x200B) and de-shape the
319 * Seen-Family letter accordingly.
320 *
321 * Shaping Mode: Only shaping.
322 * De-shaping Mode: N/A.
323 * Affects: All Seen options
324 */
325 public static final int SHAPE_TAIL_NEW_UNICODE = 0x8000000;
326
327 /** Bit mask for new Unicode Tail option */
328 public static final int SHAPE_TAIL_TYPE_MASK = 0x8000000;
329
330 /**
331 * Memory option: allow the result to have a different length than the source.
332 * @stable ICU 2.0
333 */
334 public static final int LENGTH_GROW_SHRINK = 0;
335
336 /**
337 * Memory option: allow the result to have a different length than the source.
338 * Affects: LamAlef options
339 * This option is an alias to LENGTH_GROW_SHRINK
340 */
341 public static final int LAMALEF_RESIZE = 0;
342
343 /**
344 * Memory option: the result must have the same length as the source.
345 * If more room is necessary, then try to consume spaces next to modified characters.
346 * @stable ICU 2.0
347 */
348 public static final int LENGTH_FIXED_SPACES_NEAR = 1;
349
350 /**
351 * Memory option: the result must have the same length as the source.
352 * If more room is necessary, then try to consume spaces next to modified characters.
353 * Affects: LamAlef options
354 * This option is an alias to LENGTH_FIXED_SPACES_NEAR
355 */
356 public static final int LAMALEF_NEAR = 1 ;
357
358 /**
359 * Memory option: the result must have the same length as the source.
360 * If more room is necessary, then try to consume spaces at the end of the text.
361 * @stable ICU 2.0
362 */
363 public static final int LENGTH_FIXED_SPACES_AT_END = 2;
364
365
366 /**
367 * Memory option: the result must have the same length as the source.
368 * If more room is necessary, then try to consume spaces at the end of the text.
369 * Affects: LamAlef options
370 * This option is an alias to LENGTH_FIXED_SPACES_AT_END
371 */
372 public static final int LAMALEF_END = 2;
373
374 /**
375 * Memory option: the result must have the same length as the source.
376 * If more room is necessary, then try to consume spaces at the beginning of the text.
377 * @stable ICU 2.0
378 */
379 public static final int LENGTH_FIXED_SPACES_AT_BEGINNING = 3;
380
381 /**
382 * Memory option: the result must have the same length as the source.
383 * If more room is necessary, then try to consume spaces at the beginning of the text.
384 * Affects: LamAlef options
385 * This option is an alias to LENGTH_FIXED_SPACES_AT_BEGINNING
386 */
387 public static final int LAMALEF_BEGIN = 3;
388
389 /**
390 * Memory option: the result must have the same length as the source.
391 * Shaping Mode: For each LAMALEF character found, expand LAMALEF using space at end.
392 * If there is no space at end, use spaces at beginning of the buffer. If there
393 * is no space at beginning of the buffer, use spaces at the near (i.e. the space
394 * after the LAMALEF character).
395 *
396 * Deshaping Mode: Perform the same function as the flag equals LAMALEF_END.
397 * Affects: LamAlef options
398 */
399 public static final int LAMALEF_AUTO = 0x10000;
400
401 /**
402 * Bit mask for memory options.
403 * @stable ICU 2.0
404 */
405 public static final int LENGTH_MASK = 0x10003;
406
407 /** Bit mask for LamAlef memory options. */
408
409 public static final int LAMALEF_MASK = 0x10003;
410
411 /**
412 * Direction indicator: the source is in logical (keyboard) order.
413 * @stable ICU 2.0
414 */
415 public static final int TEXT_DIRECTION_LOGICAL = 0;
416
417 /**
418 * Direction indicator:the source is in visual RTL order,
419 * the rightmost displayed character stored first.
420 * This option is an alias to U_SHAPE_TEXT_DIRECTION_LOGICAL
421 */
422 public static final int TEXT_DIRECTION_VISUAL_RTL = 0;
423
424 /**
425 * Direction indicator: the source is in visual (display) order, that is,
426 * the leftmost displayed character is stored first.
427 * @stable ICU 2.0
428 */
429 public static final int TEXT_DIRECTION_VISUAL_LTR = 4;
430
431 /**
432 * Bit mask for direction indicators.
433 * @stable ICU 2.0
434 */
435 public static final int TEXT_DIRECTION_MASK = 4;
436
437
438 /**
439 * Letter shaping option: do not perform letter shaping.
440 * @stable ICU 2.0
441 */
442 public static final int LETTERS_NOOP = 0;
443
444 /**
445 * Letter shaping option: replace normative letter characters in the U+0600 (Arabic) block,
446 * by shaped ones in the U+FE70 (Presentation Forms B) block. Performs Lam-Alef ligature
447 * substitution.
448 * @stable ICU 2.0
449 */
450 public static final int LETTERS_SHAPE = 8;
451
452 /**
453 * Letter shaping option: replace shaped letter characters in the U+FE70 (Presentation Forms B) block
454 * by normative ones in the U+0600 (Arabic) block. Converts Lam-Alef ligatures to pairs of Lam and
455 * Alef characters, consuming spaces if required.
456 * @stable ICU 2.0
457 */
458 public static final int LETTERS_UNSHAPE = 0x10;
459
460 /**
461 * Letter shaping option: replace normative letter characters in the U+0600 (Arabic) block,
462 * except for the TASHKEEL characters at U+064B...U+0652, by shaped ones in the U+Fe70
463 * (Presentation Forms B) block. The TASHKEEL characters will always be converted to
464 * the isolated forms rather than to their correct shape.
465 * @stable ICU 2.0
466 */
467 public static final int LETTERS_SHAPE_TASHKEEL_ISOLATED = 0x18;
468
469 /**
470 * Bit mask for letter shaping options.
471 * @stable ICU 2.0
472 */
473 public static final int LETTERS_MASK = 0x18;
474
475
476 /**
477 * Digit shaping option: do not perform digit shaping.
478 * @stable ICU 2.0
479 */
480 public static final int DIGITS_NOOP = 0;
481
482 /**
483 * Digit shaping option: Replace European digits (U+0030...U+0039) by Arabic-Indic digits.
484 * @stable ICU 2.0
485 */
486 public static final int DIGITS_EN2AN = 0x20;
487
488 /**
489 * Digit shaping option: Replace Arabic-Indic digits by European digits (U+0030...U+0039).
490 * @stable ICU 2.0
491 */
492 public static final int DIGITS_AN2EN = 0x40;
493
494 /**
495 * Digit shaping option:
496 * Replace European digits (U+0030...U+0039) by Arabic-Indic digits
497 * if the most recent strongly directional character
498 * is an Arabic letter (its Bidi direction value is RIGHT_TO_LEFT_ARABIC).
499 * The initial state at the start of the text is assumed to be not an Arabic,
500 * letter, so European digits at the start of the text will not change.
501 * Compare to DIGITS_ALEN2AN_INIT_AL.
502 * @stable ICU 2.0
503 */
504 public static final int DIGITS_EN2AN_INIT_LR = 0x60;
505
506 /**
507 * Digit shaping option:
508 * Replace European digits (U+0030...U+0039) by Arabic-Indic digits
509 * if the most recent strongly directional character
510 * is an Arabic letter (its Bidi direction value is RIGHT_TO_LEFT_ARABIC).
511 * The initial state at the start of the text is assumed to be an Arabic,
512 * letter, so European digits at the start of the text will change.
513 * Compare to DIGITS_ALEN2AN_INT_LR.
514 * @stable ICU 2.0
515 */
516 public static final int DIGITS_EN2AN_INIT_AL = 0x80;
517
518 /** Not a valid option value. */
519 //private static final int DIGITS_RESERVED = 0xa0;
520
521 /**
522 * Bit mask for digit shaping options.
523 * @stable ICU 2.0
524 */
525 public static final int DIGITS_MASK = 0xe0;
526
527 /**
528 * Digit type option: Use Arabic-Indic digits (U+0660...U+0669).
529 * @stable ICU 2.0
530 */
531 public static final int DIGIT_TYPE_AN = 0;
532
533 /**
534 * Digit type option: Use Eastern (Extended) Arabic-Indic digits (U+06f0...U+06f9).
535 * @stable ICU 2.0
536 */
537 public static final int DIGIT_TYPE_AN_EXTENDED = 0x100;
538
539 /**
540 * Bit mask for digit type options.
541 * @stable ICU 2.0
542 */
543 public static final int DIGIT_TYPE_MASK = 0x0100; // 0x3f00?
544
545 /**
546 * some constants
547 */
548 private static final char HAMZAFE_CHAR = '\ufe80';
549 private static final char HAMZA06_CHAR = '\u0621';
550 private static final char YEH_HAMZA_CHAR = '\u0626';
551 private static final char YEH_HAMZAFE_CHAR = '\uFE89';
552 private static final char LAMALEF_SPACE_SUB = '\uffff';
553 private static final char TASHKEEL_SPACE_SUB = '\ufffe';
554 private static final char LAM_CHAR = '\u0644';
555 private static final char SPACE_CHAR = '\u0020';
556 private static final char SPACE_CHAR_FOR_LAMALEF = '\ufeff'; // XXX: tweak for TextLine use
557 private static final char SHADDA_CHAR = '\uFE7C';
558 private static final char TATWEEL_CHAR = '\u0640';
559 private static final char SHADDA_TATWEEL_CHAR = '\uFE7D';
560 private static final char NEW_TAIL_CHAR = '\uFE73';
561 private static final char OLD_TAIL_CHAR = '\u200B';
562 private static final int SHAPE_MODE = 0;
563 private static final int DESHAPE_MODE = 1;
564
565 /**
566 * @stable ICU 2.0
567 */
568 public boolean equals(Object rhs) {
569 return rhs != null &&
570 rhs.getClass() == ArabicShaping.class &&
571 options == ((ArabicShaping)rhs).options;
572 }
573
574 /**
575 * @stable ICU 2.0
576 */
577 ///CLOVER:OFF
578 public int hashCode() {
579 return options;
580 }
581
582 /**
583 * @stable ICU 2.0
584 */
585 public String toString() {
586 StringBuffer buf = new StringBuffer(super.toString());
587 buf.append('[');
588
589 switch (options & LAMALEF_MASK) {
590 case LAMALEF_RESIZE: buf.append("LamAlef resize"); break;
591 case LAMALEF_NEAR: buf.append("LamAlef spaces at near"); break;
592 case LAMALEF_BEGIN: buf.append("LamAlef spaces at begin"); break;
593 case LAMALEF_END: buf.append("LamAlef spaces at end"); break;
594 case LAMALEF_AUTO: buf.append("lamAlef auto"); break;
595 }
596 switch (options & TEXT_DIRECTION_MASK) {
597 case TEXT_DIRECTION_LOGICAL: buf.append(", logical"); break;
598 case TEXT_DIRECTION_VISUAL_LTR: buf.append(", visual"); break;
599 }
600 switch (options & LETTERS_MASK) {
601 case LETTERS_NOOP: buf.append(", no letter shaping"); break;
602 case LETTERS_SHAPE: buf.append(", shape letters"); break;
603 case LETTERS_SHAPE_TASHKEEL_ISOLATED: buf.append(", shape letters tashkeel isolated"); break;
604 case LETTERS_UNSHAPE: buf.append(", unshape letters"); break;
605 }
606 switch (options & SEEN_MASK) {
607 case SEEN_TWOCELL_NEAR: buf.append(", Seen at near"); break;
608 }
609 switch (options & YEHHAMZA_MASK) {
610 case YEHHAMZA_TWOCELL_NEAR: buf.append(", Yeh Hamza at near"); break;
611 }
612 switch (options & TASHKEEL_MASK) {
613 case TASHKEEL_BEGIN: buf.append(", Tashkeel at begin"); break;
614 case TASHKEEL_END: buf.append(", Tashkeel at end"); break;
615 case TASHKEEL_REPLACE_BY_TATWEEL: buf.append(", Tashkeel replace with tatweel"); break;
616 case TASHKEEL_RESIZE: buf.append(", Tashkeel resize"); break;
617 }
618
619 switch (options & DIGITS_MASK) {
620 case DIGITS_NOOP: buf.append(", no digit shaping"); break;
621 case DIGITS_EN2AN: buf.append(", shape digits to AN"); break;
622 case DIGITS_AN2EN: buf.append(", shape digits to EN"); break;
623 case DIGITS_EN2AN_INIT_LR: buf.append(", shape digits to AN contextually: default EN"); break;
624 case DIGITS_EN2AN_INIT_AL: buf.append(", shape digits to AN contextually: default AL"); break;
625 }
626 switch (options & DIGIT_TYPE_MASK) {
627 case DIGIT_TYPE_AN: buf.append(", standard Arabic-Indic digits"); break;
628 case DIGIT_TYPE_AN_EXTENDED: buf.append(", extended Arabic-Indic digits"); break;
629 }
630 buf.append("]");
631
632 return buf.toString();
633 }
634 ///CLOVER:ON
635
636 //
637 // ported api
638 //
639
640 private static final int IRRELEVANT = 4;
641 private static final int LAMTYPE = 16;
642 private static final int ALEFTYPE = 32;
643
644 private static final int LINKR = 1;
645 private static final int LINKL = 2;
646 private static final int LINK_MASK = 3;
647
648 private static final int irrelevantPos[] = {
649 0x0, 0x2, 0x4, 0x6, 0x8, 0xA, 0xC, 0xE
650 };
651
652/*
653 private static final char convertLamAlef[] = {
654 '\u0622', // FEF5
655 '\u0622', // FEF6
656 '\u0623', // FEF7
657 '\u0623', // FEF8
658 '\u0625', // FEF9
659 '\u0625', // FEFA
660 '\u0627', // FEFB
661 '\u0627' // FEFC
662 };
663*/
664
665 private static final int tailFamilyIsolatedFinal[] = {
666 /* FEB1 */ 1,
667 /* FEB2 */ 1,
668 /* FEB3 */ 0,
669 /* FEB4 */ 0,
670 /* FEB5 */ 1,
671 /* FEB6 */ 1,
672 /* FEB7 */ 0,
673 /* FEB8 */ 0,
674 /* FEB9 */ 1,
675 /* FEBA */ 1,
676 /* FEBB */ 0,
677 /* FEBC */ 0,
678 /* FEBD */ 1,
679 /* FEBE */ 1
680 };
681
682 private static final int tashkeelMedial[] = {
683 /* FE70 */ 0,
684 /* FE71 */ 1,
685 /* FE72 */ 0,
686 /* FE73 */ 0,
687 /* FE74 */ 0,
688 /* FE75 */ 0,
689 /* FE76 */ 0,
690 /* FE77 */ 1,
691 /* FE78 */ 0,
692 /* FE79 */ 1,
693 /* FE7A */ 0,
694 /* FE7B */ 1,
695 /* FE7C */ 0,
696 /* FE7D */ 1,
697 /* FE7E */ 0,
698 /* FE7F */ 1
699 };
700
701 private static final char yehHamzaToYeh[] =
702 {
703 /* isolated*/ 0xFEEF,
704 /* final */ 0xFEF0
705 };
706
707 private static final char convertNormalizedLamAlef[] = {
708 '\u0622', // 065C
709 '\u0623', // 065D
710 '\u0625', // 065E
711 '\u0627', // 065F
712 };
713
714 private static final int[] araLink = {
715 1 + 32 + 256 * 0x11, /*0x0622*/
716 1 + 32 + 256 * 0x13, /*0x0623*/
717 1 + 256 * 0x15, /*0x0624*/
718 1 + 32 + 256 * 0x17, /*0x0625*/
719 1 + 2 + 256 * 0x19, /*0x0626*/
720 1 + 32 + 256 * 0x1D, /*0x0627*/
721 1 + 2 + 256 * 0x1F, /*0x0628*/
722 1 + 256 * 0x23, /*0x0629*/
723 1 + 2 + 256 * 0x25, /*0x062A*/
724 1 + 2 + 256 * 0x29, /*0x062B*/
725 1 + 2 + 256 * 0x2D, /*0x062C*/
726 1 + 2 + 256 * 0x31, /*0x062D*/
727 1 + 2 + 256 * 0x35, /*0x062E*/
728 1 + 256 * 0x39, /*0x062F*/
729 1 + 256 * 0x3B, /*0x0630*/
730 1 + 256 * 0x3D, /*0x0631*/
731 1 + 256 * 0x3F, /*0x0632*/
732 1 + 2 + 256 * 0x41, /*0x0633*/
733 1 + 2 + 256 * 0x45, /*0x0634*/
734 1 + 2 + 256 * 0x49, /*0x0635*/
735 1 + 2 + 256 * 0x4D, /*0x0636*/
736 1 + 2 + 256 * 0x51, /*0x0637*/
737 1 + 2 + 256 * 0x55, /*0x0638*/
738 1 + 2 + 256 * 0x59, /*0x0639*/
739 1 + 2 + 256 * 0x5D, /*0x063A*/
740 0, 0, 0, 0, 0, /*0x063B-0x063F*/
741 1 + 2, /*0x0640*/
742 1 + 2 + 256 * 0x61, /*0x0641*/
743 1 + 2 + 256 * 0x65, /*0x0642*/
744 1 + 2 + 256 * 0x69, /*0x0643*/
745 1 + 2 + 16 + 256 * 0x6D, /*0x0644*/
746 1 + 2 + 256 * 0x71, /*0x0645*/
747 1 + 2 + 256 * 0x75, /*0x0646*/
748 1 + 2 + 256 * 0x79, /*0x0647*/
749 1 + 256 * 0x7D, /*0x0648*/
750 1 + 256 * 0x7F, /*0x0649*/
751 1 + 2 + 256 * 0x81, /*0x064A*/
752 4, 4, 4, 4, /*0x064B-0x064E*/
753 4, 4, 4, 4, /*0x064F-0x0652*/
754 4, 4, 4, 0, 0, /*0x0653-0x0657*/
755 0, 0, 0, 0, /*0x0658-0x065B*/
756 1 + 256 * 0x85, /*0x065C*/
757 1 + 256 * 0x87, /*0x065D*/
758 1 + 256 * 0x89, /*0x065E*/
759 1 + 256 * 0x8B, /*0x065F*/
760 0, 0, 0, 0, 0, /*0x0660-0x0664*/
761 0, 0, 0, 0, 0, /*0x0665-0x0669*/
762 0, 0, 0, 0, 0, 0, /*0x066A-0x066F*/
763 4, /*0x0670*/
764 0, /*0x0671*/
765 1 + 32, /*0x0672*/
766 1 + 32, /*0x0673*/
767 0, /*0x0674*/
768 1 + 32, /*0x0675*/
769 1, 1, /*0x0676-0x0677*/
770 1+2, 1+2, 1+2, 1+2, 1+2, 1+2, /*0x0678-0x067D*/
771 1+2, 1+2, 1+2, 1+2, 1+2, 1+2, /*0x067E-0x0683*/
772 1+2, 1+2, 1+2, 1+2, /*0x0684-0x0687*/
773 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /*0x0688-0x0691*/
774 1, 1, 1, 1, 1, 1, 1, 1, /*0x0692-0x0699*/
775 1+2, 1+2, 1+2, 1+2, 1+2, 1+2, /*0x069A-0x06A3*/
776 1+2, 1+2, 1+2, 1+2, /*0x069A-0x06A3*/
777 1+2, 1+2, 1+2, 1+2, 1+2, 1+2, /*0x06A4-0x06AD*/
778 1+2, 1+2, 1+2, 1+2, /*0x06A4-0x06AD*/
779 1+2, 1+2, 1+2, 1+2, 1+2, 1+2, /*0x06AE-0x06B7*/
780 1+2, 1+2, 1+2, 1+2, /*0x06AE-0x06B7*/
781 1+2, 1+2, 1+2, 1+2, 1+2, 1+2, /*0x06B8-0x06BF*/
782 1+2, 1+2, /*0x06B8-0x06BF*/
783 1, /*0x06C0*/
784 1+2, /*0x06C1*/
785 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /*0x06C2-0x06CB*/
786 1+2, /*0x06CC*/
787 1, /*0x06CD*/
788 1+2, 1+2, 1+2, 1+2, /*0x06CE-0x06D1*/
789 1, 1 /*0x06D2-0x06D3*/
790 };
791
792 private static final int[] presLink = {
793 1 + 2, /*0xFE70*/
794 1 + 2, /*0xFE71*/
795 1 + 2, 0, 1+ 2, 0, 1+ 2, /*0xFE72-0xFE76*/
796 1 + 2, /*0xFE77*/
797 1+ 2, 1 + 2, 1+2, 1 + 2, /*0xFE78-0xFE81*/
798 1+ 2, 1 + 2, 1+2, 1 + 2, /*0xFE82-0xFE85*/
799 0, 0 + 32, 1 + 32, 0 + 32, /*0xFE86-0xFE89*/
800 1 + 32, 0, 1, 0 + 32, /*0xFE8A-0xFE8D*/
801 1 + 32, 0, 2, 1 + 2, /*0xFE8E-0xFE91*/
802 1, 0 + 32, 1 + 32, 0, /*0xFE92-0xFE95*/
803 2, 1 + 2, 1, 0, /*0xFE96-0xFE99*/
804 1, 0, 2, 1 + 2, /*0xFE9A-0xFE9D*/
805 1, 0, 2, 1 + 2, /*0xFE9E-0xFEA1*/
806 1, 0, 2, 1 + 2, /*0xFEA2-0xFEA5*/
807 1, 0, 2, 1 + 2, /*0xFEA6-0xFEA9*/
808 1, 0, 2, 1 + 2, /*0xFEAA-0xFEAD*/
809 1, 0, 1, 0, /*0xFEAE-0xFEB1*/
810 1, 0, 1, 0, /*0xFEB2-0xFEB5*/
811 1, 0, 2, 1+2, /*0xFEB6-0xFEB9*/
812 1, 0, 2, 1+2, /*0xFEBA-0xFEBD*/
813 1, 0, 2, 1+2, /*0xFEBE-0xFEC1*/
814 1, 0, 2, 1+2, /*0xFEC2-0xFEC5*/
815 1, 0, 2, 1+2, /*0xFEC6-0xFEC9*/
816 1, 0, 2, 1+2, /*0xFECA-0xFECD*/
817 1, 0, 2, 1+2, /*0xFECE-0xFED1*/
818 1, 0, 2, 1+2, /*0xFED2-0xFED5*/
819 1, 0, 2, 1+2, /*0xFED6-0xFED9*/
820 1, 0, 2, 1+2, /*0xFEDA-0xFEDD*/
821 1, 0, 2, 1+2, /*0xFEDE-0xFEE1*/
822 1, 0 + 16, 2 + 16, 1 + 2 +16, /*0xFEE2-0xFEE5*/
823 1 + 16, 0, 2, 1+2, /*0xFEE6-0xFEE9*/
824 1, 0, 2, 1+2, /*0xFEEA-0xFEED*/
825 1, 0, 2, 1+2, /*0xFEEE-0xFEF1*/
826 1, 0, 1, 0, /*0xFEF2-0xFEF5*/
827 1, 0, 2, 1+2, /*0xFEF6-0xFEF9*/
828 1, 0, 1, 0, /*0xFEFA-0xFEFD*/
829 1, 0, 1, 0,
830 1
831 };
832
833 private static int[] convertFEto06 = {
834 /***********0******1******2******3******4******5******6******7******8******9******A******B******C******D******E******F***/
835 /*FE7*/ 0x64B, 0x64B, 0x64C, 0x64C, 0x64D, 0x64D, 0x64E, 0x64E, 0x64F, 0x64F, 0x650, 0x650, 0x651, 0x651, 0x652, 0x652,
836 /*FE8*/ 0x621, 0x622, 0x622, 0x623, 0x623, 0x624, 0x624, 0x625, 0x625, 0x626, 0x626, 0x626, 0x626, 0x627, 0x627, 0x628,
837 /*FE9*/ 0x628, 0x628, 0x628, 0x629, 0x629, 0x62A, 0x62A, 0x62A, 0x62A, 0x62B, 0x62B, 0x62B, 0x62B, 0x62C, 0x62C, 0x62C,
838 /*FEA*/ 0x62C, 0x62D, 0x62D, 0x62D, 0x62D, 0x62E, 0x62E, 0x62E, 0x62E, 0x62F, 0x62F, 0x630, 0x630, 0x631, 0x631, 0x632,
839 /*FEB*/ 0x632, 0x633, 0x633, 0x633, 0x633, 0x634, 0x634, 0x634, 0x634, 0x635, 0x635, 0x635, 0x635, 0x636, 0x636, 0x636,
840 /*FEC*/ 0x636, 0x637, 0x637, 0x637, 0x637, 0x638, 0x638, 0x638, 0x638, 0x639, 0x639, 0x639, 0x639, 0x63A, 0x63A, 0x63A,
841 /*FED*/ 0x63A, 0x641, 0x641, 0x641, 0x641, 0x642, 0x642, 0x642, 0x642, 0x643, 0x643, 0x643, 0x643, 0x644, 0x644, 0x644,
842 /*FEE*/ 0x644, 0x645, 0x645, 0x645, 0x645, 0x646, 0x646, 0x646, 0x646, 0x647, 0x647, 0x647, 0x647, 0x648, 0x648, 0x649,
843 /*FEF*/ 0x649, 0x64A, 0x64A, 0x64A, 0x64A, 0x65C, 0x65C, 0x65D, 0x65D, 0x65E, 0x65E, 0x65F, 0x65F
844 };
845
846 private static final int shapeTable[][][] = {
847 { {0,0,0,0}, {0,0,0,0}, {0,1,0,3}, {0,1,0,1} },
848 { {0,0,2,2}, {0,0,1,2}, {0,1,1,2}, {0,1,1,3} },
849 { {0,0,0,0}, {0,0,0,0}, {0,1,0,3}, {0,1,0,3} },
850 { {0,0,1,2}, {0,0,1,2}, {0,1,1,2}, {0,1,1,3} }
851 };
852
853 /*
854 * This function shapes European digits to Arabic-Indic digits
855 * in-place, writing over the input characters. Data is in visual
856 * order.
857 */
858 private void shapeToArabicDigitsWithContext(char[] dest,
859 int start,
860 int length,
861 char digitBase,
862 boolean lastStrongWasAL) {
863 digitBase -= '0'; // move common adjustment out of loop
864
865 for(int i = start + length; --i >= start;) {
866 char ch = dest[i];
867 switch (Character.getDirectionality(ch)) {
868 case Character.DIRECTIONALITY_LEFT_TO_RIGHT:
869 case Character.DIRECTIONALITY_RIGHT_TO_LEFT:
870 lastStrongWasAL = false;
871 break;
872 case Character.DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC:
873 lastStrongWasAL = true;
874 break;
875 case Character.DIRECTIONALITY_EUROPEAN_NUMBER:
876 if (lastStrongWasAL && ch <= '\u0039') {
877 dest[i] = (char)(ch + digitBase);
878 }
879 break;
880 default:
881 break;
882 }
883 }
884 }
885
886 /*
887 * Name : invertBuffer
888 * Function: This function inverts the buffer, it's used
889 * in case the user specifies the buffer to be
890 * TEXT_DIRECTION_LOGICAL
891 */
892 private static void invertBuffer(char[] buffer,
893 int start,
894 int length) {
895
896 for(int i = start, j = start + length - 1; i < j; i++, --j) {
897 char temp = buffer[i];
898 buffer[i] = buffer[j];
899 buffer[j] = temp;
900 }
901 }
902
903 /*
904 * Name : changeLamAlef
905 * Function: Converts the Alef characters into an equivalent
906 * LamAlef location in the 0x06xx Range, this is an
907 * intermediate stage in the operation of the program
908 * later it'll be converted into the 0xFExx LamAlefs
909 * in the shaping function.
910 */
911 private static char changeLamAlef(char ch) {
912 switch(ch) {
913 case '\u0622': return '\u065C';
914 case '\u0623': return '\u065D';
915 case '\u0625': return '\u065E';
916 case '\u0627': return '\u065F';
917 default: return '\u0000'; // not a lamalef
918 }
919 }
920
921 /*
922 * Name : specialChar
923 * Function: Special Arabic characters need special handling in the shapeUnicode
924 * function, this function returns 1 or 2 for these special characters
925 */
926 private static int specialChar(char ch) {
927 if ((ch > '\u0621' && ch < '\u0626') ||
928 (ch == '\u0627') ||
929 (ch > '\u062E' && ch < '\u0633') ||
930 (ch > '\u0647' && ch < '\u064A') ||
931 (ch == '\u0629')) {
932 return 1;
933 } else if (ch >= '\u064B' && ch<= '\u0652') {
934 return 2;
935 } else if (ch >= 0x0653 && ch <= 0x0655 ||
936 ch == 0x0670 ||
937 ch >= 0xFE70 && ch <= 0xFE7F) {
938 return 3;
939 } else {
940 return 0;
941 }
942 }
943
944 /*
945 * Name : getLink
946 * Function: Resolves the link between the characters as
947 * Arabic characters have four forms :
948 * Isolated, Initial, Middle and Final Form
949 */
950 private static int getLink(char ch) {
951 if (ch >= '\u0622' && ch <= '\u06D3') {
952 return araLink[ch - '\u0622'];
953 } else if (ch == '\u200D') {
954 return 3;
955 } else if (ch >= '\u206D' && ch <= '\u206F') {
956 return 4;
957 } else if (ch >= '\uFE70' && ch <= '\uFEFC') {
958 return presLink[ch - '\uFE70'];
959 } else {
960 return 0;
961 }
962 }
963
964 /*
965 * Name : countSpaces
966 * Function: Counts the number of spaces
967 * at each end of the logical buffer
968 */
969 private static int countSpacesLeft(char[] dest,
970 int start,
971 int count) {
972 for (int i = start, e = start + count; i < e; ++i) {
973 if (dest[i] != SPACE_CHAR) {
974 return i - start;
975 }
976 }
977 return count;
978 }
979
980 private static int countSpacesRight(char[] dest,
981 int start,
982 int count) {
983
984 for (int i = start + count; --i >= start;) {
985 if (dest[i] != SPACE_CHAR) {
986 return start + count - 1 - i;
987 }
988 }
989 return count;
990 }
991
992 /*
993 * Name : isTashkeelChar
994 * Function: Returns true for Tashkeel characters else return false
995 */
996 private static boolean isTashkeelChar(char ch) {
997 return ( ch >='\u064B' && ch <= '\u0652' );
998 }
999
1000 /*
1001 *Name : isSeenTailFamilyChar
1002 *Function : returns 1 if the character is a seen family isolated character
1003 * in the FE range otherwise returns 0
1004 */
1005
1006 private static int isSeenTailFamilyChar(char ch) {
1007 if (ch >= 0xfeb1 && ch < 0xfebf){
1008 return tailFamilyIsolatedFinal [ch - 0xFEB1];
1009 } else {
1010 return 0;
1011 }
1012 }
1013
1014 /* Name : isSeenFamilyChar
1015 * Function : returns 1 if the character is a seen family character in the Unicode
1016 * 06 range otherwise returns 0
1017 */
1018
1019 private static int isSeenFamilyChar(char ch){
1020 if (ch >= 0x633 && ch <= 0x636){
1021 return 1;
1022 }else {
1023 return 0;
1024 }
1025 }
1026
1027 /*
1028 *Name : isTailChar
1029 *Function : returns true if the character matches one of the tail characters
1030 * (0xfe73 or 0x200b) otherwise returns false
1031 */
1032
1033 private static boolean isTailChar(char ch) {
1034 if(ch == OLD_TAIL_CHAR || ch == NEW_TAIL_CHAR){
1035 return true;
1036 }else{
1037 return false;
1038 }
1039 }
1040
1041 /*
1042 *Name : isAlefMaksouraChar
1043 *Function : returns true if the character is a Alef Maksoura Final or isolated
1044 * otherwise returns false
1045 */
1046 private static boolean isAlefMaksouraChar(char ch) {
1047 return ( (ch == 0xFEEF) || ( ch == 0xFEF0) || (ch == 0x0649));
1048 }
1049
1050 /*
1051 * Name : isYehHamzaChar
1052 * Function : returns true if the character is a yehHamza isolated or yehhamza
1053 * final is found otherwise returns false
1054 */
1055 private static boolean isYehHamzaChar(char ch) {
1056 if((ch==0xFE89)||(ch==0xFE8A)){
1057 return true;
1058 }else{
1059 return false;
1060 }
1061 }
1062
1063 /*
1064 *Name : isTashkeelCharFE
1065 *Function : Returns true for Tashkeel characters in FE range else return false
1066 */
1067
1068 private static boolean isTashkeelCharFE(char ch) {
1069 return ( ch!=0xFE75 &&(ch>=0xFE70 && ch<= 0xFE7F) );
1070 }
1071
1072 /*
1073 * Name: isTashkeelOnTatweelChar
1074 * Function: Checks if the Tashkeel Character is on Tatweel or not,if the
1075 * Tashkeel on tatweel (FE range), it returns 1 else if the
1076 * Tashkeel with shadda on tatweel (FC range)return 2 otherwise
1077 * returns 0
1078 */
1079 private static int isTashkeelOnTatweelChar(char ch){
1080 if (ch >= 0xfe70 && ch <= 0xfe7f && ch != NEW_TAIL_CHAR && ch != 0xFE75 && ch != SHADDA_TATWEEL_CHAR)
1081 {
1082 return tashkeelMedial [ch - 0xFE70];
1083 } else if( (ch >= 0xfcf2 && ch <= 0xfcf4) || (ch == SHADDA_TATWEEL_CHAR)) {
1084 return 2;
1085 } else {
1086 return 0;
1087 }
1088 }
1089
1090 /*
1091 * Name: isIsolatedTashkeelChar
1092 * Function: Checks if the Tashkeel Character is in the isolated form
1093 * (i.e. Unicode FE range) returns 1 else if the Tashkeel
1094 * with shadda is in the isolated form (i.e. Unicode FC range)
1095 * returns 1 otherwise returns 0
1096 */
1097 private static int isIsolatedTashkeelChar(char ch){
1098 if (ch >= 0xfe70 && ch <= 0xfe7f && ch != NEW_TAIL_CHAR && ch != 0xFE75){
1099 return (1 - tashkeelMedial [ch - 0xFE70]);
1100 } else if(ch >= 0xfc5e && ch <= 0xfc63){
1101 return 1;
1102 } else{
1103 return 0;
1104 }
1105 }
1106
1107 /*
1108 * Name : isAlefChar
1109 * Function: Returns 1 for Alef characters else return 0
1110 */
1111 private static boolean isAlefChar(char ch) {
1112 return ch == '\u0622' || ch == '\u0623' || ch == '\u0625' || ch == '\u0627';
1113 }
1114
1115 /*
1116 * Name : isLamAlefChar
1117 * Function: Returns true for LamAlef characters else return false
1118 */
1119 private static boolean isLamAlefChar(char ch) {
1120 return ch >= '\uFEF5' && ch <= '\uFEFC';
1121 }
1122
1123 private static boolean isNormalizedLamAlefChar(char ch) {
1124 return ch >= '\u065C' && ch <= '\u065F';
1125 }
1126
1127 /*
1128 * Name : calculateSize
1129 * Function: This function calculates the destSize to be used in preflighting
1130 * when the destSize is equal to 0
1131 */
1132 private int calculateSize(char[] source,
1133 int sourceStart,
1134 int sourceLength) {
1135
1136 int destSize = sourceLength;
1137
1138 switch (options & LETTERS_MASK) {
1139 case LETTERS_SHAPE:
1140 case LETTERS_SHAPE_TASHKEEL_ISOLATED:
1141 if (isLogical) {
1142 for (int i = sourceStart, e = sourceStart + sourceLength - 1; i < e; ++i) {
1143 if ((source[i] == LAM_CHAR && isAlefChar(source[i+1])) || isTashkeelCharFE(source[i])){
1144 --destSize;
1145 }
1146 }
1147 } else { // visual
1148 for(int i = sourceStart + 1, e = sourceStart + sourceLength; i < e; ++i) {
1149 if ((source[i] == LAM_CHAR && isAlefChar(source[i-1])) || isTashkeelCharFE(source[i])) {
1150 --destSize;
1151 }
1152 }
1153 }
1154 break;
1155
1156 case LETTERS_UNSHAPE:
1157 for(int i = sourceStart, e = sourceStart + sourceLength; i < e; ++i) {
1158 if (isLamAlefChar(source[i])) {
1159 destSize++;
1160 }
1161 }
1162 break;
1163
1164 default:
1165 break;
1166 }
1167
1168 return destSize;
1169 }
1170
1171
1172 /*
1173 * Name : countSpaceSub
1174 * Function: Counts number of times the subChar appears in the array
1175 */
1176 public static int countSpaceSub(char [] dest,int length, char subChar){
1177 int i = 0;
1178 int count = 0;
1179 while (i < length) {
1180 if (dest[i] == subChar) {
1181 count++;
1182 }
1183 i++;
1184 }
1185 return count;
1186 }
1187
1188 /*
1189 * Name : shiftArray
1190 * Function: Shifts characters to replace space sub characters
1191 */
1192 public static void shiftArray(char [] dest,int start, int e, char subChar){
1193 int w = e;
1194 int r = e;
1195 while (--r >= start) {
1196 char ch = dest[r];
1197 if (ch != subChar) {
1198 --w;
1199 if (w != r) {
1200 dest[w] = ch;
1201 }
1202 }
1203 }
1204 }
1205
1206 /*
1207 * Name : flipArray
1208 * Function: inverts array, so that start becomes end and vice versa
1209 */
1210 public static int flipArray(char [] dest, int start, int e, int w){
1211 int r;
1212 if (w > start) {
1213 // shift, assume small buffer size so don't use arraycopy
1214 r = w;
1215 w = start;
1216 while (r < e) {
1217 dest[w++] = dest[r++];
1218 }
1219 } else {
1220 w = e;
1221 }
1222 return w;
1223 }
1224
1225 /*
1226 * Name : handleTashkeelWithTatweel
1227 * Function : Replaces Tashkeel as following:
1228 * Case 1 :if the Tashkeel on tatweel, replace it with Tatweel.
1229 * Case 2 :if the Tashkeel aggregated with Shadda on Tatweel, replace
1230 * it with Shadda on Tatweel.
1231 * Case 3: if the Tashkeel is isolated replace it with Space.
1232 *
1233 */
1234 private static int handleTashkeelWithTatweel(char[] dest, int sourceLength) {
1235 int i;
1236 for(i = 0; i < sourceLength; i++){
1237 if((isTashkeelOnTatweelChar(dest[i]) == 1)){
1238 dest[i] = TATWEEL_CHAR;
1239 }else if((isTashkeelOnTatweelChar(dest[i]) == 2)){
1240 dest[i] = SHADDA_TATWEEL_CHAR;
1241 }else if((isIsolatedTashkeelChar(dest[i])==1) && dest[i] != SHADDA_CHAR){
1242 dest[i] = SPACE_CHAR;
1243 }
1244 }
1245 return sourceLength;
1246 }
1247
1248 /*
1249 *Name : handleGeneratedSpaces
1250 *Function : The shapeUnicode function converts Lam + Alef into LamAlef + space,
1251 * and Tashkeel to space.
1252 * handleGeneratedSpaces function puts these generated spaces
1253 * according to the options the user specifies. LamAlef and Tashkeel
1254 * spaces can be replaced at begin, at end, at near or decrease the
1255 * buffer size.
1256 *
1257 * There is also Auto option for LamAlef and tashkeel, which will put
1258 * the spaces at end of the buffer (or end of text if the user used
1259 * the option SPACES_RELATIVE_TO_TEXT_BEGIN_END).
1260 *
1261 * If the text type was visual_LTR and the option
1262 * SPACES_RELATIVE_TO_TEXT_BEGIN_END was selected the END
1263 * option will place the space at the beginning of the buffer and
1264 * BEGIN will place the space at the end of the buffer.
1265 */
1266 private int handleGeneratedSpaces(char[] dest,
1267 int start,
1268 int length) {
1269
1270 int lenOptionsLamAlef = options & LAMALEF_MASK;
1271 int lenOptionsTashkeel = options & TASHKEEL_MASK;
1272 boolean lamAlefOn = false;
1273 boolean tashkeelOn = false;
1274
1275 if (!isLogical & !spacesRelativeToTextBeginEnd) {
1276 switch (lenOptionsLamAlef) {
1277 case LAMALEF_BEGIN: lenOptionsLamAlef = LAMALEF_END; break;
1278 case LAMALEF_END: lenOptionsLamAlef = LAMALEF_BEGIN; break;
1279 default: break;
1280 }
1281 switch (lenOptionsTashkeel){
1282 case TASHKEEL_BEGIN: lenOptionsTashkeel = TASHKEEL_END; break;
1283 case TASHKEEL_END: lenOptionsTashkeel = TASHKEEL_BEGIN; break;
1284 default: break;
1285 }
1286 }
1287
1288
1289 if (lenOptionsLamAlef == LAMALEF_NEAR) {
1290 for (int i = start, e = i + length; i < e; ++i) {
1291 if (dest[i] == LAMALEF_SPACE_SUB) {
1292 dest[i] = SPACE_CHAR_FOR_LAMALEF;
1293 }
1294 }
1295
1296 } else {
1297
1298 final int e = start + length;
1299 int wL = countSpaceSub(dest, length, LAMALEF_SPACE_SUB);
1300 int wT = countSpaceSub(dest, length, TASHKEEL_SPACE_SUB);
1301
1302 if (lenOptionsLamAlef == LAMALEF_END){
1303 lamAlefOn = true;
1304 }
1305 if (lenOptionsTashkeel == TASHKEEL_END){
1306 tashkeelOn = true;
1307 }
1308
1309
1310 if (lamAlefOn && (lenOptionsLamAlef == LAMALEF_END)) {
1311 shiftArray(dest, start, e, LAMALEF_SPACE_SUB);
1312 while (wL > start) {
1313 dest[--wL] = SPACE_CHAR;
1314 }
1315 }
1316
1317 if (tashkeelOn && (lenOptionsTashkeel == TASHKEEL_END)){
1318 shiftArray(dest, start, e, TASHKEEL_SPACE_SUB);
1319 while (wT > start) {
1320 dest[--wT] = SPACE_CHAR;
1321 }
1322 }
1323
1324 lamAlefOn = false;
1325 tashkeelOn = false;
1326
1327 if (lenOptionsLamAlef == LAMALEF_RESIZE){
1328 lamAlefOn = true;
1329 }
1330 if (lenOptionsTashkeel == TASHKEEL_RESIZE){
1331 tashkeelOn = true;
1332 }
1333
1334 if (lamAlefOn && (lenOptionsLamAlef == LAMALEF_RESIZE)){
1335 shiftArray(dest, start, e, LAMALEF_SPACE_SUB);
1336 wL = flipArray(dest,start,e, wL);
1337 length = wL - start;
1338 }
1339 if (tashkeelOn && (lenOptionsTashkeel == TASHKEEL_RESIZE)) {
1340 shiftArray(dest, start, e, TASHKEEL_SPACE_SUB);
1341 wT = flipArray(dest,start,e, wT);
1342 length = wT - start;
1343 }
1344
1345 lamAlefOn = false;
1346 tashkeelOn = false;
1347
1348 if ((lenOptionsLamAlef == LAMALEF_BEGIN) ||
1349 (lenOptionsLamAlef == LAMALEF_AUTO)){
1350 lamAlefOn = true;
1351 }
1352 if (lenOptionsTashkeel == TASHKEEL_BEGIN){
1353 tashkeelOn = true;
1354 }
1355
1356 if (lamAlefOn && ((lenOptionsLamAlef == LAMALEF_BEGIN)||
1357 (lenOptionsLamAlef == LAMALEF_AUTO))) { // spaces at beginning
1358 shiftArray(dest, start, e, LAMALEF_SPACE_SUB);
1359 wL = flipArray(dest,start,e, wL);
1360 while (wL < e) {
1361 dest[wL++] = SPACE_CHAR;
1362 }
1363 }
1364 if(tashkeelOn && (lenOptionsTashkeel == TASHKEEL_BEGIN)){
1365 shiftArray(dest, start, e, TASHKEEL_SPACE_SUB);
1366 wT = flipArray(dest,start,e, wT);
1367 while (wT < e) {
1368 dest[wT++] = SPACE_CHAR;
1369 }
1370 }
1371 }
1372
1373 return length;
1374 }
1375
1376
1377 /*
1378 *Name :expandCompositCharAtBegin
1379 *Function :Expands the LamAlef character to Lam and Alef consuming the required
1380 * space from beginning of the buffer. If the text type was visual_LTR
1381 * and the option SPACES_RELATIVE_TO_TEXT_BEGIN_END was selected
1382 * the spaces will be located at end of buffer.
1383 * If there are no spaces to expand the LamAlef, an exception is thrown.
1384*/
1385 private boolean expandCompositCharAtBegin(char[] dest,int start, int length,
1386 int lacount) {
1387 boolean spaceNotFound = false;
1388
1389 if (lacount > countSpacesRight(dest, start, length)) {
1390 spaceNotFound = true;
1391 return spaceNotFound;
1392 }
1393 for (int r = start + length - lacount, w = start + length; --r >= start;) {
1394 char ch = dest[r];
1395 if (isNormalizedLamAlefChar(ch)) {
1396 dest[--w] = LAM_CHAR;
1397 dest[--w] = convertNormalizedLamAlef[ch - '\u065C'];
1398 } else {
1399 dest[--w] = ch;
1400 }
1401 }
1402 return spaceNotFound;
1403
1404 }
1405
1406 /*
1407 *Name : expandCompositCharAtEnd
1408 *Function : Expands the LamAlef character to Lam and Alef consuming the
1409 * required space from end of the buffer. If the text type was
1410 * Visual LTR and the option SPACES_RELATIVE_TO_TEXT_BEGIN_END
1411 * was used, the spaces will be consumed from begin of buffer. If
1412 * there are no spaces to expand the LamAlef, an exception is thrown.
1413 */
1414
1415 private boolean expandCompositCharAtEnd(char[] dest,int start, int length,
1416 int lacount){
1417 boolean spaceNotFound = false;
1418
1419 if (lacount > countSpacesLeft(dest, start, length)) {
1420 spaceNotFound = true;
1421 return spaceNotFound;
1422 }
1423 for (int r = start + lacount, w = start, e = start + length; r < e; ++r) {
1424 char ch = dest[r];
1425 if (isNormalizedLamAlefChar(ch)) {
1426 dest[w++] = convertNormalizedLamAlef[ch - '\u065C'];
1427 dest[w++] = LAM_CHAR;
1428 } else {
1429 dest[w++] = ch;
1430 }
1431 }
1432 return spaceNotFound;
1433 }
1434
1435 /*
1436 *Name : expandCompositCharAtNear
1437 *Function : Expands the LamAlef character into Lam + Alef, YehHamza character
1438 * into Yeh + Hamza, SeenFamily character into SeenFamily character
1439 * + Tail, while consuming the space next to the character.
1440 */
1441
1442 private boolean expandCompositCharAtNear(char[] dest,int start, int length,
1443 int yehHamzaOption, int seenTailOption, int lamAlefOption){
1444
1445 boolean spaceNotFound = false;
1446
1447
1448
1449 if (isNormalizedLamAlefChar(dest[start])) {
1450 spaceNotFound = true;
1451 return spaceNotFound;
1452 }
1453 for (int i = start + length; --i >=start;) {
1454 char ch = dest[i];
1455 if (lamAlefOption == 1 && isNormalizedLamAlefChar(ch)) {
1456 if (i>start &&dest[i-1] == SPACE_CHAR) {
1457 dest[i] = LAM_CHAR;
1458 dest[--i] = convertNormalizedLamAlef[ch - '\u065C'];
1459 } else {
1460 spaceNotFound = true;
1461 return spaceNotFound;
1462 }
1463 }else if(seenTailOption == 1 && isSeenTailFamilyChar(ch) == 1){
1464 if(i>start &&dest[i-1] == SPACE_CHAR){
1465 dest[i-1] = tailChar;
1466 } else{
1467 spaceNotFound = true;
1468 return spaceNotFound;
1469 }
1470 }else if(yehHamzaOption == 1 && isYehHamzaChar(ch)){
1471
1472 if(i>start &&dest[i-1] == SPACE_CHAR){
1473 dest[i] = yehHamzaToYeh[ch - YEH_HAMZAFE_CHAR];
1474 dest[i-1] = HAMZAFE_CHAR;
1475 }else{
1476 spaceNotFound = true;
1477 return spaceNotFound;
1478 }
1479
1480
1481 }
1482 }
1483 return false;
1484
1485 }
1486
1487 /*
1488 * Name : expandCompositChar
1489 * Function: LamAlef needs special handling as the LamAlef is
1490 * one character while expanding it will give two
1491 * characters Lam + Alef, so we need to expand the LamAlef
1492 * in near or far spaces according to the options the user
1493 * specifies or increase the buffer size.
1494 * Dest has enough room for the expansion if we are growing.
1495 * lamalef are normalized to the 'special characters'
1496 */
1497 private int expandCompositChar(char[] dest,
1498 int start,
1499 int length,
1500 int lacount,
1501 int shapingMode) throws ArabicShapingException {
1502
1503 int lenOptionsLamAlef = options & LAMALEF_MASK;
1504 int lenOptionsSeen = options & SEEN_MASK;
1505 int lenOptionsYehHamza = options & YEHHAMZA_MASK;
1506 boolean spaceNotFound = false;
1507
1508 if (!isLogical && !spacesRelativeToTextBeginEnd) {
1509 switch (lenOptionsLamAlef) {
1510 case LAMALEF_BEGIN: lenOptionsLamAlef = LAMALEF_END; break;
1511 case LAMALEF_END: lenOptionsLamAlef = LAMALEF_BEGIN; break;
1512 default: break;
1513 }
1514 }
1515
1516 if(shapingMode == 1){
1517 if(lenOptionsLamAlef == LAMALEF_AUTO){
1518 if(isLogical){
1519 spaceNotFound = expandCompositCharAtEnd(dest, start, length, lacount);
1520 if(spaceNotFound){
1521 spaceNotFound = expandCompositCharAtBegin(dest, start, length, lacount);
1522 }
1523 if(spaceNotFound){
1524 spaceNotFound = expandCompositCharAtNear(dest, start, length,0,0,1);
1525 }
1526 if(spaceNotFound){
1527 throw new ArabicShapingException("No spacefor lamalef");
1528 }
1529 }else{
1530 spaceNotFound = expandCompositCharAtBegin(dest, start, length, lacount);
1531 if(spaceNotFound){
1532 spaceNotFound = expandCompositCharAtEnd(dest, start, length, lacount);
1533 }
1534 if(spaceNotFound){
1535 spaceNotFound = expandCompositCharAtNear(dest, start, length,0,0,1);
1536 }
1537 if(spaceNotFound){
1538 throw new ArabicShapingException("No spacefor lamalef");
1539 }
1540 }
1541 }else if(lenOptionsLamAlef == LAMALEF_END){
1542 spaceNotFound = expandCompositCharAtEnd(dest, start, length, lacount);
1543 if(spaceNotFound){
1544 throw new ArabicShapingException("No spacefor lamalef");
1545 }
1546 }else if(lenOptionsLamAlef == LAMALEF_BEGIN){
1547 spaceNotFound = expandCompositCharAtBegin(dest, start, length, lacount);
1548 if(spaceNotFound){
1549 throw new ArabicShapingException("No spacefor lamalef");
1550 }
1551 }else if(lenOptionsLamAlef == LAMALEF_NEAR){
1552 spaceNotFound = expandCompositCharAtNear(dest, start, length,0,0,1);
1553 if(spaceNotFound){
1554 throw new ArabicShapingException("No spacefor lamalef");
1555 }
1556 }else if(lenOptionsLamAlef == LAMALEF_RESIZE){
1557 for (int r = start + length, w = r + lacount; --r >= start;) {
1558 char ch = dest[r];
1559 if (isNormalizedLamAlefChar(ch)) {
1560 dest[--w] = '\u0644';
1561 dest[--w] = convertNormalizedLamAlef[ch - '\u065C'];
1562 } else {
1563 dest[--w] = ch;
1564 }
1565 }
1566 length += lacount;
1567 }
1568 }else{
1569 if(lenOptionsSeen == SEEN_TWOCELL_NEAR){
1570 spaceNotFound = expandCompositCharAtNear(dest, start, length,0,1,0);
1571 if(spaceNotFound){
1572 throw new ArabicShapingException("No space for Seen tail expansion");
1573 }
1574 }
1575 if(lenOptionsYehHamza == YEHHAMZA_TWOCELL_NEAR){
1576 spaceNotFound = expandCompositCharAtNear(dest, start, length,1,0,0);
1577 if(spaceNotFound){
1578 throw new ArabicShapingException("No space for YehHamza expansion");
1579 }
1580 }
1581 }
1582 return length;
1583 }
1584
1585
1586 /* Convert the input buffer from FExx Range into 06xx Range
1587 * to put all characters into the 06xx range
1588 * even the lamalef is converted to the special region in
1589 * the 06xx range. Return the number of lamalef chars found.
1590 */
1591 private int normalize(char[] dest, int start, int length) {
1592 int lacount = 0;
1593 for (int i = start, e = i + length; i < e; ++i) {
1594 char ch = dest[i];
1595 if (ch >= '\uFE70' && ch <= '\uFEFC') {
1596 if (isLamAlefChar(ch)) {
1597 ++lacount;
1598 }
1599 dest[i] = (char)convertFEto06[ch - '\uFE70'];
1600 }
1601 }
1602 return lacount;
1603 }
1604
1605 /*
1606 * Name : deshapeNormalize
1607 * Function: Convert the input buffer from FExx Range into 06xx Range
1608 * even the lamalef is converted to the special region in the 06xx range.
1609 * According to the options the user enters, all seen family characters
1610 * followed by a tail character are merged to seen tail family character and
1611 * any yeh followed by a hamza character are merged to yehhamza character.
1612 * Method returns the number of lamalef chars found.
1613 */
1614 private int deshapeNormalize(char[] dest, int start, int length) {
1615 int lacount = 0;
1616 int yehHamzaComposeEnabled = 0;
1617 int seenComposeEnabled = 0;
1618
1619 yehHamzaComposeEnabled = ((options&YEHHAMZA_MASK) == YEHHAMZA_TWOCELL_NEAR) ? 1 : 0;
1620 seenComposeEnabled = ((options&SEEN_MASK) == SEEN_TWOCELL_NEAR)? 1 : 0;
1621
1622 for (int i = start, e = i + length; i < e; ++i) {
1623 char ch = dest[i];
1624
1625 if( (yehHamzaComposeEnabled == 1) && ((ch == HAMZA06_CHAR) || (ch == HAMZAFE_CHAR))
1626 && (i < (length - 1)) && isAlefMaksouraChar(dest[i+1] )) {
1627 dest[i] = SPACE_CHAR;
1628 dest[i+1] = YEH_HAMZA_CHAR;
1629 } else if ( (seenComposeEnabled == 1) && (isTailChar(ch)) && (i< (length - 1))
1630 && (isSeenTailFamilyChar(dest[i+1])==1) ) {
1631 dest[i] = SPACE_CHAR;
1632 }
1633 else if (ch >= '\uFE70' && ch <= '\uFEFC') {
1634 if (isLamAlefChar(ch)) {
1635 ++lacount;
1636 }
1637 dest[i] = (char)convertFEto06[ch - '\uFE70'];
1638 }
1639 }
1640 return lacount;
1641 }
1642
1643 /*
1644 * Name : shapeUnicode
1645 * Function: Converts an Arabic Unicode buffer in 06xx Range into a shaped
1646 * arabic Unicode buffer in FExx Range
1647 */
1648 private int shapeUnicode(char[] dest,
1649 int start,
1650 int length,
1651 int destSize,
1652 int tashkeelFlag)throws ArabicShapingException {
1653
1654 int lamalef_count = normalize(dest, start, length);
1655
1656 // resolve the link between the characters.
1657 // Arabic characters have four forms: Isolated, Initial, Medial and Final.
1658 // Tashkeel characters have two, isolated or medial, and sometimes only isolated.
1659 // tashkeelFlag == 0: shape normally, 1: shape isolated, 2: don't shape
1660
1661 boolean lamalef_found = false, seenfam_found = false;
1662 boolean yehhamza_found = false, tashkeel_found = false;
1663 int i = start + length - 1;
1664 int currLink = getLink(dest[i]);
1665 int nextLink = 0;
1666 int prevLink = 0;
1667 int lastLink = 0;
1668 //int prevPos = i;
1669 int lastPos = i;
1670 int nx = -2;
1671 int nw = 0;
1672
1673 while (i >= 0) {
1674 // If high byte of currLink > 0 then there might be more than one shape
1675 if ((currLink & '\uFF00') > 0 || isTashkeelChar(dest[i])) {
1676 nw = i - 1;
1677 nx = -2;
1678 while (nx < 0) { // we need to know about next char
1679 if (nw == -1) {
1680 nextLink = 0;
1681 nx = Integer.MAX_VALUE;
1682 } else {
1683 nextLink = getLink(dest[nw]);
1684 if ((nextLink & IRRELEVANT) == 0) {
1685 nx = nw;
1686 } else {
1687 --nw;
1688 }
1689 }
1690 }
1691
1692 if (((currLink & ALEFTYPE) > 0) && ((lastLink & LAMTYPE) > 0)) {
1693 lamalef_found = true;
1694 char wLamalef = changeLamAlef(dest[i]); // get from 0x065C-0x065f
1695 if (wLamalef != '\u0000') {
1696 // replace alef by marker, it will be removed later
1697 dest[i] = '\uffff';
1698 dest[lastPos] = wLamalef;
1699 i = lastPos;
1700 }
1701
1702 lastLink = prevLink;
1703 currLink = getLink(wLamalef); // requires '\u0000', unfortunately
1704 }
1705 if ((i > 0) && (dest[i-1] == SPACE_CHAR))
1706 {
1707 if ( isSeenFamilyChar(dest[i]) == 1){
1708 seenfam_found = true;
1709 } else if (dest[i] == YEH_HAMZA_CHAR) {
1710 yehhamza_found = true;
1711 }
1712 }
1713 else if(i==0){
1714 if ( isSeenFamilyChar(dest[i]) == 1){
1715 seenfam_found = true;
1716 } else if (dest[i] == YEH_HAMZA_CHAR) {
1717 yehhamza_found = true;
1718 }
1719 }
1720
1721
1722 // get the proper shape according to link ability of neighbors
1723 // and of character; depends on the order of the shapes
1724 // (isolated, initial, middle, final) in the compatibility area
1725
1726 int flag = specialChar(dest[i]);
1727
1728 int shape = shapeTable[nextLink & LINK_MASK]
1729 [lastLink & LINK_MASK]
1730 [currLink & LINK_MASK];
1731
1732 if (flag == 1) {
1733 shape &= 0x1;
1734 } else if (flag == 2) {
1735 if (tashkeelFlag == 0 &&
1736 ((lastLink & LINKL) != 0) &&
1737 ((nextLink & LINKR) != 0) &&
1738 dest[i] != '\u064C' &&
1739 dest[i] != '\u064D' &&
1740 !((nextLink & ALEFTYPE) == ALEFTYPE &&
1741 (lastLink & LAMTYPE) == LAMTYPE)) {
1742
1743 shape = 1;
1744 } else {
1745 shape = 0;
1746 }
1747 }
1748 if (flag == 2) {
1749 if (tashkeelFlag == 2) {
1750 dest[i] = TASHKEEL_SPACE_SUB;
1751 tashkeel_found = true;
1752 }
1753 else{
1754 dest[i] = (char)('\uFE70' + irrelevantPos[dest[i] - '\u064B'] + shape);
1755 }
1756 // else leave tashkeel alone
1757 } else {
1758 dest[i] = (char)('\uFE70' + (currLink >> 8) + shape);
1759 }
1760 }
1761
1762 // move one notch forward
1763 if ((currLink & IRRELEVANT) == 0) {
1764 prevLink = lastLink;
1765 lastLink = currLink;
1766 //prevPos = lastPos;
1767 lastPos = i;
1768 }
1769
1770 --i;
1771 if (i == nx) {
1772 currLink = nextLink;
1773 nx = -2;
1774 } else if (i != -1) {
1775 currLink = getLink(dest[i]);
1776 }
1777 }
1778
1779 // If we found a lam/alef pair in the buffer
1780 // call handleGeneratedSpaces to remove the spaces that were added
1781
1782 destSize = length;
1783 if (lamalef_found || tashkeel_found) {
1784 destSize = handleGeneratedSpaces(dest, start, length);
1785 }
1786 if (seenfam_found || yehhamza_found){
1787 destSize = expandCompositChar(dest, start, destSize, lamalef_count, SHAPE_MODE);
1788 }
1789 return destSize;
1790 }
1791
1792 /*
1793 * Name : deShapeUnicode
1794 * Function: Converts an Arabic Unicode buffer in FExx Range into unshaped
1795 * arabic Unicode buffer in 06xx Range
1796 */
1797 private int deShapeUnicode(char[] dest,
1798 int start,
1799 int length,
1800 int destSize) throws ArabicShapingException {
1801
1802 int lamalef_count = deshapeNormalize(dest, start, length);
1803
1804 // If there was a lamalef in the buffer call expandLamAlef
1805 if (lamalef_count != 0) {
1806 // need to adjust dest to fit expanded buffer... !!!
1807 destSize = expandCompositChar(dest, start, length, lamalef_count,DESHAPE_MODE);
1808 } else {
1809 destSize = length;
1810 }
1811
1812 return destSize;
1813 }
1814
1815 private int internalShape(char[] source,
1816 int sourceStart,
1817 int sourceLength,
1818 char[] dest,
1819 int destStart,
1820 int destSize) throws ArabicShapingException {
1821
1822 if (sourceLength == 0) {
1823 return 0;
1824 }
1825
1826 if (destSize == 0) {
1827 if (((options & LETTERS_MASK) != LETTERS_NOOP) &&
1828 ((options & LAMALEF_MASK) == LAMALEF_RESIZE)) {
1829
1830 return calculateSize(source, sourceStart, sourceLength);
1831 } else {
1832 return sourceLength; // by definition
1833 }
1834 }
1835
1836 // always use temp buffer
1837 char[] temp = new char[sourceLength * 2]; // all lamalefs requiring expansion
1838 System.arraycopy(source, sourceStart, temp, 0, sourceLength);
1839
1840 if (isLogical) {
1841 invertBuffer(temp, 0, sourceLength);
1842 }
1843
1844 int outputSize = sourceLength;
1845
1846 switch (options & LETTERS_MASK) {
1847 case LETTERS_SHAPE_TASHKEEL_ISOLATED:
1848 outputSize = shapeUnicode(temp, 0, sourceLength, destSize, 1);
1849 break;
1850
1851 case LETTERS_SHAPE:
1852 if( ((options&TASHKEEL_MASK)> 0) &&
1853 ((options&TASHKEEL_MASK) !=TASHKEEL_REPLACE_BY_TATWEEL)) {
1854 /* Call the shaping function with tashkeel flag == 2 for removal of tashkeel */
1855 outputSize = shapeUnicode(temp, 0, sourceLength, destSize, 2);
1856 }else {
1857 //default Call the shaping function with tashkeel flag == 1 */
1858 outputSize = shapeUnicode(temp, 0, sourceLength, destSize, 0);
1859
1860 /*After shaping text check if user wants to remove tashkeel and replace it with tatweel*/
1861 if( (options&TASHKEEL_MASK) == TASHKEEL_REPLACE_BY_TATWEEL){
1862 outputSize = handleTashkeelWithTatweel(temp,sourceLength);
1863 }
1864 }
1865 break;
1866
1867 case LETTERS_UNSHAPE:
1868 outputSize = deShapeUnicode(temp, 0, sourceLength, destSize);
1869 break;
1870
1871 default:
1872 break;
1873 }
1874
1875 if (outputSize > destSize) {
1876 throw new ArabicShapingException("not enough room for result data");
1877 }
1878
1879 if ((options & DIGITS_MASK) != DIGITS_NOOP) {
1880 char digitBase = '\u0030'; // European digits
1881 switch (options & DIGIT_TYPE_MASK) {
1882 case DIGIT_TYPE_AN:
1883 digitBase = '\u0660'; // Arabic-Indic digits
1884 break;
1885
1886 case DIGIT_TYPE_AN_EXTENDED:
1887 digitBase = '\u06f0'; // Eastern Arabic-Indic digits (Persian and Urdu)
1888 break;
1889
1890 default:
1891 break;
1892 }
1893
1894 switch (options & DIGITS_MASK) {
1895 case DIGITS_EN2AN:
1896 {
1897 int digitDelta = digitBase - '\u0030';
1898 for (int i = 0; i < outputSize; ++i) {
1899 char ch = temp[i];
1900 if (ch <= '\u0039' && ch >= '\u0030') {
1901 temp[i] += digitDelta;
1902 }
1903 }
1904 }
1905 break;
1906
1907 case DIGITS_AN2EN:
1908 {
1909 char digitTop = (char)(digitBase + 9);
1910 int digitDelta = '\u0030' - digitBase;
1911 for (int i = 0; i < outputSize; ++i) {
1912 char ch = temp[i];
1913 if (ch <= digitTop && ch >= digitBase) {
1914 temp[i] += digitDelta;
1915 }
1916 }
1917 }
1918 break;
1919
1920 case DIGITS_EN2AN_INIT_LR:
1921 shapeToArabicDigitsWithContext(temp, 0, outputSize, digitBase, false);
1922 break;
1923
1924 case DIGITS_EN2AN_INIT_AL:
1925 shapeToArabicDigitsWithContext(temp, 0, outputSize, digitBase, true);
1926 break;
1927
1928 default:
1929 break;
1930 }
1931 }
1932
1933 if (isLogical) {
1934 invertBuffer(temp, 0, outputSize);
1935 }
1936
1937 System.arraycopy(temp, 0, dest, destStart, outputSize);
1938
1939 return outputSize;
1940 }
1941
1942 private static class ArabicShapingException extends RuntimeException {
1943 ArabicShapingException(String msg) {
1944 super(msg);
1945 }
1946 }
1947}