15192346582

Committed 22 May 2025 04:13PM UTC coverage: 79.545% (+1.0%) from 78.546%

Build # 15192346582

Build Type

push

github

Committed by

mta452

Commit Message

[make] Set C++ standard version to 14

Run Details

1400 of 1760 relevant lines covered (79.55%)

868008.5 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

99.13

/Source/IsolatingRun.c

/*
 * Copyright (C) 2014-2025 Muhammad Tayyab Akram
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <SBConfig.h>

#include "BidiChain.h"
#include "BracketQueue.h"
#include "BracketType.h"
#include "LevelRun.h"
#include "PairingLookup.h"
#include "SBAssert.h"
#include "SBBase.h"
#include "SBCodepoint.h"
#include "SBLog.h"
#include "IsolatingRun.h"

static void ResolveAvailableBracketPairs(IsolatingRunRef isolatingRun);

static void AttachLevelRunLinks(IsolatingRunRef isolatingRun)
{
    BidiChainRef chain = isolatingRun->bidiChain;
    LevelRunRef baseLevelRun = isolatingRun->baseLevelRun;
    LevelRunRef current;
    LevelRunRef next;

    isolatingRun->_originalLink = BidiChainGetNext(chain, chain->roller);
    BidiChainSetNext(chain, chain->roller, baseLevelRun->firstLink);

    /* Iterate over level runs and attach their links to form an isolating run. */
    for (current = baseLevelRun; (next = current->next); current = next) {
        BidiChainSetNext(chain, current->lastLink, next->firstLink);
    }
    BidiChainSetNext(chain, current->lastLink, chain->roller);

    isolatingRun->_lastLevelRun = current;
    isolatingRun->_sos = RunExtrema_SOR(baseLevelRun->extrema);

    if (!RunKindIsPartialIsolate(baseLevelRun->kind)) {
        isolatingRun->_eos = RunExtrema_EOR(current->extrema);
    } else {
        SBLevel paragraphLevel = isolatingRun->paragraphLevel;
        SBLevel runLevel = baseLevelRun->level;
        SBLevel eosLevel = (runLevel > paragraphLevel ? runLevel : paragraphLevel);
        isolatingRun->_eos = ((eosLevel & 1) ? SBBidiTypeR : SBBidiTypeL);
    }
}

static void AttachOriginalLinks(IsolatingRunRef isolatingRun)
{
    BidiChainRef chain = isolatingRun->bidiChain;
    LevelRunRef current;

    BidiChainSetNext(chain, chain->roller, isolatingRun->_originalLink);

    /* Iterate over level runs and attach original subsequent links. */
    for (current = isolatingRun->baseLevelRun; current; current = current->next) {
        BidiChainSetNext(chain, current->lastLink, current->subsequentLink);
    }
}

static BidiLink ResolveWeakTypes(IsolatingRunRef isolatingRun)
{
    BidiChainRef chain = isolatingRun->bidiChain;
    BidiLink roller = chain->roller;
    BidiLink link;

    BidiLink priorLink;
    SBBidiType sos;

    SBBidiType w1PriorType;
    SBBidiType w2StrongType;
    SBBidiType w4PriorType;
    SBBidiType w5PriorType;
    SBBidiType w7StrongType;

    priorLink = roller;
    sos = isolatingRun->_sos;

    w1PriorType = sos;
    w2StrongType = sos;

    BidiChainForEach(chain, roller, link) {
        SBBidiType type = BidiChainGetType(chain, link);
        SBBoolean forceMerge = SBFalse;

        /* Rule W1 */
        if (type == SBBidiTypeNSM) {
            /* Change the 'type' variable as well because it can be EN on which W2 depends. */
            type = (SBBidiTypeIsIsolate(w1PriorType) ? SBBidiTypeON : w1PriorType);
            BidiChainSetType(chain, link, type);

            /* Fix for 3rd point of rule N0. */
            if (w1PriorType == SBBidiTypeON) {
                forceMerge = SBTrue;
            }
        }
        w1PriorType = type;

        /* Rule W2 */
        if (type == SBBidiTypeEN) {
            if (w2StrongType == SBBidiTypeAL) {
                BidiChainSetType(chain, link, SBBidiTypeAN);
            }
        }
        /*
         * Rule W3
         * NOTE: It is safe to apply W3 in 'else-if' statement because it only depends on type AL.
         *       Even if W2 changes EN to AN, there won't be any harm.
         */
        else if (type == SBBidiTypeAL) {
            BidiChainSetType(chain, link, SBBidiTypeR);
        }

        if (SBBidiTypeIsStrong(type)) {
            /* Save the strong type as it is checked in W2. */
            w2StrongType = type;
        }

        if ((type != SBBidiTypeON && BidiChainGetType(chain, priorLink) == type) || forceMerge) {
            BidiChainAbsorbNext(chain, priorLink);
        } else {
            priorLink = link;
        }
    }

    priorLink = roller;
    w4PriorType = sos;
    w5PriorType = sos;
    w7StrongType = sos;

    BidiChainForEach(chain, roller, link) {
        SBBidiType type = BidiChainGetType(chain, link);
        SBBidiType nextType = BidiChainGetType(chain, BidiChainGetNext(chain, link));

        /* Rule W4 */
        if (BidiChainIsSingle(chain, link)
            && SBBidiTypeIsNumberSeparator(type)
            && SBBidiTypeIsNumber(w4PriorType)
            && (w4PriorType == nextType)
            && (w4PriorType == SBBidiTypeEN || type == SBBidiTypeCS))
        {
            /* Change the current type as well because it can be EN on which W5 depends. */
            type = w4PriorType;
            BidiChainSetType(chain, link, type);
        }
        w4PriorType = type;

        /* Rule W5 */
        if (type == SBBidiTypeET && (w5PriorType == SBBidiTypeEN || nextType == SBBidiTypeEN)) {
            /* Change the current type as well because it is EN on which W7 depends. */
            type = SBBidiTypeEN;
            BidiChainSetType(chain, link, type);
        }
        w5PriorType = type;

        switch (type) {
        /* Rule W6 */
        case SBBidiTypeET:
        case SBBidiTypeCS:
        case SBBidiTypeES:
            BidiChainSetType(chain, link, SBBidiTypeON);
            break;

        /*
         * Rule W7
         * NOTE: W7 is expected to be applied after W6. However this is not the case here. The
         *       reason is that W6 can only create the type ON which is not tested in W7 by any
         *       means. So it won't affect the algorithm.
         */
        case SBBidiTypeEN:
            if (w7StrongType == SBBidiTypeL) {
                BidiChainSetType(chain, link, SBBidiTypeL);
            }
            break;

        /*
         * Save the strong type for W7.
         * NOTE: The strong type is expected to be saved after applying W7 because W7 itself creates
         *       a strong type. However the strong type being saved here is based on the type after
         *       W5. This won't effect the algorithm because a single link contains all consecutive
         *       EN types. This means that even if W7 creates a strong type, it will be saved in
         *       next iteration.
         */
        case SBBidiTypeL:
        case SBBidiTypeR:
            w7StrongType = type;
            break;
        }

        if (type != SBBidiTypeON && BidiChainGetType(chain, priorLink) == type) {
            BidiChainAbsorbNext(chain, priorLink);
        } else {
            priorLink = link;
        }
    }

    return priorLink;
}

static SBBoolean ResolveBrackets(IsolatingRunRef isolatingRun)
{
    const SBCodepointSequence *sequence = isolatingRun->codepointSequence;
    SBUInteger paragraphOffset = isolatingRun->paragraphOffset;
    BracketQueueRef queue = &isolatingRun->_bracketQueue;
    BidiChainRef chain = isolatingRun->bidiChain;
    BidiLink roller = chain->roller;
    BidiLink link;

    BidiLink priorStrongLink;
    SBLevel runLevel;

    priorStrongLink = BidiLinkNone;
    runLevel = isolatingRun->baseLevelRun->level;

    BracketQueueReset(queue, SBLevelAsNormalBidiType(runLevel));

    BidiChainForEach(chain, roller, link) {
        SBUInteger stringIndex;
        SBCodepoint codepoint;
        SBBidiType type;

        SBCodepoint bracketValue;
        BracketType bracketType;

        type = BidiChainGetType(chain, link);

        switch (type) {
        case SBBidiTypeON:
            stringIndex = BidiChainGetOffset(chain, link) + paragraphOffset;
            codepoint = SBCodepointSequenceGetCodepointAt(sequence, &stringIndex);
            bracketValue = LookupBracketPair(codepoint, &bracketType);

            switch (bracketType) {
            case BracketTypeOpen:
                if (queue->count < BracketQueueGetMaxCapacity()) {
                    if (!BracketQueueEnqueue(queue, priorStrongLink, link, bracketValue)) {
                        return SBFalse;
                    }
                } else {
                    goto Resolve;
                }
                break;

            case BracketTypeClose:
                if (queue->count != 0) {
                    BracketQueueClosePair(queue, link, codepoint);

                    if (BracketQueueShouldDequeue(queue)) {
                        ResolveAvailableBracketPairs(isolatingRun);
                    }
                }
                break;
            }
            break;

        case SBBidiTypeEN:
        case SBBidiTypeAN:
            type = SBBidiTypeR;

        case SBBidiTypeR:
        case SBBidiTypeL:
            if (queue->count != 0) {
                BracketQueueSetStrongType(queue, type);
            }

            priorStrongLink = link;
            break;
        }
    }

Resolve:
    ResolveAvailableBracketPairs(isolatingRun);
    return SBTrue;
}

static void ResolveAvailableBracketPairs(IsolatingRunRef isolatingRun)
{
    BracketQueueRef queue = &isolatingRun->_bracketQueue;
    BidiChainRef chain = isolatingRun->bidiChain;

    SBLevel runLevel;
    SBBidiType embeddingDirection;
    SBBidiType oppositeDirection;

    runLevel = isolatingRun->baseLevelRun->level;
    embeddingDirection = SBLevelAsNormalBidiType(runLevel);
    oppositeDirection = SBLevelAsOppositeBidiType(runLevel);

    while (queue->count != 0) {
        BidiLink openingLink = BracketQueueGetOpeningLink(queue);
        BidiLink closingLink = BracketQueueGetClosingLink(queue);

        if ((openingLink != BidiLinkNone) && (closingLink != BidiLinkNone)) {
            SBBidiType innerStrongType;
            SBBidiType pairType;

            innerStrongType = BracketQueueGetStrongType(queue);

            /* Rule: N0.b */
            if (innerStrongType == embeddingDirection) {
                pairType = innerStrongType;
            }
            /* Rule: N0.c */
            else if (innerStrongType == oppositeDirection) {
                BidiLink priorStrongLink;
                SBBidiType priorStrongType;

                priorStrongLink = BracketQueueGetPriorStrongLink(queue);

                if (priorStrongLink != BidiLinkNone) {
                    BidiLink link;

                    priorStrongType = BidiChainGetType(chain, priorStrongLink);
                    if (SBBidiTypeIsNumber(priorStrongType)) {
                        priorStrongType = SBBidiTypeR;
                    }

                    link = BidiChainGetNext(chain, priorStrongLink);

                    while (link != openingLink) {
                        SBBidiType type = BidiChainGetType(chain, link);
                        if (type == SBBidiTypeL || type == SBBidiTypeR) {
                            priorStrongType = type;
                        }

                        link = BidiChainGetNext(chain, link);
                    }
                } else {
                    priorStrongType = isolatingRun->_sos;
                }

                /* Rule: N0.c.1 */
                if (priorStrongType == oppositeDirection) {
                    pairType = oppositeDirection;
                }
                /* Rule: N0.c.2 */
                else {
                    pairType = embeddingDirection;
                }
            }
            /* Rule: N0.d */
            else {
                pairType = SBBidiTypeNil;
            }

            if (pairType != SBBidiTypeNil) {
                /* Do the substitution */
                BidiChainSetType(chain, openingLink, pairType);
                BidiChainSetType(chain, closingLink, pairType);
            }
        }

        BracketQueueDequeue(queue);
    }
}

static void ResolveNeutrals(IsolatingRunRef isolatingRun)
{
    BidiChainRef chain = isolatingRun->bidiChain;
    BidiLink roller = chain->roller;
    BidiLink link;

    SBLevel runLevel;
    SBBidiType strongType;
    BidiLink neutralLink;

    runLevel = isolatingRun->baseLevelRun->level;
    strongType = isolatingRun->_sos;
    neutralLink = BidiLinkNone;

    BidiChainForEach(chain, roller, link) {
        SBBidiType type = BidiChainGetType(chain, link);
        SBBidiType nextType;

        SBAssert(SBBidiTypeIsStrongOrNumber(type) || SBBidiTypeIsNeutralOrIsolate(type));

        switch (type) {
        case SBBidiTypeL:
            strongType = SBBidiTypeL;
            break;

        case SBBidiTypeR:
        case SBBidiTypeEN:
        case SBBidiTypeAN:
            strongType = SBBidiTypeR;
            break;

        case SBBidiTypeB:                           
        case SBBidiTypeS:
        case SBBidiTypeWS:
        case SBBidiTypeON:
        case SBBidiTypeLRI:
        case SBBidiTypeRLI:                         
        case SBBidiTypeFSI:
        case SBBidiTypePDI:
            if (neutralLink == BidiLinkNone) {
                neutralLink = link;
            }

            nextType = BidiChainGetType(chain, BidiChainGetNext(chain, link));
            if (SBBidiTypeIsNumber(nextType)) {
                nextType = SBBidiTypeR;
            } else if (nextType == SBBidiTypeNil) {
                nextType = isolatingRun->_eos;
            }

            if (SBBidiTypeIsStrong(nextType)) {
                /* Rules N1, N2 */
                SBBidiType resolvedType = (strongType == nextType
                                           ? strongType
                                           : SBLevelAsNormalBidiType(runLevel));

                do {
                    BidiChainSetType(chain, neutralLink, resolvedType);
                    neutralLink = BidiChainGetNext(chain, neutralLink);
                } while (neutralLink != BidiChainGetNext(chain, link));

                neutralLink = BidiLinkNone;
            }
            break;
        }
    }
}

static void ResolveImplicitLevels(IsolatingRunRef isolatingRun)
{
    BidiChainRef chain = isolatingRun->bidiChain;
    BidiLink roller = chain->roller;
    BidiLink link;

    SBLevel runLevel = isolatingRun->baseLevelRun->level;
    
    if ((runLevel & 1) == 0) {
        BidiChainForEach(chain, roller, link) {
            SBBidiType type = BidiChainGetType(chain, link);
            SBLevel level = BidiChainGetLevel(chain, link);
            
            SBAssert(SBBidiTypeIsStrongOrNumber(type));
            
            /* Rule I1 */
            if (type == SBBidiTypeR) {
                BidiChainSetLevel(chain, link, level + 1);
            } else if (type != SBBidiTypeL) {
                BidiChainSetLevel(chain, link, level + 2);
            }
        }
    } else {
        BidiChainForEach(chain, roller, link) {
            SBBidiType type = BidiChainGetType(chain, link);
            SBLevel level = BidiChainGetLevel(chain, link);
            
            SBAssert(SBBidiTypeIsStrongOrNumber(type));
            
            /* Rule I2 */
            if (type != SBBidiTypeR) {
                BidiChainSetLevel(chain, link, level + 1);
            }
        }
    }
}

SB_INTERNAL void IsolatingRunInitialize(IsolatingRunRef isolatingRun)
{
    BracketQueueInitialize(&isolatingRun->_bracketQueue);
}

SB_INTERNAL SBBoolean IsolatingRunResolve(IsolatingRunRef isolatingRun)
{
    BidiLink lastLink;
    BidiLink subsequentLink;

    SB_LOG_BLOCK_OPENER("Identified Isolating Run");

    /* Attach level run links to form isolating run. */
    AttachLevelRunLinks(isolatingRun);
    /* Save last subsequent link. */
    subsequentLink = isolatingRun->_lastLevelRun->subsequentLink;

    SB_LOG_STATEMENT("Range", 1, SB_LOG_RUN_RANGE(isolatingRun));
    SB_LOG_STATEMENT("Types", 1, SB_LOG_RUN_TYPES(isolatingRun));
    SB_LOG_STATEMENT("Level", 1, SB_LOG_LEVEL(isolatingRun->baseLevelRun->level));
    SB_LOG_STATEMENT("SOS", 1, SB_LOG_BIDI_TYPE(isolatingRun->_sos));
    SB_LOG_STATEMENT("EOS", 1, SB_LOG_BIDI_TYPE(isolatingRun->_eos));

    /* Rules W1-W7 */
    lastLink = ResolveWeakTypes(isolatingRun);
    SB_LOG_BLOCK_OPENER("Resolved Weak Types");
    SB_LOG_STATEMENT("Types", 1, SB_LOG_RUN_TYPES(isolatingRun));
    SB_LOG_BLOCK_CLOSER();

    /* Rule N0 */
    if (!ResolveBrackets(isolatingRun)) {
        return SBFalse;
    }

    SB_LOG_BLOCK_OPENER("Resolved Brackets");
    SB_LOG_STATEMENT("Types", 1, SB_LOG_RUN_TYPES(isolatingRun));
    SB_LOG_BLOCK_CLOSER();

    /* Rules N1, N2 */
    ResolveNeutrals(isolatingRun);
    SB_LOG_BLOCK_OPENER("Resolved Neutrals");
    SB_LOG_STATEMENT("Types", 1, SB_LOG_RUN_TYPES(isolatingRun));
    SB_LOG_BLOCK_CLOSER();

    /* Rules I1, I2 */
    ResolveImplicitLevels(isolatingRun);
    SB_LOG_BLOCK_OPENER("Resolved Implicit Levels");
    SB_LOG_STATEMENT("Levels", 1, SB_LOG_RUN_LEVELS(isolatingRun));
    SB_LOG_BLOCK_CLOSER();

    /* Re-attach original links. */
    AttachOriginalLinks(isolatingRun);
    /* Attach new final link (of isolating run) with last subsequent link. */
    BidiChainSetNext(isolatingRun->bidiChain, lastLink, subsequentLink);

    SB_LOG_BLOCK_CLOSER();

    return SBTrue;
}

SB_INTERNAL void IsolatingRunFinalize(IsolatingRunRef isolatingRun)
{
    BracketQueueFinalize(&isolatingRun->_bracketQueue);
}

1	/*
2	* Copyright (C) 2014-2025 Muhammad Tayyab Akram
3	*
4	* Licensed under the Apache License, Version 2.0 (the "License");
5	* you may not use this file except in compliance with the License.
6	* You may obtain a copy of the License at
7	*
8	* http://www.apache.org/licenses/LICENSE-2.0
9	*
10	* Unless required by applicable law or agreed to in writing, software
11	* distributed under the License is distributed on an "AS IS" BASIS,
12	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13	* See the License for the specific language governing permissions and
14	* limitations under the License.
15	*/
16
17	#include <SBConfig.h>
18
19	#include "BidiChain.h"
20	#include "BracketQueue.h"
21	#include "BracketType.h"
22	#include "LevelRun.h"
23	#include "PairingLookup.h"
24	#include "SBAssert.h"
25	#include "SBBase.h"
26	#include "SBCodepoint.h"
27	#include "SBLog.h"
28	#include "IsolatingRun.h"
29
30	static void ResolveAvailableBracketPairs(IsolatingRunRef isolatingRun);
31
32	static void AttachLevelRunLinks(IsolatingRunRef isolatingRun)	1,257,049✔
33	{
34	BidiChainRef chain = isolatingRun->bidiChain;	1,257,049✔
35	LevelRunRef baseLevelRun = isolatingRun->baseLevelRun;	1,257,049✔
36	LevelRunRef current;
37	LevelRunRef next;
38
39	isolatingRun->_originalLink = BidiChainGetNext(chain, chain->roller);	1,257,049✔
40	BidiChainSetNext(chain, chain->roller, baseLevelRun->firstLink);	1,257,049✔
41
42	/* Iterate over level runs and attach their links to form an isolating run. */
43	for (current = baseLevelRun; (next = current->next); current = next) {	1,264,807✔
44	BidiChainSetNext(chain, current->lastLink, next->firstLink);	7,758✔
45	}
46	BidiChainSetNext(chain, current->lastLink, chain->roller);	1,257,049✔
47
48	isolatingRun->_lastLevelRun = current;	1,257,049✔
49	isolatingRun->_sos = RunExtrema_SOR(baseLevelRun->extrema);	1,257,049✔
50
51	if (!RunKindIsPartialIsolate(baseLevelRun->kind)) {	1,257,049✔
52	isolatingRun->_eos = RunExtrema_EOR(current->extrema);	916,331✔
53	} else {
54	SBLevel paragraphLevel = isolatingRun->paragraphLevel;	340,718✔
55	SBLevel runLevel = baseLevelRun->level;	340,718✔
56	SBLevel eosLevel = (runLevel > paragraphLevel ? runLevel : paragraphLevel);	340,718✔
57	isolatingRun->_eos = ((eosLevel & 1) ? SBBidiTypeR : SBBidiTypeL);	340,718✔
58	}
59	}	1,257,049✔
60
61	static void AttachOriginalLinks(IsolatingRunRef isolatingRun)	1,257,049✔
62	{
63	BidiChainRef chain = isolatingRun->bidiChain;	1,257,049✔
64	LevelRunRef current;
65
66	BidiChainSetNext(chain, chain->roller, isolatingRun->_originalLink);	1,257,049✔
67
68	/* Iterate over level runs and attach original subsequent links. */
69	for (current = isolatingRun->baseLevelRun; current; current = current->next) {	2,521,856✔
70	BidiChainSetNext(chain, current->lastLink, current->subsequentLink);	1,264,807✔
71	}
72	}	1,257,049✔
73
74	static BidiLink ResolveWeakTypes(IsolatingRunRef isolatingRun)	1,257,049✔
75	{
76	BidiChainRef chain = isolatingRun->bidiChain;	1,257,049✔
77	BidiLink roller = chain->roller;	1,257,049✔
78	BidiLink link;
79
80	BidiLink priorLink;
81	SBBidiType sos;
82
83	SBBidiType w1PriorType;
84	SBBidiType w2StrongType;
85	SBBidiType w4PriorType;
86	SBBidiType w5PriorType;
87	SBBidiType w7StrongType;
88
89	priorLink = roller;	1,257,049✔
90	sos = isolatingRun->_sos;	1,257,049✔
91
92	w1PriorType = sos;	1,257,049✔
93	w2StrongType = sos;	1,257,049✔
94
95	BidiChainForEach(chain, roller, link) {	4,075,780✔
96	SBBidiType type = BidiChainGetType(chain, link);	2,818,731✔
97	SBBoolean forceMerge = SBFalse;	2,818,731✔
98
99	/* Rule W1 */
100	if (type == SBBidiTypeNSM) {	2,818,731✔
101	/* Change the 'type' variable as well because it can be EN on which W2 depends. */
102	type = (SBBidiTypeIsIsolate(w1PriorType) ? SBBidiTypeON : w1PriorType);	118,199✔
103	BidiChainSetType(chain, link, type);	118,199✔
104
105	/* Fix for 3rd point of rule N0. */
106	if (w1PriorType == SBBidiTypeON) {	118,199✔
107	forceMerge = SBTrue;	4,583✔
108	}
109	}
110	w1PriorType = type;	2,818,731✔
111
112	/* Rule W2 */
113	if (type == SBBidiTypeEN) {	2,818,731✔
114	if (w2StrongType == SBBidiTypeAL) {	123,093✔
115	BidiChainSetType(chain, link, SBBidiTypeAN);	6,365✔
116	}
117	}
118	/*
119	* Rule W3
120	* NOTE: It is safe to apply W3 in 'else-if' statement because it only depends on type AL.
121	* Even if W2 changes EN to AN, there won't be any harm.
122	*/
123	else if (type == SBBidiTypeAL) {	2,695,638✔
124	BidiChainSetType(chain, link, SBBidiTypeR);	123,081✔
125	}
126
127	if (SBBidiTypeIsStrong(type)) {	2,818,731✔
128	/* Save the strong type as it is checked in W2. */
129	w2StrongType = type;	808,401✔
130	}
131
132	if ((type != SBBidiTypeON && BidiChainGetType(chain, priorLink) == type) \|\| forceMerge) {	2,818,731✔
133	BidiChainAbsorbNext(chain, priorLink);	62,610✔
134	} else {
135	priorLink = link;	2,756,121✔
136	}
137	}
138
139	priorLink = roller;	1,257,049✔
140	w4PriorType = sos;	1,257,049✔
141	w5PriorType = sos;	1,257,049✔
142	w7StrongType = sos;	1,257,049✔
143
144	BidiChainForEach(chain, roller, link) {	4,013,170✔
145	SBBidiType type = BidiChainGetType(chain, link);	2,756,121✔
146	SBBidiType nextType = BidiChainGetType(chain, BidiChainGetNext(chain, link));	2,756,121✔
147
148	/* Rule W4 */
149	if (BidiChainIsSingle(chain, link)	2,756,121✔
150	&& SBBidiTypeIsNumberSeparator(type)	2,592,373✔
151	&& SBBidiTypeIsNumber(w4PriorType)	218,034✔
152	&& (w4PriorType == nextType)	17,704✔
153	&& (w4PriorType == SBBidiTypeEN \|\| type == SBBidiTypeCS))	651✔
154	{
155	/* Change the current type as well because it can be EN on which W5 depends. */
156	type = w4PriorType;	485✔
157	BidiChainSetType(chain, link, type);	485✔
158	}
159	w4PriorType = type;	2,756,121✔
160
161	/* Rule W5 */
162	if (type == SBBidiTypeET && (w5PriorType == SBBidiTypeEN \|\| nextType == SBBidiTypeEN)) {	2,756,121✔
163	/* Change the current type as well because it is EN on which W7 depends. */
164	type = SBBidiTypeEN;	8,892✔
165	BidiChainSetType(chain, link, type);	8,892✔
166	}
167	w5PriorType = type;	2,756,121✔
168
169	switch (type) {	2,756,121✔
170	/* Rule W6 */
171	case SBBidiTypeET:	344,031✔
172	case SBBidiTypeCS:
173	case SBBidiTypeES:
174	BidiChainSetType(chain, link, SBBidiTypeON);	344,031✔
175	break;	344,031✔
176
177	/*
178	* Rule W7
179	* NOTE: W7 is expected to be applied after W6. However this is not the case here. The
180	* reason is that W6 can only create the type ON which is not tested in W7 by any
181	* means. So it won't affect the algorithm.
182	*/
183	case SBBidiTypeEN:	121,136✔
184	if (w7StrongType == SBBidiTypeL) {	121,136✔
185	BidiChainSetType(chain, link, SBBidiTypeL);	72,106✔
186	}
187	break;	121,136✔
188
189	/*
190	* Save the strong type for W7.
191	* NOTE: The strong type is expected to be saved after applying W7 because W7 itself creates
192	* a strong type. However the strong type being saved here is based on the type after
193	* W5. This won't effect the algorithm because a single link contains all consecutive
194	* EN types. This means that even if W7 creates a strong type, it will be saved in
195	* next iteration.
196	*/
197	case SBBidiTypeL:	789,782✔
198	case SBBidiTypeR:
199	w7StrongType = type;	789,782✔
200	break;	789,782✔
201	}
202
203	if (type != SBBidiTypeON && BidiChainGetType(chain, priorLink) == type) {	2,756,121✔
204	BidiChainAbsorbNext(chain, priorLink);	19,066✔
205	} else {
206	priorLink = link;	2,737,055✔
207	}
208	}
209
210	return priorLink;	1,257,049✔
211	}
212
213	static SBBoolean ResolveBrackets(IsolatingRunRef isolatingRun)	1,257,049✔
214	{
215	const SBCodepointSequence *sequence = isolatingRun->codepointSequence;	1,257,049✔
216	SBUInteger paragraphOffset = isolatingRun->paragraphOffset;	1,257,049✔
217	BracketQueueRef queue = &isolatingRun->_bracketQueue;	1,257,049✔
218	BidiChainRef chain = isolatingRun->bidiChain;	1,257,049✔
219	BidiLink roller = chain->roller;	1,257,049✔
220	BidiLink link;
221
222	BidiLink priorStrongLink;
223	SBLevel runLevel;
224
225	priorStrongLink = BidiLinkNone;	1,257,049✔
226	runLevel = isolatingRun->baseLevelRun->level;	1,257,049✔
227
228	BracketQueueReset(queue, SBLevelAsNormalBidiType(runLevel));	1,257,049✔
229
230	BidiChainForEach(chain, roller, link) {	3,994,038✔
231	SBUInteger stringIndex;	2,736,990✔
232	SBCodepoint codepoint;
233	SBBidiType type;
234
235	SBCodepoint bracketValue;
236	BracketType bracketType;	2,736,990✔
237
238	type = BidiChainGetType(chain, link);	2,736,990✔
239
240	switch (type) {	2,736,990✔
241	case SBBidiTypeON:	965,014✔
242	stringIndex = BidiChainGetOffset(chain, link) + paragraphOffset;	965,014✔
243	codepoint = SBCodepointSequenceGetCodepointAt(sequence, &stringIndex);	965,014✔
244	bracketValue = LookupBracketPair(codepoint, &bracketType);	965,014✔
245
246	switch (bracketType) {	965,014✔
247	case BracketTypeOpen:	329,476✔
248	if (queue->count < BracketQueueGetMaxCapacity()) {	329,476✔
249	if (!BracketQueueEnqueue(queue, priorStrongLink, link, bracketValue)) {	329,475✔
250	return SBFalse;	×
251	}
252	} else {
253	goto Resolve;	1✔
254	}
255	break;	329,475✔
256
257	case BracketTypeClose:	170,150✔
258	if (queue->count != 0) {	170,150✔
259	BracketQueueClosePair(queue, link, codepoint);	154,290✔
260
261	if (BracketQueueShouldDequeue(queue)) {	154,290✔
262	ResolveAvailableBracketPairs(isolatingRun);	62,172✔
263	}
264	}
265	break;	170,150✔
266	}
267	break;	965,013✔
268
269	case SBBidiTypeEN:	168,897✔
270	case SBBidiTypeAN:
271	type = SBBidiTypeR;	168,897✔
272
273	case SBBidiTypeR:	1,016,146✔
274	case SBBidiTypeL:
275	if (queue->count != 0) {	1,016,146✔
276	BracketQueueSetStrongType(queue, type);	186,688✔
277	}
278
279	priorStrongLink = link;	1,016,146✔
280	break;	1,016,146✔
281	}
282	}
283
284	Resolve:	1,257,048✔
285	ResolveAvailableBracketPairs(isolatingRun);	1,257,049✔
286	return SBTrue;	1,257,049✔
287	}
288
289	static void ResolveAvailableBracketPairs(IsolatingRunRef isolatingRun)	1,319,221✔
290	{
291	BracketQueueRef queue = &isolatingRun->_bracketQueue;	1,319,221✔
292	BidiChainRef chain = isolatingRun->bidiChain;	1,319,221✔
293
294	SBLevel runLevel;
295	SBBidiType embeddingDirection;
296	SBBidiType oppositeDirection;
297
298	runLevel = isolatingRun->baseLevelRun->level;	1,319,221✔
299	embeddingDirection = SBLevelAsNormalBidiType(runLevel);	1,319,221✔
300	oppositeDirection = SBLevelAsOppositeBidiType(runLevel);	1,319,221✔
301
302	while (queue->count != 0) {	1,648,696✔
303	BidiLink openingLink = BracketQueueGetOpeningLink(queue);	329,475✔
304	BidiLink closingLink = BracketQueueGetClosingLink(queue);	329,475✔
305
306	if ((openingLink != BidiLinkNone) && (closingLink != BidiLinkNone)) {	329,475✔
307	SBBidiType innerStrongType;
308	SBBidiType pairType;
309
310	innerStrongType = BracketQueueGetStrongType(queue);	139,723✔
311
312	/* Rule: N0.b */
313	if (innerStrongType == embeddingDirection) {	139,723✔
314	pairType = innerStrongType;	52,931✔
315	}
316	/* Rule: N0.c */
317	else if (innerStrongType == oppositeDirection) {	86,792✔
318	BidiLink priorStrongLink;
319	SBBidiType priorStrongType;
320
321	priorStrongLink = BracketQueueGetPriorStrongLink(queue);	28,864✔
322
323	if (priorStrongLink != BidiLinkNone) {	28,864✔
324	BidiLink link;
325
326	priorStrongType = BidiChainGetType(chain, priorStrongLink);	16,576✔
327	if (SBBidiTypeIsNumber(priorStrongType)) {	16,576✔
328	priorStrongType = SBBidiTypeR;	22✔
329	}
330
331	link = BidiChainGetNext(chain, priorStrongLink);	16,576✔
332
333	while (link != openingLink) {	30,737✔
334	SBBidiType type = BidiChainGetType(chain, link);	14,161✔
335	if (type == SBBidiTypeL \|\| type == SBBidiTypeR) {	14,161✔
336	priorStrongType = type;	6,258✔
337	}
338
339	link = BidiChainGetNext(chain, link);	14,161✔
340	}
341	} else {
342	priorStrongType = isolatingRun->_sos;	12,288✔
343	}
344
345	/* Rule: N0.c.1 */
346	if (priorStrongType == oppositeDirection) {	28,864✔
347	pairType = oppositeDirection;	7,780✔
348	}
349	/* Rule: N0.c.2 */
350	else {
351	pairType = embeddingDirection;	21,084✔
352	}
353	}
354	/* Rule: N0.d */
355	else {
356	pairType = SBBidiTypeNil;	57,928✔
357	}
358
359	if (pairType != SBBidiTypeNil) {	139,723✔
360	/* Do the substitution */
361	BidiChainSetType(chain, openingLink, pairType);	81,795✔
362	BidiChainSetType(chain, closingLink, pairType);	81,795✔
363	}
364	}
365
366	BracketQueueDequeue(queue);	329,475✔
367	}
368	}	1,319,221✔
369
370	static void ResolveNeutrals(IsolatingRunRef isolatingRun)	1,257,049✔
371	{
372	BidiChainRef chain = isolatingRun->bidiChain;	1,257,049✔
373	BidiLink roller = chain->roller;	1,257,049✔
374	BidiLink link;
375
376	SBLevel runLevel;
377	SBBidiType strongType;
378	BidiLink neutralLink;
379
380	runLevel = isolatingRun->baseLevelRun->level;	1,257,049✔
381	strongType = isolatingRun->_sos;	1,257,049✔
382	neutralLink = BidiLinkNone;	1,257,049✔
383
384	BidiChainForEach(chain, roller, link) {	3,994,104✔
385	SBBidiType type = BidiChainGetType(chain, link);	2,737,055✔
386	SBBidiType nextType;
387
388	SBAssert(SBBidiTypeIsStrongOrNumber(type) \|\| SBBidiTypeIsNeutralOrIsolate(type));	2,737,055✔
389
390	switch (type) {	2,737,055✔
391	case SBBidiTypeL:	492,739✔
392	strongType = SBBidiTypeL;	492,739✔
393	break;	492,739✔
394
395	case SBBidiTypeR:	686,998✔
396	case SBBidiTypeEN:
397	case SBBidiTypeAN:
398	strongType = SBBidiTypeR;	686,998✔
399	break;	686,998✔
400
401	case SBBidiTypeB:	1,557,318✔
402	case SBBidiTypeS:
403	case SBBidiTypeWS:
404	case SBBidiTypeON:
405	case SBBidiTypeLRI:
406	case SBBidiTypeRLI:
407	case SBBidiTypeFSI:
408	case SBBidiTypePDI:
409	if (neutralLink == BidiLinkNone) {	1,557,318✔
410	neutralLink = link;	1,071,507✔
411	}
412
413	nextType = BidiChainGetType(chain, BidiChainGetNext(chain, link));	1,557,318✔
414	if (SBBidiTypeIsNumber(nextType)) {	1,557,318✔
415	nextType = SBBidiTypeR;	44,682✔
416	} else if (nextType == SBBidiTypeNil) {	1,512,636✔
417	nextType = isolatingRun->_eos;	768,320✔
418	}
419
420	if (SBBidiTypeIsStrong(nextType)) {	1,557,318✔
421	/* Rules N1, N2 */
422	SBBidiType resolvedType = (strongType == nextType	1,305,697✔
423	? strongType
424	: SBLevelAsNormalBidiType(runLevel));	234,190✔
425
426	do {
427	BidiChainSetType(chain, neutralLink, resolvedType);	1,557,318✔
428	neutralLink = BidiChainGetNext(chain, neutralLink);	1,557,318✔
429	} while (neutralLink != BidiChainGetNext(chain, link));	1,557,318✔
430
431	neutralLink = BidiLinkNone;	1,071,507✔
432	}
433	break;	1,557,318✔
434	}
435	}
436	}	1,257,049✔
437
438	static void ResolveImplicitLevels(IsolatingRunRef isolatingRun)	1,257,049✔
439	{
440	BidiChainRef chain = isolatingRun->bidiChain;	1,257,049✔
441	BidiLink roller = chain->roller;	1,257,049✔
442	BidiLink link;
443
444	SBLevel runLevel = isolatingRun->baseLevelRun->level;	1,257,049✔
445
446	if ((runLevel & 1) == 0) {	1,257,049✔
447	BidiChainForEach(chain, roller, link) {	2,198,392✔
448	SBBidiType type = BidiChainGetType(chain, link);	1,492,015✔
449	SBLevel level = BidiChainGetLevel(chain, link);	1,492,015✔
450
451	SBAssert(SBBidiTypeIsStrongOrNumber(type));	1,492,015✔
452
453	/* Rule I1 */
454	if (type == SBBidiTypeR) {	1,492,015✔
455	BidiChainSetLevel(chain, link, level + 1);	167,970✔
456	} else if (type != SBBidiTypeL) {	1,324,045✔
457	BidiChainSetLevel(chain, link, level + 2);	72,819✔
458	}
459	}
460	} else {
461	BidiChainForEach(chain, roller, link) {	1,795,712✔
462	SBBidiType type = BidiChainGetType(chain, link);	1,245,040✔
463	SBLevel level = BidiChainGetLevel(chain, link);	1,245,040✔
464
465	SBAssert(SBBidiTypeIsStrongOrNumber(type));	1,245,040✔
466
467	/* Rule I2 */
468	if (type != SBBidiTypeR) {	1,245,040✔
469	BidiChainSetLevel(chain, link, level + 1);	223,066✔
470	}
471	}
472	}
473	}	1,257,049✔
474
475	SB_INTERNAL void IsolatingRunInitialize(IsolatingRunRef isolatingRun)	861,949✔
476	{
477	BracketQueueInitialize(&isolatingRun->_bracketQueue);	861,949✔
478	}	861,949✔
479
480	SB_INTERNAL SBBoolean IsolatingRunResolve(IsolatingRunRef isolatingRun)	1,257,049✔
481	{
482	BidiLink lastLink;
483	BidiLink subsequentLink;
484
485	SB_LOG_BLOCK_OPENER("Identified Isolating Run");
486
487	/* Attach level run links to form isolating run. */
488	AttachLevelRunLinks(isolatingRun);	1,257,049✔
489	/* Save last subsequent link. */
490	subsequentLink = isolatingRun->_lastLevelRun->subsequentLink;	1,257,049✔
491
492	SB_LOG_STATEMENT("Range", 1, SB_LOG_RUN_RANGE(isolatingRun));
493	SB_LOG_STATEMENT("Types", 1, SB_LOG_RUN_TYPES(isolatingRun));
494	SB_LOG_STATEMENT("Level", 1, SB_LOG_LEVEL(isolatingRun->baseLevelRun->level));
495	SB_LOG_STATEMENT("SOS", 1, SB_LOG_BIDI_TYPE(isolatingRun->_sos));
496	SB_LOG_STATEMENT("EOS", 1, SB_LOG_BIDI_TYPE(isolatingRun->_eos));
497
498	/* Rules W1-W7 */
499	lastLink = ResolveWeakTypes(isolatingRun);	1,257,049✔
500	SB_LOG_BLOCK_OPENER("Resolved Weak Types");
501	SB_LOG_STATEMENT("Types", 1, SB_LOG_RUN_TYPES(isolatingRun));
502	SB_LOG_BLOCK_CLOSER();
503
504	/* Rule N0 */
505	if (!ResolveBrackets(isolatingRun)) {	1,257,049✔
506	return SBFalse;	×
507	}
508
509	SB_LOG_BLOCK_OPENER("Resolved Brackets");
510	SB_LOG_STATEMENT("Types", 1, SB_LOG_RUN_TYPES(isolatingRun));
511	SB_LOG_BLOCK_CLOSER();
512
513	/* Rules N1, N2 */
514	ResolveNeutrals(isolatingRun);	1,257,049✔
515	SB_LOG_BLOCK_OPENER("Resolved Neutrals");
516	SB_LOG_STATEMENT("Types", 1, SB_LOG_RUN_TYPES(isolatingRun));
517	SB_LOG_BLOCK_CLOSER();
518
519	/* Rules I1, I2 */
520	ResolveImplicitLevels(isolatingRun);	1,257,049✔
521	SB_LOG_BLOCK_OPENER("Resolved Implicit Levels");
522	SB_LOG_STATEMENT("Levels", 1, SB_LOG_RUN_LEVELS(isolatingRun));
523	SB_LOG_BLOCK_CLOSER();
524
525	/* Re-attach original links. */
526	AttachOriginalLinks(isolatingRun);	1,257,049✔
527	/* Attach new final link (of isolating run) with last subsequent link. */
528	BidiChainSetNext(isolatingRun->bidiChain, lastLink, subsequentLink);	1,257,049✔
529
530	SB_LOG_BLOCK_CLOSER();
531
532	return SBTrue;	1,257,049✔
533	}
534
535	SB_INTERNAL void IsolatingRunFinalize(IsolatingRunRef isolatingRun)	861,949✔
536	{
537	BracketQueueFinalize(&isolatingRun->_bracketQueue);	861,949✔
538	}	861,949✔

Tehreer / SheenBidi / 15192346582

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous