19308576644

Committed 12 Nov 2025 06:56PM UTC coverage: 95.907% (+16.4%) from 79.545%

Build # 19308576644

Build Type

push

github

Committed by

mta452

Commit Message

[lib] Fix memory management issues

Run Details

13 of 13 new or added lines in 3 files covered. (100.0%)

29 existing lines in 10 files now uncovered.

3866 of 4031 relevant lines covered (95.91%)

462026.31 hits per line

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

99.1

/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 <SheenBidi/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;
    const LevelRun *baseLevelRun = isolatingRun->baseLevelRun;
    const LevelRun *current;
    const LevelRun *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;
    const LevelRun *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 (BracketQueueGetOpenPairCount(queue) >= BracketQueueMaxOpenPairs) {
                    /* Stop further processing. */
                    return SBTrue;
                }
                if (!BracketQueueEnqueue(queue, priorStrongLink, link, bracketValue)) {
                    return SBFalse;
                }
                break;

            case BracketTypeClose:
                BracketQueueClosePair(queue, link, codepoint);
                break;
            }
            break;

        case SBBidiTypeEN:
        case SBBidiTypeAN:
            type = SBBidiTypeR;

        case SBBidiTypeR:
        case SBBidiTypeL:
            BracketQueueAssignInnerStrongType(queue, type);
            priorStrongLink = link;
            break;
        }
    }

    BracketQueueMarkPopulated(queue);
    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->pairCount > 0) {
        BidiLink openingLink = BracketQueueGetOpeningLink(queue);
        BidiLink closingLink = BracketQueueGetClosingLink(queue);
        SBBidiType innerStrongType = BracketQueueGetInnerStrongType(queue);
        SBBidiType pairType;

        /* 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);

                /*
                 * Iterate over in-between links to find the proper prior strong type because there
                 * might be resolved brackets with different strong types.
                 */
                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, MemoryRef memory)
{
    BracketQueueInitialize(&isolatingRun->_bracketQueue, memory);
}

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;
}

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 <SheenBidi/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,381✔
33	{
34	BidiChainRef chain = isolatingRun->bidiChain;	1,257,381✔
35	const LevelRun *baseLevelRun = isolatingRun->baseLevelRun;	1,257,381✔
36	const LevelRun *current;
37	const LevelRun *next;
38
39	isolatingRun->_originalLink = BidiChainGetNext(chain, chain->roller);	1,257,381✔
40	BidiChainSetNext(chain, chain->roller, baseLevelRun->firstLink);	1,257,381✔
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,265,139✔
44	BidiChainSetNext(chain, current->lastLink, next->firstLink);	7,758✔
45	}
46	BidiChainSetNext(chain, current->lastLink, chain->roller);	1,257,381✔
47
48	isolatingRun->_lastLevelRun = current;	1,257,381✔
49	isolatingRun->_sos = RunExtrema_SOR(baseLevelRun->extrema);	1,257,381✔
50
51	if (!RunKindIsPartialIsolate(baseLevelRun->kind)) {	1,257,381✔
52	isolatingRun->_eos = RunExtrema_EOR(current->extrema);	916,663✔
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,381✔
60
61	static void AttachOriginalLinks(IsolatingRunRef isolatingRun)	1,257,381✔
62	{
63	BidiChainRef chain = isolatingRun->bidiChain;	1,257,381✔
64	const LevelRun *current;
65
66	BidiChainSetNext(chain, chain->roller, isolatingRun->_originalLink);	1,257,381✔
67
68	/* Iterate over level runs and attach original subsequent links. */
69	for (current = isolatingRun->baseLevelRun; current; current = current->next) {	2,522,520✔
70	BidiChainSetNext(chain, current->lastLink, current->subsequentLink);	1,265,139✔
71	}
72	}	1,257,381✔
73
74	static BidiLink ResolveWeakTypes(IsolatingRunRef isolatingRun)	1,257,381✔
75	{
76	BidiChainRef chain = isolatingRun->bidiChain;	1,257,381✔
77	BidiLink roller = chain->roller;	1,257,381✔
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,381✔
90	sos = isolatingRun->_sos;	1,257,381✔
91
92	w1PriorType = sos;	1,257,381✔
93	w2StrongType = sos;	1,257,381✔
94
95	BidiChainForEach(chain, roller, link) {	4,077,302✔
96	SBBidiType type = BidiChainGetType(chain, link);	2,819,921✔
97	SBBoolean forceMerge = SBFalse;	2,819,921✔
98
99	/* Rule W1 */
100	if (type == SBBidiTypeNSM) {	2,819,921✔
101	/* Change the 'type' variable as well because it can be EN on which W2 depends. */
102	type = (SBBidiTypeIsIsolate(w1PriorType) ? SBBidiTypeON : w1PriorType);	118,204✔
103	BidiChainSetType(chain, link, type);	118,204✔
104
105	/* Fix for 3rd point of rule N0. */
106	if (w1PriorType == SBBidiTypeON) {	118,204✔
107	forceMerge = SBTrue;	4,583✔
108	}
109	}
110	w1PriorType = type;	2,819,921✔
111
112	/* Rule W2 */
113	if (type == SBBidiTypeEN) {	2,819,921✔
114	if (w2StrongType == SBBidiTypeAL) {	123,365✔
115	BidiChainSetType(chain, link, SBBidiTypeAN);	6,367✔
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,696,556✔
124	BidiChainSetType(chain, link, SBBidiTypeR);	123,131✔
125	}
126
127	if (SBBidiTypeIsStrong(type)) {	2,819,921✔
128	/* Save the strong type as it is checked in W2. */
129	w2StrongType = type;	809,038✔
130	}
131
132	if ((type != SBBidiTypeON && BidiChainGetType(chain, priorLink) == type) \|\| forceMerge) {	2,819,921✔
133	BidiChainAbsorbNext(chain, priorLink);	62,617✔
134	} else {
135	priorLink = link;	2,757,304✔
136	}
137	}
138
139	priorLink = roller;	1,257,381✔
140	w4PriorType = sos;	1,257,381✔
141	w5PriorType = sos;	1,257,381✔
142	w7StrongType = sos;	1,257,381✔
143
144	BidiChainForEach(chain, roller, link) {	4,014,685✔
145	SBBidiType type = BidiChainGetType(chain, link);	2,757,304✔
146	SBBidiType nextType = BidiChainGetType(chain, BidiChainGetNext(chain, link));	2,757,304✔
147
148	/* Rule W4 */
149	if (BidiChainIsSingle(chain, link)	2,757,304✔
150	&& SBBidiTypeIsNumberSeparator(type)	2,592,993✔
151	&& SBBidiTypeIsNumber(w4PriorType)	218,045✔
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,757,304✔
160
161	/* Rule W5 */
162	if (type == SBBidiTypeET && (w5PriorType == SBBidiTypeEN \|\| nextType == SBBidiTypeEN)) {	2,757,304✔
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,757,304✔
168
169	switch (type) {	2,757,304✔
170	/* Rule W6 */
171	case SBBidiTypeET:	344,043✔
172	case SBBidiTypeCS:
173	case SBBidiTypeES:
174	BidiChainSetType(chain, link, SBBidiTypeON);	344,043✔
175	break;	344,043✔
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,406✔
184	if (w7StrongType == SBBidiTypeL) {	121,406✔
185	BidiChainSetType(chain, link, SBBidiTypeL);	72,374✔
186	}
187	break;	121,406✔
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:	790,412✔
198	case SBBidiTypeR:
199	w7StrongType = type;	790,412✔
200	break;	790,412✔
201	}
202
203	if (type != SBBidiTypeON && BidiChainGetType(chain, priorLink) == type) {	2,757,304✔
204	BidiChainAbsorbNext(chain, priorLink);	19,269✔
205	} else {
206	priorLink = link;	2,738,035✔
207	}
208	}
209
210	return priorLink;	1,257,381✔
211	}
212
213	static SBBoolean ResolveBrackets(IsolatingRunRef isolatingRun)	1,257,381✔
214	{
215	const SBCodepointSequence *sequence = isolatingRun->codepointSequence;	1,257,381✔
216	SBUInteger paragraphOffset = isolatingRun->paragraphOffset;	1,257,381✔
217	BracketQueueRef queue = &isolatingRun->_bracketQueue;	1,257,381✔
218	BidiChainRef chain = isolatingRun->bidiChain;	1,257,381✔
219	BidiLink roller = chain->roller;	1,257,381✔
220	BidiLink link;
221
222	BidiLink priorStrongLink;
223	SBLevel runLevel;
224
225	priorStrongLink = BidiLinkNone;	1,257,381✔
226	runLevel = isolatingRun->baseLevelRun->level;	1,257,381✔
227
228	BracketQueueReset(queue, SBLevelAsNormalBidiType(runLevel));	1,257,381✔
229
230	BidiChainForEach(chain, roller, link) {	3,995,350✔
231	SBUInteger stringIndex;	2,737,970✔
232	SBCodepoint codepoint;
233	SBBidiType type;
234
235	SBCodepoint bracketValue;
236	BracketType bracketType;	2,737,970✔
237
238	type = BidiChainGetType(chain, link);	2,737,970✔
239
240	switch (type) {	2,737,970✔
241	case SBBidiTypeON:	965,035✔
242	stringIndex = BidiChainGetOffset(chain, link) + paragraphOffset;	965,035✔
243	codepoint = SBCodepointSequenceGetCodepointAt(sequence, &stringIndex);	965,035✔
244	bracketValue = LookupBracketPair(codepoint, &bracketType);	965,035✔
245
246	switch (bracketType) {	965,035✔
247	case BracketTypeOpen:	329,480✔
248	if (BracketQueueGetOpenPairCount(queue) >= BracketQueueMaxOpenPairs) {	329,480✔
249	/* Stop further processing. */
250	return SBTrue;	1✔
251	}
252	if (!BracketQueueEnqueue(queue, priorStrongLink, link, bracketValue)) {	329,479✔
UNCOV 253	return SBFalse;	×
254	}
255	break;	329,479✔
256
257	case BracketTypeClose:	170,154✔
258	BracketQueueClosePair(queue, link, codepoint);	170,154✔
259	break;	170,154✔
260	}
261	break;	965,034✔
262
263	case SBBidiTypeEN:	168,901✔
264	case SBBidiTypeAN:
265	type = SBBidiTypeR;	168,901✔
266
267	case SBBidiTypeR:	1,016,845✔
268	case SBBidiTypeL:
269	BracketQueueAssignInnerStrongType(queue, type);	1,016,845✔
270	priorStrongLink = link;	1,016,845✔
271	break;	1,016,845✔
272	}
273	}
274
275	BracketQueueMarkPopulated(queue);	1,257,380✔
276	ResolveAvailableBracketPairs(isolatingRun);	1,257,380✔
277
278	return SBTrue;	1,257,380✔
279	}
280
281	static void ResolveAvailableBracketPairs(IsolatingRunRef isolatingRun)	1,257,380✔
282	{
283	BracketQueueRef queue = &isolatingRun->_bracketQueue;	1,257,380✔
284	BidiChainRef chain = isolatingRun->bidiChain;	1,257,380✔
285
286	SBLevel runLevel;
287	SBBidiType embeddingDirection;
288	SBBidiType oppositeDirection;
289
290	runLevel = isolatingRun->baseLevelRun->level;	1,257,380✔
291	embeddingDirection = SBLevelAsNormalBidiType(runLevel);	1,257,380✔
292	oppositeDirection = SBLevelAsOppositeBidiType(runLevel);	1,257,380✔
293
294	while (queue->pairCount > 0) {	1,397,107✔
295	BidiLink openingLink = BracketQueueGetOpeningLink(queue);	139,727✔
296	BidiLink closingLink = BracketQueueGetClosingLink(queue);	139,727✔
297	SBBidiType innerStrongType = BracketQueueGetInnerStrongType(queue);	139,727✔
298	SBBidiType pairType;
299
300	/* Rule: N0.b */
301	if (innerStrongType == embeddingDirection) {	139,727✔
302	pairType = innerStrongType;	52,931✔
303	}
304	/* Rule: N0.c */
305	else if (innerStrongType == oppositeDirection) {	86,796✔
306	BidiLink priorStrongLink;
307	SBBidiType priorStrongType;
308
309	priorStrongLink = BracketQueueGetPriorStrongLink(queue);	28,868✔
310
311	if (priorStrongLink != BidiLinkNone) {	28,868✔
312	BidiLink link;
313
314	priorStrongType = BidiChainGetType(chain, priorStrongLink);	16,580✔
315	if (SBBidiTypeIsNumber(priorStrongType)) {	16,580✔
316	priorStrongType = SBBidiTypeR;	22✔
317	}
318
319	link = BidiChainGetNext(chain, priorStrongLink);	16,580✔
320
321	/*
322	* Iterate over in-between links to find the proper prior strong type because there
323	* might be resolved brackets with different strong types.
324	*/
325	while (link != openingLink) {	30,745✔
326	SBBidiType type = BidiChainGetType(chain, link);	14,165✔
327	if (type == SBBidiTypeL \|\| type == SBBidiTypeR) {	14,165✔
328	priorStrongType = type;	6,258✔
329	}
330
331	link = BidiChainGetNext(chain, link);	14,165✔
332	}
333	} else {
334	priorStrongType = isolatingRun->_sos;	12,288✔
335	}
336
337	/* Rule: N0.c.1 */
338	if (priorStrongType == oppositeDirection) {	28,868✔
339	pairType = oppositeDirection;	7,780✔
340	}
341	/* Rule: N0.c.2 */
342	else {
343	pairType = embeddingDirection;	21,088✔
344	}
345	}
346	/* Rule: N0.d */
347	else {
348	pairType = SBBidiTypeNil;	57,928✔
349	}
350
351	if (pairType != SBBidiTypeNil) {	139,727✔
352	/* Do the substitution */
353	BidiChainSetType(chain, openingLink, pairType);	81,799✔
354	BidiChainSetType(chain, closingLink, pairType);	81,799✔
355	}
356
357	BracketQueueDequeue(queue);	139,727✔
358	}
359	}	1,257,380✔
360
361	static void ResolveNeutrals(IsolatingRunRef isolatingRun)	1,257,381✔
362	{
363	BidiChainRef chain = isolatingRun->bidiChain;	1,257,381✔
364	BidiLink roller = chain->roller;	1,257,381✔
365	BidiLink link;
366
367	SBLevel runLevel;
368	SBBidiType strongType;
369	BidiLink neutralLink;
370
371	runLevel = isolatingRun->baseLevelRun->level;	1,257,381✔
372	strongType = isolatingRun->_sos;	1,257,381✔
373	neutralLink = BidiLinkNone;	1,257,381✔
374
375	BidiChainForEach(chain, roller, link) {	3,995,416✔
376	SBBidiType type = BidiChainGetType(chain, link);	2,738,035✔
377	SBBidiType nextType;
378
379	SBAssert(SBBidiTypeIsStrongOrNumber(type) \|\| SBBidiTypeIsNeutralOrIsolate(type));	2,738,035✔
380
381	switch (type) {	2,738,035✔
382	case SBBidiTypeL:	493,412✔
383	strongType = SBBidiTypeL;	493,412✔
384	break;	493,412✔
385
386	case SBBidiTypeR:	687,032✔
387	case SBBidiTypeEN:
388	case SBBidiTypeAN:
389	strongType = SBBidiTypeR;	687,032✔
390	break;	687,032✔
391
392	case SBBidiTypeB:	1,557,591✔
393	case SBBidiTypeS:
394	case SBBidiTypeWS:
395	case SBBidiTypeON:
396	case SBBidiTypeLRI:
397	case SBBidiTypeRLI:
398	case SBBidiTypeFSI:
399	case SBBidiTypePDI:
400	if (neutralLink == BidiLinkNone) {	1,557,591✔
401	neutralLink = link;	1,071,773✔
402	}
403
404	nextType = BidiChainGetType(chain, BidiChainGetNext(chain, link));	1,557,591✔
405	if (SBBidiTypeIsNumber(nextType)) {	1,557,591✔
406	nextType = SBBidiTypeR;	44,682✔
407	} else if (nextType == SBBidiTypeNil) {	1,512,909✔
408	nextType = isolatingRun->_eos;	768,486✔
409	}
410
411	if (SBBidiTypeIsStrong(nextType)) {	1,557,591✔
412	/* Rules N1, N2 */
413	SBBidiType resolvedType = (strongType == nextType	1,305,969✔
414	? strongType
415	: SBLevelAsNormalBidiType(runLevel));	234,196✔
416
417	do {
418	BidiChainSetType(chain, neutralLink, resolvedType);	1,557,591✔
419	neutralLink = BidiChainGetNext(chain, neutralLink);	1,557,591✔
420	} while (neutralLink != BidiChainGetNext(chain, link));	1,557,591✔
421
422	neutralLink = BidiLinkNone;	1,071,773✔
423	}
424	break;	1,557,591✔
425	}
426	}
427	}	1,257,381✔
428
429	static void ResolveImplicitLevels(IsolatingRunRef isolatingRun)	1,257,381✔
430	{
431	BidiChainRef chain = isolatingRun->bidiChain;	1,257,381✔
432	BidiLink roller = chain->roller;	1,257,381✔
433	BidiLink link;
434
435	SBLevel runLevel = isolatingRun->baseLevelRun->level;	1,257,381✔
436
437	if ((runLevel & 1) == 0) {	1,257,381✔
438	BidiChainForEach(chain, roller, link) {	2,199,673✔
439	SBBidiType type = BidiChainGetType(chain, link);	1,492,976✔
440	SBLevel level = BidiChainGetLevel(chain, link);	1,492,976✔
441
442	SBAssert(SBBidiTypeIsStrongOrNumber(type));	1,492,976✔
443
444	/* Rule I1 */
445	if (type == SBBidiTypeR) {	1,492,976✔
446	BidiChainSetLevel(chain, link, level + 1);	167,991✔
447	} else if (type != SBBidiTypeL) {	1,324,985✔
448	BidiChainSetLevel(chain, link, level + 2);	72,823✔
449	}
450	}
451	} else {
452	BidiChainForEach(chain, roller, link) {	1,795,743✔
453	SBBidiType type = BidiChainGetType(chain, link);	1,245,059✔
454	SBLevel level = BidiChainGetLevel(chain, link);	1,245,059✔
455
456	SBAssert(SBBidiTypeIsStrongOrNumber(type));	1,245,059✔
457
458	/* Rule I2 */
459	if (type != SBBidiTypeR) {	1,245,059✔
460	BidiChainSetLevel(chain, link, level + 1);	223,071✔
461	}
462	}
463	}
464	}	1,257,381✔
465
466	SB_INTERNAL void IsolatingRunInitialize(IsolatingRunRef isolatingRun, MemoryRef memory)	862,281✔
467	{
468	BracketQueueInitialize(&isolatingRun->_bracketQueue, memory);	862,281✔
469	}	862,281✔
470
471	SB_INTERNAL SBBoolean IsolatingRunResolve(IsolatingRunRef isolatingRun)	1,257,381✔
472	{
473	BidiLink lastLink;
474	BidiLink subsequentLink;
475
476	SB_LOG_BLOCK_OPENER("Identified Isolating Run");
477
478	/* Attach level run links to form isolating run. */
479	AttachLevelRunLinks(isolatingRun);	1,257,381✔
480	/* Save last subsequent link. */
481	subsequentLink = isolatingRun->_lastLevelRun->subsequentLink;	1,257,381✔
482
483	SB_LOG_STATEMENT("Range", 1, SB_LOG_RUN_RANGE(isolatingRun));
484	SB_LOG_STATEMENT("Types", 1, SB_LOG_RUN_TYPES(isolatingRun));
485	SB_LOG_STATEMENT("Level", 1, SB_LOG_LEVEL(isolatingRun->baseLevelRun->level));
486	SB_LOG_STATEMENT("SOS", 1, SB_LOG_BIDI_TYPE(isolatingRun->_sos));
487	SB_LOG_STATEMENT("EOS", 1, SB_LOG_BIDI_TYPE(isolatingRun->_eos));
488
489	/* Rules W1-W7 */
490	lastLink = ResolveWeakTypes(isolatingRun);	1,257,381✔
491	SB_LOG_BLOCK_OPENER("Resolved Weak Types");
492	SB_LOG_STATEMENT("Types", 1, SB_LOG_RUN_TYPES(isolatingRun));
493	SB_LOG_BLOCK_CLOSER();
494
495	/* Rule N0 */
496	if (!ResolveBrackets(isolatingRun)) {	1,257,381✔
UNCOV 497	return SBFalse;	×
498	}
499
500	SB_LOG_BLOCK_OPENER("Resolved Brackets");
501	SB_LOG_STATEMENT("Types", 1, SB_LOG_RUN_TYPES(isolatingRun));
502	SB_LOG_BLOCK_CLOSER();
503
504	/* Rules N1, N2 */
505	ResolveNeutrals(isolatingRun);	1,257,381✔
506	SB_LOG_BLOCK_OPENER("Resolved Neutrals");
507	SB_LOG_STATEMENT("Types", 1, SB_LOG_RUN_TYPES(isolatingRun));
508	SB_LOG_BLOCK_CLOSER();
509
510	/* Rules I1, I2 */
511	ResolveImplicitLevels(isolatingRun);	1,257,381✔
512	SB_LOG_BLOCK_OPENER("Resolved Implicit Levels");
513	SB_LOG_STATEMENT("Levels", 1, SB_LOG_RUN_LEVELS(isolatingRun));
514	SB_LOG_BLOCK_CLOSER();
515
516	/* Re-attach original links. */
517	AttachOriginalLinks(isolatingRun);	1,257,381✔
518	/* Attach new final link (of isolating run) with last subsequent link. */
519	BidiChainSetNext(isolatingRun->bidiChain, lastLink, subsequentLink);	1,257,381✔
520
521	SB_LOG_BLOCK_CLOSER();
522
523	return SBTrue;	1,257,381✔
524	}

Tehreer / SheenBidi / 19308576644

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