History

My first initial commit with all of mine experimental changes.

Dmitry Kabak (userdima committed 13 years ago

Commit d37b88d1 parent 3f5b46618352 files · +2598093 −-8690Browse files

Showing the changes to java/pkg/sun/text/bidi/BidiLine.java (1 of 18352 files). Show all

Unified · Split

java/pkg/sun/text/bidi/BidiLine.java+849−0
@@ -0,0 +1,849 @@
1+/*
2+ * Copyright (c) 2009, Oracle and/or its affiliates. All rights reserved.
3+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4+ *
5+ * This code is free software; you can redistribute it and/or modify it
6+ * under the terms of the GNU General Public License version 2 only, as
7+ * published by the Free Software Foundation. Oracle designates this
8+ * particular file as subject to the "Classpath" exception as provided
9+ * by Oracle in the LICENSE file that accompanied this code.
10+ *
11+ * This code is distributed in the hope that it will be useful, but WITHOUT
12+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14+ * version 2 for more details (a copy is included in the LICENSE file that
15+ * accompanied this code).
16+ *
17+ * You should have received a copy of the GNU General Public License version
18+ * 2 along with this work; if not, write to the Free Software Foundation,
19+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20+ *
21+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22+ * or visit www.oracle.com if you need additional information or have any
23+ * questions.
24+ */
25+/*
26+ *******************************************************************************
27+ * (C) Copyright IBM Corp. and others, 1996-2009 - All Rights Reserved *
28+ * *
29+ * The original version of this source code and documentation is copyrighted *
30+ * and owned by IBM, These materials are provided under terms of a License *
31+ * Agreement between IBM and Sun. This technology is protected by multiple *
32+ * US and International patents. This notice and attribution to IBM may not *
33+ * to removed. *
34+ *******************************************************************************
35+ */
36+/* Written by Simon Montagu, Matitiahu Allouche
37+ * (ported from C code written by Markus W. Scherer)
38+ */
39+
40+package sun.text.bidi;
41+
42+import java.text.Bidi;
43+import java.util.Arrays;
44+
45+public final class BidiLine {
46+
47+ /*
48+ * General remarks about the functions in this file:
49+ *
50+ * These functions deal with the aspects of potentially mixed-directional
51+ * text in a single paragraph or in a line of a single paragraph
52+ * which has already been processed according to
53+ * the Unicode 3.0 Bidi algorithm as defined in
54+ * http://www.unicode.org/unicode/reports/tr9/ , version 13,
55+ * also described in The Unicode Standard, Version 4.0.1 .
56+ *
57+ * This means that there is a Bidi object with a levels
58+ * and a dirProps array.
59+ * paraLevel and direction are also set.
60+ * Only if the length of the text is zero, then levels==dirProps==NULL.
61+ *
62+ * The overall directionality of the paragraph
63+ * or line is used to bypass the reordering steps if possible.
64+ * Even purely RTL text does not need reordering there because
65+ * the getLogical/VisualIndex() methods can compute the
66+ * index on the fly in such a case.
67+ *
68+ * The implementation of the access to same-level-runs and of the reordering
69+ * do attempt to provide better performance and less memory usage compared to
70+ * a direct implementation of especially rule (L2) with an array of
71+ * one (32-bit) integer per text character.
72+ *
73+ * Here, the levels array is scanned as soon as necessary, and a vector of
74+ * same-level-runs is created. Reordering then is done on this vector.
75+ * For each run of text positions that were resolved to the same level,
76+ * only 8 bytes are stored: the first text position of the run and the visual
77+ * position behind the run after reordering.
78+ * One sign bit is used to hold the directionality of the run.
79+ * This is inefficient if there are many very short runs. If the average run
80+ * length is <2, then this uses more memory.
81+ *
82+ * In a further attempt to save memory, the levels array is never changed
83+ * after all the resolution rules (Xn, Wn, Nn, In).
84+ * Many methods have to consider the field trailingWSStart:
85+ * if it is less than length, then there is an implicit trailing run
86+ * at the paraLevel,
87+ * which is not reflected in the levels array.
88+ * This allows a line Bidi object to use the same levels array as
89+ * its paragraph parent object.
90+ *
91+ * When a Bidi object is created for a line of a paragraph, then the
92+ * paragraph's levels and dirProps arrays are reused by way of setting
93+ * a pointer into them, not by copying. This again saves memory and forbids to
94+ * change the now shared levels for (L1).
95+ */
96+
97+ /* handle trailing WS (L1) -------------------------------------------------- */
98+
99+ /*
100+ * setTrailingWSStart() sets the start index for a trailing
101+ * run of WS in the line. This is necessary because we do not modify
102+ * the paragraph's levels array that we just point into.
103+ * Using trailingWSStart is another form of performing (L1).
104+ *
105+ * To make subsequent operations easier, we also include the run
106+ * before the WS if it is at the paraLevel - we merge the two here.
107+ *
108+ * This method is called only from setLine(), so paraLevel is
109+ * set correctly for the line even when contextual multiple paragraphs.
110+ */
111+
112+ static void setTrailingWSStart(BidiBase bidiBase)
113+ {
114+ byte[] dirProps = bidiBase.dirProps;
115+ byte[] levels = bidiBase.levels;
116+ int start = bidiBase.length;
117+ byte paraLevel = bidiBase.paraLevel;
118+
119+ /* If the line is terminated by a block separator, all preceding WS etc...
120+ are already set to paragraph level.
121+ Setting trailingWSStart to pBidi->length will avoid changing the
122+ level of B chars from 0 to paraLevel in getLevels when
123+ orderParagraphsLTR==TRUE
124+ */
125+ if (BidiBase.NoContextRTL(dirProps[start - 1]) == BidiBase.B) {
126+ bidiBase.trailingWSStart = start; /* currently == bidiBase.length */
127+ return;
128+ }
129+ /* go backwards across all WS, BN, explicit codes */
130+ while (start > 0 &&
131+ (BidiBase.DirPropFlagNC(dirProps[start - 1]) & BidiBase.MASK_WS) != 0) {
132+ --start;
133+ }
134+
135+ /* if the WS run can be merged with the previous run then do so here */
136+ while (start > 0 && levels[start - 1] == paraLevel) {
137+ --start;
138+ }
139+
140+ bidiBase.trailingWSStart=start;
141+ }
142+
143+ public static Bidi setLine(Bidi bidi, BidiBase paraBidi,
144+ Bidi newBidi, BidiBase newBidiBase,
145+ int start, int limit) {
146+ int length;
147+
148+ BidiBase lineBidi = newBidiBase;
149+
150+ /* set the values in lineBidi from its paraBidi parent */
151+ /* class members are already initialized to 0 */
152+ // lineBidi.paraBidi = null; /* mark unfinished setLine */
153+ // lineBidi.flags = 0;
154+ // lineBidi.controlCount = 0;
155+
156+ length = lineBidi.length = lineBidi.originalLength =
157+ lineBidi.resultLength = limit - start;
158+
159+ lineBidi.text = new char[length];
160+ System.arraycopy(paraBidi.text, start, lineBidi.text, 0, length);
161+ lineBidi.paraLevel = paraBidi.GetParaLevelAt(start);
162+ lineBidi.paraCount = paraBidi.paraCount;
163+ lineBidi.runs = new BidiRun[0];
164+ if (paraBidi.controlCount > 0) {
165+ int j;
166+ for (j = start; j < limit; j++) {
167+ if (BidiBase.IsBidiControlChar(paraBidi.text[j])) {
168+ lineBidi.controlCount++;
169+ }
170+ }
171+ lineBidi.resultLength -= lineBidi.controlCount;
172+ }
173+ /* copy proper subset of DirProps */
174+ lineBidi.getDirPropsMemory(length);
175+ lineBidi.dirProps = lineBidi.dirPropsMemory;
176+ System.arraycopy(paraBidi.dirProps, start, lineBidi.dirProps, 0,
177+ length);
178+ /* copy proper subset of Levels */
179+ lineBidi.getLevelsMemory(length);
180+ lineBidi.levels = lineBidi.levelsMemory;
181+ System.arraycopy(paraBidi.levels, start, lineBidi.levels, 0,
182+ length);
183+ lineBidi.runCount = -1;
184+
185+ if (paraBidi.direction != BidiBase.MIXED) {
186+ /* the parent is already trivial */
187+ lineBidi.direction = paraBidi.direction;
188+
189+ /*
190+ * The parent's levels are all either
191+ * implicitly or explicitly ==paraLevel;
192+ * do the same here.
193+ */
194+ if (paraBidi.trailingWSStart <= start) {
195+ lineBidi.trailingWSStart = 0;
196+ } else if (paraBidi.trailingWSStart < limit) {
197+ lineBidi.trailingWSStart = paraBidi.trailingWSStart - start;
198+ } else {
199+ lineBidi.trailingWSStart = length;
200+ }
201+ } else {
202+ byte[] levels = lineBidi.levels;
203+ int i, trailingWSStart;
204+ byte level;
205+
206+ setTrailingWSStart(lineBidi);
207+ trailingWSStart = lineBidi.trailingWSStart;
208+
209+ /* recalculate lineBidi.direction */
210+ if (trailingWSStart == 0) {
211+ /* all levels are at paraLevel */
212+ lineBidi.direction = (byte)(lineBidi.paraLevel & 1);
213+ } else {
214+ /* get the level of the first character */
215+ level = (byte)(levels[0] & 1);
216+
217+ /* if there is anything of a different level, then the line
218+ is mixed */
219+ if (trailingWSStart < length &&
220+ (lineBidi.paraLevel & 1) != level) {
221+ /* the trailing WS is at paraLevel, which differs from
222+ levels[0] */
223+ lineBidi.direction = BidiBase.MIXED;
224+ } else {
225+ /* see if levels[1..trailingWSStart-1] have the same
226+ direction as levels[0] and paraLevel */
227+ for (i = 1; ; i++) {
228+ if (i == trailingWSStart) {
229+ /* the direction values match those in level */
230+ lineBidi.direction = level;
231+ break;
232+ } else if ((levels[i] & 1) != level) {
233+ lineBidi.direction = BidiBase.MIXED;
234+ break;
235+ }
236+ }
237+ }
238+ }
239+
240+ switch(lineBidi.direction) {
241+ case Bidi.DIRECTION_LEFT_TO_RIGHT:
242+ /* make sure paraLevel is even */
243+ lineBidi.paraLevel = (byte)
244+ ((lineBidi.paraLevel + 1) & ~1);
245+
246+ /* all levels are implicitly at paraLevel (important for
247+ getLevels()) */
248+ lineBidi.trailingWSStart = 0;
249+ break;
250+ case Bidi.DIRECTION_RIGHT_TO_LEFT:
251+ /* make sure paraLevel is odd */
252+ lineBidi.paraLevel |= 1;
253+
254+ /* all levels are implicitly at paraLevel (important for
255+ getLevels()) */
256+ lineBidi.trailingWSStart = 0;
257+ break;
258+ default:
259+ break;
260+ }
261+ }
262+
263+ newBidiBase.paraBidi = paraBidi; /* mark successful setLine */
264+ return newBidi;
265+ }
266+
267+ static byte getLevelAt(BidiBase bidiBase, int charIndex)
268+ {
269+ /* return paraLevel if in the trailing WS run, otherwise the real level */
270+ if (bidiBase.direction != BidiBase.MIXED || charIndex >= bidiBase.trailingWSStart) {
271+ return bidiBase.GetParaLevelAt(charIndex);
272+ } else {
273+ return bidiBase.levels[charIndex];
274+ }
275+ }
276+
277+ static byte[] getLevels(BidiBase bidiBase)
278+ {
279+ int start = bidiBase.trailingWSStart;
280+ int length = bidiBase.length;
281+
282+ if (start != length) {
283+ /* the current levels array does not reflect the WS run */
284+ /*
285+ * After the previous if(), we know that the levels array
286+ * has an implicit trailing WS run and therefore does not fully
287+ * reflect itself all the levels.
288+ * This must be a Bidi object for a line, and
289+ * we need to create a new levels array.
290+ */
291+ /* bidiBase.paraLevel is ok even if contextual multiple paragraphs,
292+ since bidiBase is a line object */
293+ Arrays.fill(bidiBase.levels, start, length, bidiBase.paraLevel);
294+
295+ /* this new levels array is set for the line and reflects the WS run */
296+ bidiBase.trailingWSStart = length;
297+ }
298+ if (length < bidiBase.levels.length) {
299+ byte[] levels = new byte[length];
300+ System.arraycopy(bidiBase.levels, 0, levels, 0, length);
301+ return levels;
302+ }
303+ return bidiBase.levels;
304+ }
305+
306+ static BidiRun getLogicalRun(BidiBase bidiBase, int logicalPosition)
307+ {
308+ /* this is done based on runs rather than on levels since levels have
309+ a special interpretation when REORDER_RUNS_ONLY
310+ */
311+ BidiRun newRun = new BidiRun(), iRun;
312+ getRuns(bidiBase);
313+ int runCount = bidiBase.runCount;
314+ int visualStart = 0, logicalLimit = 0;
315+ iRun = bidiBase.runs[0];
316+
317+ for (int i = 0; i < runCount; i++) {
318+ iRun = bidiBase.runs[i];
319+ logicalLimit = iRun.start + iRun.limit - visualStart;
320+ if ((logicalPosition >= iRun.start) &&
321+ (logicalPosition < logicalLimit)) {
322+ break;
323+ }
324+ visualStart = iRun.limit;
325+ }
326+ newRun.start = iRun.start;
327+ newRun.limit = logicalLimit;
328+ newRun.level = iRun.level;
329+ return newRun;
330+ }
331+
332+ /* in trivial cases there is only one trivial run; called by getRuns() */
333+ private static void getSingleRun(BidiBase bidiBase, byte level) {
334+ /* simple, single-run case */
335+ bidiBase.runs = bidiBase.simpleRuns;
336+ bidiBase.runCount = 1;
337+
338+ /* fill and reorder the single run */
339+ bidiBase.runs[0] = new BidiRun(0, bidiBase.length, level);
340+ }
341+
342+ /* reorder the runs array (L2) ---------------------------------------------- */
343+
344+ /*
345+ * Reorder the same-level runs in the runs array.
346+ * Here, runCount>1 and maxLevel>=minLevel>=paraLevel.
347+ * All the visualStart fields=logical start before reordering.
348+ * The "odd" bits are not set yet.
349+ *
350+ * Reordering with this data structure lends itself to some handy shortcuts:
351+ *
352+ * Since each run is moved but not modified, and since at the initial maxLevel
353+ * each sequence of same-level runs consists of only one run each, we
354+ * don't need to do anything there and can predecrement maxLevel.
355+ * In many simple cases, the reordering is thus done entirely in the
356+ * index mapping.
357+ * Also, reordering occurs only down to the lowest odd level that occurs,
358+ * which is minLevel|1. However, if the lowest level itself is odd, then
359+ * in the last reordering the sequence of the runs at this level or higher
360+ * will be all runs, and we don't need the elaborate loop to search for them.
361+ * This is covered by ++minLevel instead of minLevel|=1 followed
362+ * by an extra reorder-all after the reorder-some loop.
363+ * About a trailing WS run:
364+ * Such a run would need special treatment because its level is not
365+ * reflected in levels[] if this is not a paragraph object.
366+ * Instead, all characters from trailingWSStart on are implicitly at
367+ * paraLevel.
368+ * However, for all maxLevel>paraLevel, this run will never be reordered
369+ * and does not need to be taken into account. maxLevel==paraLevel is only reordered
370+ * if minLevel==paraLevel is odd, which is done in the extra segment.
371+ * This means that for the main reordering loop we don't need to consider
372+ * this run and can --runCount. If it is later part of the all-runs
373+ * reordering, then runCount is adjusted accordingly.
374+ */
375+ private static void reorderLine(BidiBase bidiBase, byte minLevel, byte maxLevel) {
376+
377+ /* nothing to do? */
378+ if (maxLevel<=(minLevel|1)) {
379+ return;
380+ }
381+
382+ BidiRun[] runs;
383+ BidiRun tempRun;
384+ byte[] levels;
385+ int firstRun, endRun, limitRun, runCount;
386+
387+ /*
388+ * Reorder only down to the lowest odd level
389+ * and reorder at an odd minLevel in a separate, simpler loop.
390+ * See comments above for why minLevel is always incremented.
391+ */
392+ ++minLevel;
393+
394+ runs = bidiBase.runs;
395+ levels = bidiBase.levels;
396+ runCount = bidiBase.runCount;
397+
398+ /* do not include the WS run at paraLevel<=old minLevel except in the simple loop */
399+ if (bidiBase.trailingWSStart < bidiBase.length) {
400+ --runCount;
401+ }
402+
403+ while (--maxLevel >= minLevel) {
404+ firstRun = 0;
405+
406+ /* loop for all sequences of runs */
407+ for ( ; ; ) {
408+ /* look for a sequence of runs that are all at >=maxLevel */
409+ /* look for the first run of such a sequence */
410+ while (firstRun < runCount && levels[runs[firstRun].start] < maxLevel) {
411+ ++firstRun;
412+ }
413+ if (firstRun >= runCount) {
414+ break; /* no more such runs */
415+ }
416+
417+ /* look for the limit run of such a sequence (the run behind it) */
418+ for (limitRun = firstRun; ++limitRun < runCount &&
419+ levels[runs[limitRun].start]>=maxLevel; ) {}
420+
421+ /* Swap the entire sequence of runs from firstRun to limitRun-1. */
422+ endRun = limitRun - 1;
423+ while (firstRun < endRun) {
424+ tempRun = runs[firstRun];
425+ runs[firstRun] = runs[endRun];
426+ runs[endRun] = tempRun;
427+ ++firstRun;
428+ --endRun;
429+ }
430+
431+ if (limitRun == runCount) {
432+ break; /* no more such runs */
433+ } else {
434+ firstRun = limitRun + 1;
435+ }
436+ }
437+ }
438+
439+ /* now do maxLevel==old minLevel (==odd!), see above */
440+ if ((minLevel & 1) == 0) {
441+ firstRun = 0;
442+
443+ /* include the trailing WS run in this complete reordering */
444+ if (bidiBase.trailingWSStart == bidiBase.length) {
445+ --runCount;
446+ }
447+
448+ /* Swap the entire sequence of all runs. (endRun==runCount) */
449+ while (firstRun < runCount) {
450+ tempRun = runs[firstRun];
451+ runs[firstRun] = runs[runCount];
452+ runs[runCount] = tempRun;
453+ ++firstRun;
454+ --runCount;
455+ }
456+ }
457+ }
458+
459+ /* compute the runs array --------------------------------------------------- */
460+
461+ static int getRunFromLogicalIndex(BidiBase bidiBase, int logicalIndex) {
462+ BidiRun[] runs = bidiBase.runs;
463+ int runCount = bidiBase.runCount, visualStart = 0, i, length, logicalStart;
464+
465+ for (i = 0; i < runCount; i++) {
466+ length = runs[i].limit - visualStart;
467+ logicalStart = runs[i].start;
468+ if ((logicalIndex >= logicalStart) && (logicalIndex < (logicalStart+length))) {
469+ return i;
470+ }
471+ visualStart += length;
472+ }
473+ /* we should never get here */
474+ throw new IllegalStateException("Internal ICU error in getRunFromLogicalIndex");
475+ }
476+
477+ /*
478+ * Compute the runs array from the levels array.
479+ * After getRuns() returns true, runCount is guaranteed to be >0
480+ * and the runs are reordered.
481+ * Odd-level runs have visualStart on their visual right edge and
482+ * they progress visually to the left.
483+ * If option OPTION_INSERT_MARKS is set, insertRemove will contain the
484+ * sum of appropriate LRM/RLM_BEFORE/AFTER flags.
485+ * If option OPTION_REMOVE_CONTROLS is set, insertRemove will contain the
486+ * negative number of BiDi control characters within this run.
487+ */
488+ static void getRuns(BidiBase bidiBase) {
489+ /*
490+ * This method returns immediately if the runs are already set. This
491+ * includes the case of length==0 (handled in setPara)..
492+ */
493+ if (bidiBase.runCount >= 0) {
494+ return;
495+ }
496+ if (bidiBase.direction != BidiBase.MIXED) {
497+ /* simple, single-run case - this covers length==0 */
498+ /* bidiBase.paraLevel is ok even for contextual multiple paragraphs */
499+ getSingleRun(bidiBase, bidiBase.paraLevel);
500+ } else /* BidiBase.MIXED, length>0 */ {
501+ /* mixed directionality */
502+ int length = bidiBase.length, limit;
503+ byte[] levels = bidiBase.levels;
504+ int i, runCount;
505+ byte level = BidiBase.INTERNAL_LEVEL_DEFAULT_LTR; /* initialize with no valid level */
506+ /*
507+ * If there are WS characters at the end of the line
508+ * and the run preceding them has a level different from
509+ * paraLevel, then they will form their own run at paraLevel (L1).
510+ * Count them separately.
511+ * We need some special treatment for this in order to not
512+ * modify the levels array which a line Bidi object shares
513+ * with its paragraph parent and its other line siblings.
514+ * In other words, for the trailing WS, it may be
515+ * levels[]!=paraLevel but we have to treat it like it were so.
516+ */
517+ limit = bidiBase.trailingWSStart;
518+ /* count the runs, there is at least one non-WS run, and limit>0 */
519+ runCount = 0;
520+ for (i = 0; i < limit; ++i) {
521+ /* increment runCount at the start of each run */
522+ if (levels[i] != level) {
523+ ++runCount;
524+ level = levels[i];
525+ }
526+ }
527+
528+ /*
529+ * We don't need to see if the last run can be merged with a trailing
530+ * WS run because setTrailingWSStart() would have done that.
531+ */
532+ if (runCount == 1 && limit == length) {
533+ /* There is only one non-WS run and no trailing WS-run. */
534+ getSingleRun(bidiBase, levels[0]);
535+ } else /* runCount>1 || limit<length */ {
536+ /* allocate and set the runs */
537+ BidiRun[] runs;
538+ int runIndex, start;
539+ byte minLevel = BidiBase.MAX_EXPLICIT_LEVEL + 1;
540+ byte maxLevel=0;
541+
542+ /* now, count a (non-mergeable) WS run */
543+ if (limit < length) {
544+ ++runCount;
545+ }
546+
547+ /* runCount > 1 */
548+ bidiBase.getRunsMemory(runCount);
549+ runs = bidiBase.runsMemory;
550+
551+ /* set the runs */
552+ /* FOOD FOR THOUGHT: this could be optimized, e.g.:
553+ * 464->444, 484->444, 575->555, 595->555
554+ * However, that would take longer. Check also how it would
555+ * interact with BiDi control removal and inserting Marks.
556+ */
557+ runIndex = 0;
558+
559+ /* search for the run limits and initialize visualLimit values with the run lengths */
560+ i = 0;
561+ do {
562+ /* prepare this run */
563+ start = i;
564+ level = levels[i];
565+ if (level < minLevel) {
566+ minLevel = level;
567+ }
568+ if (level > maxLevel) {
569+ maxLevel = level;
570+ }
571+
572+ /* look for the run limit */
573+ while (++i < limit && levels[i] == level) {}
574+
575+ /* i is another run limit */
576+ runs[runIndex] = new BidiRun(start, i - start, level);
577+ ++runIndex;
578+ } while (i < limit);
579+
580+ if (limit < length) {
581+ /* there is a separate WS run */
582+ runs[runIndex] = new BidiRun(limit, length - limit, bidiBase.paraLevel);
583+ /* For the trailing WS run, bidiBase.paraLevel is ok even
584+ if contextual multiple paragraphs. */
585+ if (bidiBase.paraLevel < minLevel) {
586+ minLevel = bidiBase.paraLevel;
587+ }
588+ }
589+
590+ /* set the object fields */
591+ bidiBase.runs = runs;
592+ bidiBase.runCount = runCount;
593+
594+ reorderLine(bidiBase, minLevel, maxLevel);
595+
596+ /* now add the direction flags and adjust the visualLimit's to be just that */
597+ /* this loop will also handle the trailing WS run */
598+ limit = 0;
599+ for (i = 0; i < runCount; ++i) {
600+ runs[i].level = levels[runs[i].start];
601+ limit = (runs[i].limit += limit);
602+ }
603+
604+ /* Set the embedding level for the trailing WS run. */
605+ /* For a RTL paragraph, it will be the *first* run in visual order. */
606+ /* For the trailing WS run, bidiBase.paraLevel is ok even if
607+ contextual multiple paragraphs. */
608+ if (runIndex < runCount) {
609+ int trailingRun = ((bidiBase.paraLevel & 1) != 0)? 0 : runIndex;
610+ runs[trailingRun].level = bidiBase.paraLevel;
611+ }
612+ }
613+ }
614+
615+ /* handle insert LRM/RLM BEFORE/AFTER run */
616+ if (bidiBase.insertPoints.size > 0) {
617+ BidiBase.Point point;
618+ int runIndex, ip;
619+ for (ip = 0; ip < bidiBase.insertPoints.size; ip++) {
620+ point = bidiBase.insertPoints.points[ip];
621+ runIndex = getRunFromLogicalIndex(bidiBase, point.pos);
622+ bidiBase.runs[runIndex].insertRemove |= point.flag;
623+ }
624+ }
625+
626+ /* handle remove BiDi control characters */
627+ if (bidiBase.controlCount > 0) {
628+ int runIndex, ic;
629+ char c;
630+ for (ic = 0; ic < bidiBase.length; ic++) {
631+ c = bidiBase.text[ic];
632+ if (BidiBase.IsBidiControlChar(c)) {
633+ runIndex = getRunFromLogicalIndex(bidiBase, ic);
634+ bidiBase.runs[runIndex].insertRemove--;
635+ }
636+ }
637+ }
638+ }
639+
640+ static int[] prepareReorder(byte[] levels, byte[] pMinLevel, byte[] pMaxLevel)
641+ {
642+ int start;
643+ byte level, minLevel, maxLevel;
644+
645+ if (levels == null || levels.length <= 0) {
646+ return null;
647+ }
648+
649+ /* determine minLevel and maxLevel */
650+ minLevel = BidiBase.MAX_EXPLICIT_LEVEL + 1;
651+ maxLevel = 0;
652+ for (start = levels.length; start>0; ) {
653+ level = levels[--start];
654+ if (level > BidiBase.MAX_EXPLICIT_LEVEL + 1) {
655+ return null;
656+ }
657+ if (level < minLevel) {
658+ minLevel = level;
659+ }
660+ if (level > maxLevel) {
661+ maxLevel = level;
662+ }
663+ }
664+ pMinLevel[0] = minLevel;
665+ pMaxLevel[0] = maxLevel;
666+
667+ /* initialize the index map */
668+ int[] indexMap = new int[levels.length];
669+ for (start = levels.length; start > 0; ) {
670+ --start;
671+ indexMap[start] = start;
672+ }
673+
674+ return indexMap;
675+ }
676+
677+ static int[] reorderVisual(byte[] levels)
678+ {
679+ byte[] aMinLevel = new byte[1];
680+ byte[] aMaxLevel = new byte[1];
681+ int start, end, limit, temp;
682+ byte minLevel, maxLevel;
683+
684+ int[] indexMap = prepareReorder(levels, aMinLevel, aMaxLevel);
685+ if (indexMap == null) {
686+ return null;
687+ }
688+
689+ minLevel = aMinLevel[0];
690+ maxLevel = aMaxLevel[0];
691+
692+ /* nothing to do? */
693+ if (minLevel == maxLevel && (minLevel & 1) == 0) {
694+ return indexMap;
695+ }
696+
697+ /* reorder only down to the lowest odd level */
698+ minLevel |= 1;
699+
700+ /* loop maxLevel..minLevel */
701+ do {
702+ start = 0;
703+
704+ /* loop for all sequences of levels to reorder at the current maxLevel */
705+ for ( ; ; ) {
706+ /* look for a sequence of levels that are all at >=maxLevel */
707+ /* look for the first index of such a sequence */
708+ while (start < levels.length && levels[start] < maxLevel) {
709+ ++start;
710+ }
711+ if (start >= levels.length) {
712+ break; /* no more such runs */
713+ }
714+
715+ /* look for the limit of such a sequence (the index behind it) */
716+ for (limit = start; ++limit < levels.length && levels[limit] >= maxLevel; ) {}
717+
718+ /*
719+ * Swap the entire interval of indexes from start to limit-1.
720+ * We don't need to swap the levels for the purpose of this
721+ * algorithm: the sequence of levels that we look at does not
722+ * move anyway.
723+ */
724+ end = limit - 1;
725+ while (start < end) {
726+ temp = indexMap[start];
727+ indexMap[start] = indexMap[end];
728+ indexMap[end] = temp;
729+
730+ ++start;
731+ --end;
732+ }
733+
734+ if (limit == levels.length) {
735+ break; /* no more such sequences */
736+ } else {
737+ start = limit + 1;
738+ }
739+ }
740+ } while (--maxLevel >= minLevel);
741+
742+ return indexMap;
743+ }
744+
745+ static int[] getVisualMap(BidiBase bidiBase)
746+ {
747+ /* fill a visual-to-logical index map using the runs[] */
748+ BidiRun[] runs = bidiBase.runs;
749+ int logicalStart, visualStart, visualLimit;
750+ int allocLength = bidiBase.length > bidiBase.resultLength ? bidiBase.length
751+ : bidiBase.resultLength;
752+ int[] indexMap = new int[allocLength];
753+
754+ visualStart = 0;
755+ int idx = 0;
756+ for (int j = 0; j < bidiBase.runCount; ++j) {
757+ logicalStart = runs[j].start;
758+ visualLimit = runs[j].limit;
759+ if (runs[j].isEvenRun()) {
760+ do { /* LTR */
761+ indexMap[idx++] = logicalStart++;
762+ } while (++visualStart < visualLimit);
763+ } else {
764+ logicalStart += visualLimit - visualStart; /* logicalLimit */
765+ do { /* RTL */
766+ indexMap[idx++] = --logicalStart;
767+ } while (++visualStart < visualLimit);
768+ }
769+ /* visualStart==visualLimit; */
770+ }
771+
772+ if (bidiBase.insertPoints.size > 0) {
773+ int markFound = 0, runCount = bidiBase.runCount;
774+ int insertRemove, i, j, k;
775+ runs = bidiBase.runs;
776+ /* count all inserted marks */
777+ for (i = 0; i < runCount; i++) {
778+ insertRemove = runs[i].insertRemove;
779+ if ((insertRemove & (BidiBase.LRM_BEFORE|BidiBase.RLM_BEFORE)) > 0) {
780+ markFound++;
781+ }
782+ if ((insertRemove & (BidiBase.LRM_AFTER|BidiBase.RLM_AFTER)) > 0) {
783+ markFound++;
784+ }
785+ }
786+ /* move back indexes by number of preceding marks */
787+ k = bidiBase.resultLength;
788+ for (i = runCount - 1; i >= 0 && markFound > 0; i--) {
789+ insertRemove = runs[i].insertRemove;
790+ if ((insertRemove & (BidiBase.LRM_AFTER|BidiBase.RLM_AFTER)) > 0) {
791+ indexMap[--k] = BidiBase.MAP_NOWHERE;
792+ markFound--;
793+ }
794+ visualStart = i > 0 ? runs[i-1].limit : 0;
795+ for (j = runs[i].limit - 1; j >= visualStart && markFound > 0; j--) {
796+ indexMap[--k] = indexMap[j];
797+ }
798+ if ((insertRemove & (BidiBase.LRM_BEFORE|BidiBase.RLM_BEFORE)) > 0) {
799+ indexMap[--k] = BidiBase.MAP_NOWHERE;
800+ markFound--;
801+ }
802+ }
803+ }
804+ else if (bidiBase.controlCount > 0) {
805+ int runCount = bidiBase.runCount, logicalEnd;
806+ int insertRemove, length, i, j, k, m;
807+ char uchar;
808+ boolean evenRun;
809+ runs = bidiBase.runs;
810+ visualStart = 0;
811+ /* move forward indexes by number of preceding controls */
812+ k = 0;
813+ for (i = 0; i < runCount; i++, visualStart += length) {
814+ length = runs[i].limit - visualStart;
815+ insertRemove = runs[i].insertRemove;
816+ /* if no control found yet, nothing to do in this run */
817+ if ((insertRemove == 0) && (k == visualStart)) {
818+ k += length;
819+ continue;
820+ }
821+ /* if no control in this run */
822+ if (insertRemove == 0) {
823+ visualLimit = runs[i].limit;
824+ for (j = visualStart; j < visualLimit; j++) {
825+ indexMap[k++] = indexMap[j];
826+ }
827+ continue;
828+ }
829+ logicalStart = runs[i].start;
830+ evenRun = runs[i].isEvenRun();
831+ logicalEnd = logicalStart + length - 1;
832+ for (j = 0; j < length; j++) {
833+ m = evenRun ? logicalStart + j : logicalEnd - j;
834+ uchar = bidiBase.text[m];
835+ if (!BidiBase.IsBidiControlChar(uchar)) {
836+ indexMap[k++] = m;
837+ }
838+ }
839+ }
840+ }
841+ if (allocLength == bidiBase.resultLength) {
842+ return indexMap;
843+ }
844+ int[] newMap = new int[bidiBase.resultLength];
845+ System.arraycopy(indexMap, 0, newMap, 0, bidiBase.resultLength);
846+ return newMap;
847+ }
848+
849+}

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t