Lines Matching refs:runs
50 * The implementation of the access to same-level-runs and of the reordering
56 * same-level-runs is created. Reordering then is done on this vector.
61 * This is inefficient if there are many very short runs. If the average run
157 pLineBiDi->runs=NULL;
320 /* this is done based on runs rather than on levels since levels have
324 iRun=pBiDi->runs[0];
327 iRun = pBiDi->runs[i];
351 /* runs API functions ------------------------------------------------------- */
377 start=pBiDi->runs[runIndex].logicalStart;
383 *pLength=pBiDi->runs[runIndex].visualLimit-
384 pBiDi->runs[runIndex-1].visualLimit;
386 *pLength=pBiDi->runs[0].visualLimit;
396 pBiDi->runs=pBiDi->simpleRuns;
400 pBiDi->runs[0].logicalStart=MAKE_INDEX_ODD_PAIR(0, level);
401 pBiDi->runs[0].visualLimit=pBiDi->length;
402 pBiDi->runs[0].insertRemove=0;
405 /* reorder the runs array (L2) ---------------------------------------------- */
408 * Reorder the same-level runs in the runs array.
416 * each sequence of same-level runs consists of only one run each, we
422 * in the last reordering the sequence of the runs at this level or higher
423 * will be all runs, and we don't need the elaborate loop to search for them.
435 * this run and can --runCount. If it is later part of the all-runs
440 Run *runs, tempRun;
456 runs=pBiDi->runs;
468 /* loop for all sequences of runs */
470 /* look for a sequence of runs that are all at >=maxLevel */
472 while(firstRun<runCount && levels[runs[firstRun].logicalStart]<maxLevel) {
476 break; /* no more such runs */
480 for(limitRun=firstRun; ++limitRun<runCount && levels[runs[limitRun].logicalStart]>=maxLevel;) {}
482 /* Swap the entire sequence of runs from firstRun to limitRun-1. */
485 tempRun = runs[firstRun];
486 runs[firstRun]=runs[endRun];
487 runs[endRun]=tempRun;
493 break; /* no more such runs */
509 /* Swap the entire sequence of all runs. (endRun==runCount) */
511 tempRun=runs[firstRun];
512 runs[firstRun]=runs[runCount];
513 runs[runCount]=tempRun;
520 /* compute the runs array --------------------------------------------------- */
523 Run *runs=pBiDi->runs;
527 length=runs[i].visualLimit-visualStart;
528 logicalStart=GET_INDEX(runs[i].logicalStart);
541 * Compute the runs array from the levels array.
543 * and the runs are reordered.
544 * Odd-level runs have visualStart on their visual right edge and
554 * This method returns immediately if the runs are already set. This
583 /* count the runs, there is at least one non-WS run, and limit>0 */
601 /* allocate and set the runs */
602 Run *runs;
613 runs=pBiDi->runsMemory;
618 /* set the runs */
643 runs[runIndex].logicalStart=start;
644 runs[runIndex].visualLimit=i-start;
645 runs[runIndex].insertRemove=0;
651 runs[runIndex].logicalStart=limit;
652 runs[runIndex].visualLimit=length-limit;
661 pBiDi->runs=runs;
670 ADD_ODD_BIT_FROM_LEVEL(runs[i].logicalStart, levels[runs[i].logicalStart]);
671 limit+=runs[i].visualLimit;
672 runs[i].visualLimit=limit;
682 ADD_ODD_BIT_FROM_LEVEL(runs[trailingRun].logicalStart, pBiDi->paraLevel);
694 pBiDi->runs[runIndex].insertRemove|=point->flag;
705 pBiDi->runs[runIndex].insertRemove--;
845 break; /* no more such runs */
885 /* we can do the trivial cases without the runs array */
898 Run *runs=pBiDi->runs;
901 /* linear search for the run, search on the visual runs */
903 length=runs[i].visualLimit-visualStart;
904 offset=logicalIndex-GET_INDEX(runs[i].logicalStart);
906 if(IS_EVEN_RUN(runs[i].logicalStart)) {
925 Run *runs=pBiDi->runs;
929 length=runs[i].visualLimit-visualStart;
930 insertRemove=runs[i].insertRemove;
935 if(visualIndex<runs[i].visualLimit) {
945 Run *runs=pBiDi->runs;
953 /* loop on runs */
955 length=runs[i].visualLimit-visualStart;
956 insertRemove=runs[i].insertRemove;
958 if(visualIndex>=runs[i].visualLimit) {
966 if(IS_EVEN_RUN(runs[i].logicalStart)) {
968 start=runs[i].logicalStart;
973 limit=GET_INDEX(runs[i].logicalStart)+length;
990 Run *runs;
995 /* we can do the trivial cases without the runs array */
1009 runs=pBiDi->runs;
1015 runs=pBiDi->runs;
1018 length=runs[i].visualLimit-visualStart;
1019 insertRemove=runs[i].insertRemove;
1027 if(visualIndex<(runs[i].visualLimit+markFound)) {
1047 length=runs[i].visualLimit-visualStart;
1048 insertRemove=runs[i].insertRemove;
1050 if(visualIndex>=(runs[i].visualLimit-controlFound+insertRemove)) {
1060 logicalStart=runs[i].logicalStart;
1081 for(i=0; visualIndex>=runs[i].visualLimit; ++i) {}
1089 if(visualIndex>=runs[i].visualLimit) {
1091 } else if(i==0 || visualIndex>=runs[i-1].visualLimit) {
1099 start=runs[i].logicalStart;
1102 /* the offset in runs[i] is visualIndex-runs[i-1].visualLimit */
1104 visualIndex-=runs[i-1].visualLimit;
1109 return GET_INDEX(start)+runs[i].visualLimit-visualIndex-1;
1123 /* fill a logical-to-visual index map using the runs[] */
1126 Run *runs=pBiDi->runs;
1136 logicalStart=GET_INDEX(runs[j].logicalStart);
1137 visualLimit=runs[j].visualLimit;
1138 if(IS_EVEN_RUN(runs[j].logicalStart)) {
1157 length=runs[i].visualLimit-visualStart;
1158 insertRemove=runs[i].insertRemove;
1163 logicalStart=GET_INDEX(runs[i].logicalStart);
1182 length=runs[i].visualLimit-visualStart;
1183 insertRemove=runs[i].insertRemove;
1184 /* no control found within previous runs nor within this run */
1188 logicalStart=runs[i].logicalStart;
1224 /* fill a visual-to-logical index map using the runs[] */
1225 Run *runs=pBiDi->runs, *runsLimit=runs+pBiDi->runCount;
1232 for(; runs<runsLimit; ++runs) {
1233 logicalStart=runs->logicalStart;
1234 visualLimit=runs->visualLimit;
1252 runs=pBiDi->runs;
1255 insertRemove=runs[i].insertRemove;
1266 insertRemove=runs[i].insertRemove;
1271 visualStart= i>0 ? runs[i-1].visualLimit : 0;
1272 for(j=runs[i].visualLimit-1; j>=visualStart && markFound>0; j--) {
1286 runs=pBiDi->runs;
1291 length=runs[i].visualLimit-visualStart;
1292 insertRemove=runs[i].insertRemove;
1300 visualLimit=runs[i].visualLimit;
1306 logicalStart=runs[i].logicalStart;