Lines Matching full:runs
46 * The implementation of the access to same-level-runs and of the reordering
52 * same-level-runs is created. Reordering then is done on this vector.
57 * This is inefficient if there are many very short runs. If the average run
153 pLineBiDi->runs=NULL;
316 /* this is done based on runs rather than on levels since levels have
320 iRun=pBiDi->runs[0];
323 iRun = pBiDi->runs[i];
347 /* runs API functions ------------------------------------------------------- */
373 start=pBiDi->runs[runIndex].logicalStart;
379 *pLength=pBiDi->runs[runIndex].visualLimit-
380 pBiDi->runs[runIndex-1].visualLimit;
382 *pLength=pBiDi->runs[0].visualLimit;
392 pBiDi->runs=pBiDi->simpleRuns;
396 pBiDi->runs[0].logicalStart=MAKE_INDEX_ODD_PAIR(0, level);
397 pBiDi->runs[0].visualLimit=pBiDi->length;
398 pBiDi->runs[0].insertRemove=0;
401 /* reorder the runs array (L2) ---------------------------------------------- */
404 * Reorder the same-level runs in the runs array.
412 * each sequence of same-level runs consists of only one run each, we
418 * in the last reordering the sequence of the runs at this level or higher
419 * will be all runs, and we don't need the elaborate loop to search for them.
431 * this run and can --runCount. If it is later part of the all-runs
436 Run *runs, tempRun;
452 runs=pBiDi->runs;
464 /* loop for all sequences of runs */
466 /* look for a sequence of runs that are all at >=maxLevel */
468 while(firstRun<runCount && levels[runs[firstRun].logicalStart]<maxLevel) {
472 break; /* no more such runs */
476 for(limitRun=firstRun; ++limitRun<runCount && levels[runs[limitRun].logicalStart]>=maxLevel;) {}
478 /* Swap the entire sequence of runs from firstRun to limitRun-1. */
481 tempRun = runs[firstRun];
482 runs[firstRun]=runs[endRun];
483 runs[endRun]=tempRun;
489 break; /* no more such runs */
505 /* Swap the entire sequence of all runs. (endRun==runCount) */
507 tempRun=runs[firstRun];
508 runs[firstRun]=runs[runCount];
509 runs[runCount]=tempRun;
516 /* compute the runs array --------------------------------------------------- */
519 Run *runs=pBiDi->runs;
523 length=runs[i].visualLimit-visualStart;
524 logicalStart=GET_INDEX(runs[i].logicalStart);
537 * Compute the runs array from the levels array.
539 * and the runs are reordered.
540 * Odd-level runs have visualStart on their visual right edge and
550 * This method returns immediately if the runs are already set. This
579 /* count the runs, there is at least one non-WS run, and limit>0 */
597 /* allocate and set the runs */
598 Run *runs;
609 runs=pBiDi->runsMemory;
614 /* set the runs */
639 runs[runIndex].logicalStart=start;
640 runs[runIndex].visualLimit=i-start;
641 runs[runIndex].insertRemove=0;
647 runs[runIndex].logicalStart=limit;
648 runs[runIndex].visualLimit=length-limit;
657 pBiDi->runs=runs;
666 ADD_ODD_BIT_FROM_LEVEL(runs[i].logicalStart, levels[runs[i].logicalStart]);
667 limit=runs[i].visualLimit+=limit;
677 ADD_ODD_BIT_FROM_LEVEL(runs[trailingRun].logicalStart, pBiDi->paraLevel);
689 pBiDi->runs[runIndex].insertRemove|=point->flag;
700 pBiDi->runs[runIndex].insertRemove--;
840 break; /* no more such runs */
880 /* we can do the trivial cases without the runs array */
893 Run *runs=pBiDi->runs;
896 /* linear search for the run, search on the visual runs */
898 length=runs[i].visualLimit-visualStart;
899 offset=logicalIndex-GET_INDEX(runs[i].logicalStart);
901 if(IS_EVEN_RUN(runs[i].logicalStart)) {
920 Run *runs=pBiDi->runs;
924 length=runs[i].visualLimit-visualStart;
925 insertRemove=runs[i].insertRemove;
930 if(visualIndex<runs[i].visualLimit) {
940 Run *runs=pBiDi->runs;
948 /* loop on runs */
950 length=runs[i].visualLimit-visualStart;
951 insertRemove=runs[i].insertRemove;
953 if(visualIndex>=runs[i].visualLimit) {
961 if(IS_EVEN_RUN(runs[i].logicalStart)) {
963 start=runs[i].logicalStart;
968 limit=GET_INDEX(runs[i].logicalStart)+length;
985 Run *runs;
990 /* we can do the trivial cases without the runs array */
1004 runs=pBiDi->runs;
1010 runs=pBiDi->runs;
1013 length=runs[i].visualLimit-visualStart;
1014 insertRemove=runs[i].insertRemove;
1022 if(visualIndex<(runs[i].visualLimit+markFound)) {
1042 length=runs[i].visualLimit-visualStart;
1043 insertRemove=runs[i].insertRemove;
1045 if(visualIndex>=(runs[i].visualLimit-controlFound+insertRemove)) {
1055 logicalStart=runs[i].logicalStart;
1076 for(i=0; visualIndex>=runs[i].visualLimit; ++i) {}
1084 if(visualIndex>=runs[i].visualLimit) {
1086 } else if(i==0 || visualIndex>=runs[i-1].visualLimit) {
1094 start=runs[i].logicalStart;
1097 /* the offset in runs[i] is visualIndex-runs[i-1].visualLimit */
1099 visualIndex-=runs[i-1].visualLimit;
1104 return GET_INDEX(start)+runs[i].visualLimit-visualIndex-1;
1118 /* fill a logical-to-visual index map using the runs[] */
1121 Run *runs=pBiDi->runs;
1131 logicalStart=GET_INDEX(runs[j].logicalStart);
1132 visualLimit=runs[j].visualLimit;
1133 if(IS_EVEN_RUN(runs[j].logicalStart)) {
1152 length=runs[i].visualLimit-visualStart;
1153 insertRemove=runs[i].insertRemove;
1158 logicalStart=GET_INDEX(runs[i].logicalStart);
1177 length=runs[i].visualLimit-visualStart;
1178 insertRemove=runs[i].insertRemove;
1179 /* no control found within previous runs nor within this run */
1183 logicalStart=runs[i].logicalStart;
1219 /* fill a visual-to-logical index map using the runs[] */
1220 Run *runs=pBiDi->runs, *runsLimit=runs+pBiDi->runCount;
1227 for(; runs<runsLimit; ++runs) {
1228 logicalStart=runs->logicalStart;
1229 visualLimit=runs->visualLimit;
1247 runs=pBiDi->runs;
1250 insertRemove=runs[i].insertRemove;
1261 insertRemove=runs[i].insertRemove;
1266 visualStart= i>0 ? runs[i-1].visualLimit : 0;
1267 for(j=runs[i].visualLimit-1; j>=visualStart && markFound>0; j--) {
1281 runs=pBiDi->runs;
1286 length=runs[i].visualLimit-visualStart;
1287 insertRemove=runs[i].insertRemove;
1295 visualLimit=runs[i].visualLimit;
1301 logicalStart=runs[i].logicalStart;
