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;
668 runs[i].visualLimit=limit;
678 ADD_ODD_BIT_FROM_LEVEL(runs[trailingRun].logicalStart, pBiDi->paraLevel);
690 pBiDi->runs[runIndex].insertRemove|=point->flag;
701 pBiDi->runs[runIndex].insertRemove--;
841 break; /* no more such runs */
881 /* we can do the trivial cases without the runs array */
894 Run *runs=pBiDi->runs;
897 /* linear search for the run, search on the visual runs */
899 length=runs[i].visualLimit-visualStart;
900 offset=logicalIndex-GET_INDEX(runs[i].logicalStart);
902 if(IS_EVEN_RUN(runs[i].logicalStart)) {
921 Run *runs=pBiDi->runs;
925 length=runs[i].visualLimit-visualStart;
926 insertRemove=runs[i].insertRemove;
931 if(visualIndex<runs[i].visualLimit) {
941 Run *runs=pBiDi->runs;
949 /* loop on runs */
951 length=runs[i].visualLimit-visualStart;
952 insertRemove=runs[i].insertRemove;
954 if(visualIndex>=runs[i].visualLimit) {
962 if(IS_EVEN_RUN(runs[i].logicalStart)) {
964 start=runs[i].logicalStart;
969 limit=GET_INDEX(runs[i].logicalStart)+length;
986 Run *runs;
991 /* we can do the trivial cases without the runs array */
1005 runs=pBiDi->runs;
1011 runs=pBiDi->runs;
1014 length=runs[i].visualLimit-visualStart;
1015 insertRemove=runs[i].insertRemove;
1023 if(visualIndex<(runs[i].visualLimit+markFound)) {
1043 length=runs[i].visualLimit-visualStart;
1044 insertRemove=runs[i].insertRemove;
1046 if(visualIndex>=(runs[i].visualLimit-controlFound+insertRemove)) {
1056 logicalStart=runs[i].logicalStart;
1077 for(i=0; visualIndex>=runs[i].visualLimit; ++i) {}
1085 if(visualIndex>=runs[i].visualLimit) {
1087 } else if(i==0 || visualIndex>=runs[i-1].visualLimit) {
1095 start=runs[i].logicalStart;
1098 /* the offset in runs[i] is visualIndex-runs[i-1].visualLimit */
1100 visualIndex-=runs[i-1].visualLimit;
1105 return GET_INDEX(start)+runs[i].visualLimit-visualIndex-1;
1119 /* fill a logical-to-visual index map using the runs[] */
1122 Run *runs=pBiDi->runs;
1132 logicalStart=GET_INDEX(runs[j].logicalStart);
1133 visualLimit=runs[j].visualLimit;
1134 if(IS_EVEN_RUN(runs[j].logicalStart)) {
1153 length=runs[i].visualLimit-visualStart;
1154 insertRemove=runs[i].insertRemove;
1159 logicalStart=GET_INDEX(runs[i].logicalStart);
1178 length=runs[i].visualLimit-visualStart;
1179 insertRemove=runs[i].insertRemove;
1180 /* no control found within previous runs nor within this run */
1184 logicalStart=runs[i].logicalStart;
1220 /* fill a visual-to-logical index map using the runs[] */
1221 Run *runs=pBiDi->runs, *runsLimit=runs+pBiDi->runCount;
1228 for(; runs<runsLimit; ++runs) {
1229 logicalStart=runs->logicalStart;
1230 visualLimit=runs->visualLimit;
1248 runs=pBiDi->runs;
1251 insertRemove=runs[i].insertRemove;
1262 insertRemove=runs[i].insertRemove;
1267 visualStart= i>0 ? runs[i-1].visualLimit : 0;
1268 for(j=runs[i].visualLimit-1; j>=visualStart && markFound>0; j--) {
1282 runs=pBiDi->runs;
1287 length=runs[i].visualLimit-visualStart;
1288 insertRemove=runs[i].insertRemove;
1296 visualLimit=runs[i].visualLimit;
1302 logicalStart=runs[i].logicalStart;
