1763

Committed 01 Apr 2026 03:04PM UTC coverage: 82.698% (+0.3%) from 82.407%

Build # 1763

Build Type

push

travis-ci

Committed by

thoni56

Commit Message

[tests][flaky] One test captured logging output which contained source line references

Coverage Stats

15658 of 18934 relevant lines covered (82.7%)

15517812.5 hits per line

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

95.74

src/referenceableitemtable.c

#include <string.h>

#include "head.h"
#include "referenceableitem.h"

#define IN_REFTAB_C
#include "referenceableitemtable.h"

#include "memory.h"               /* For XX_ALLOCC */
#include "log.h"


static ReferenceableItemTable referenceableItemTable;

static bool equalReferenceableItems(ReferenceableItem *e1, ReferenceableItem *e2) {
    return e1->type==e2->type
        && e1->storage==e2->storage
        && e1->visibility==e2->visibility
        && e1->includeFileNumber==e2->includeFileNumber
        && strcmp(e1->linkName, e2->linkName)==0;
}


#define HASH_FUN(element) (hashFun(element->linkName) + (unsigned)element->includeFileNumber)
#define HASH_ELEM_EQUAL(e1,e2) equalReferenceableItems(e1, e2)

#include "hashlist.tc"


void initReferenceableItemTable(int size) {
    // We want this in cx_memory, so can't use refTabInit() b.c it allocates in StackMemory
    referenceableItemTable.tab = cxAlloc(size*sizeof(ReferenceableItem *));
    referenceableItemTableNoAllocInit(&referenceableItemTable, size);
}

ReferenceableItem *getReferenceableItem(int index) {
    assert(index < referenceableItemTable.size);
    assert(referenceableItemTable.tab[index]);
    return referenceableItemTable.tab[index];
}

int getNextExistingReferenceableItem(int index) {
    for (int i=index; i < referenceableItemTable.size; i++)
        if (referenceableItemTable.tab[i] != NULL)
            return i;
    return -1;
}

int addToReferenceableItemTable(ReferenceableItem *referenceableItem) {
    return referenceableItemTableAdd(&referenceableItemTable, referenceableItem);
}

void pushReferenceableItem(ReferenceableItem *element, int offset) {
    referenceableItemTablePush(&referenceableItemTable, element, offset);
}

bool isMemberInReferenceableItemTable(ReferenceableItem *element, int *offsetP,
                                      ReferenceableItem **foundMemberPointer) {
    return referenceableItemTableIsMember(&referenceableItemTable, element, offsetP,
                                          foundMemberPointer);
}

void mapOverReferenceableItemTable(void (*fun)(ReferenceableItem *)) {
    ENTER();
    referenceableItemTableMap(&referenceableItemTable, fun);
    LEAVE();
}

void mapOverReferenceableItemTableWithPointer(void (*fun)(ReferenceableItem *, void *),
                                              void *pointer) {
    referenceableItemTableMapWithPointer(&referenceableItemTable, fun, pointer);
}

void mapOverReferenceableItemTableWithIndex(void (*fun)(int index)) {
    referenceableItemTableMapWithIndex(&referenceableItemTable, fun);
}

void removeReferenceableItemsForFile(int fileNumber) {
    log_trace("removing all references for file number %d", fileNumber);

    for (int i = 0; i < referenceableItemTable.size; i++) {
        ReferenceableItem *item = referenceableItemTable.tab[i];
        if (item == NULL)
            continue;

        /* Remove references matching fileNumber from this item's reference list */
        Reference **refP = &(item->references);
        while (*refP != NULL) {
            if ((*refP)->position.file == fileNumber) {
                log_trace("removing reference to %s at %d:%d", item->linkName,
                         (*refP)->position.line, (*refP)->position.col);
                *refP = (*refP)->next;  /* Unlink this reference */
            } else {
                refP = &((*refP)->next);  /* Move to next */
            }
        }
    }
}

1	#include <string.h>
2
3	#include "head.h"
4	#include "referenceableitem.h"
5
6	#define IN_REFTAB_C
7	#include "referenceableitemtable.h"
8
9	#include "memory.h" /* For XX_ALLOCC */
10	#include "log.h"
11
12
13	static ReferenceableItemTable referenceableItemTable;
14
15	static bool equalReferenceableItems(ReferenceableItem e1, ReferenceableItem e2) {	240,924,781✔
16	return e1->type==e2->type	240,924,781✔
17	&& e1->storage==e2->storage	134,117,711✔
18	&& e1->visibility==e2->visibility	95,928,655✔
19	&& e1->includeFileNumber==e2->includeFileNumber	95,928,655✔
20	&& strcmp(e1->linkName, e2->linkName)==0;	375,042,492✔
21	}
22
23
24	#define HASH_FUN(element) (hashFun(element->linkName) + (unsigned)element->includeFileNumber)
25	#define HASH_ELEM_EQUAL(e1,e2) equalReferenceableItems(e1, e2)
26
27	#include "hashlist.tc"
28
29
30	void initReferenceableItemTable(int size) {	224✔
31	// We want this in cx_memory, so can't use refTabInit() b.c it allocates in StackMemory
32	referenceableItemTable.tab = cxAlloc(sizesizeof(ReferenceableItem ));	224✔
33	referenceableItemTableNoAllocInit(&referenceableItemTable, size);	224✔
34	}	224✔
35
36	ReferenceableItem *getReferenceableItem(int index) {	1,890,496✔
37	assert(index < referenceableItemTable.size);	1,890,496✔
38	assert(referenceableItemTable.tab[index]);
39	return referenceableItemTable.tab[index];
40	}	1,892,258✔
41		115,394,224✔
42	int getNextExistingReferenceableItem(int index) {	115,392,462✔
43	for (int i=index; i < referenceableItemTable.size; i++)	1,890,496✔
44	if (referenceableItemTable.tab[i] != NULL)	1,762✔
45	return i;
46	return -1;
47	}	3,335✔
48		3,335✔
49	int addToReferenceableItemTable(ReferenceableItem *referenceableItem) {
50	return referenceableItemTableAdd(&referenceableItemTable, referenceableItem);
51	}	378,688✔
52		378,688✔
53	void pushReferenceableItem(ReferenceableItem *element, int offset) {	378,688✔
54	referenceableItemTablePush(&referenceableItemTable, element, offset);
55	}	109,471,291✔
56
57	bool isMemberInReferenceableItemTable(ReferenceableItem element, int offsetP,	109,471,291✔
58	ReferenceableItem **foundMemberPointer) {
59	return referenceableItemTableIsMember(&referenceableItemTable, element, offsetP,
60	foundMemberPointer);
61	}	258✔
62		258✔
63	void mapOverReferenceableItemTable(void (fun)(ReferenceableItem )) {	258✔
64	ENTER();	258✔
65	referenceableItemTableMap(&referenceableItemTable, fun);	258✔
66	LEAVE();
67	}	16✔
68
69	void mapOverReferenceableItemTableWithPointer(void (fun)(ReferenceableItem , void *),	16✔
70	void *pointer) {	16✔
71	referenceableItemTableMapWithPointer(&referenceableItemTable, fun, pointer);
72	}	×
73		×
74	void mapOverReferenceableItemTableWithIndex(void (*fun)(int index)) {
75	referenceableItemTableMapWithIndex(&referenceableItemTable, fun);
76	}	1,256✔
77		1,256✔
78	void removeReferenceableItemsForFile(int fileNumber) {
79	log_trace("removing all references for file number %d", fileNumber);	82,314,472✔
80		82,313,216✔
81	for (int i = 0; i < referenceableItemTable.size; i++) {	82,313,216✔
82	ReferenceableItem *item = referenceableItemTable.tab[i];	80,984,417✔
83	if (item == NULL)
84	continue;
85		1,328,799✔
86	/* Remove references matching fileNumber from this item's reference list */	3,756,427✔
87	Reference **refP = &(item->references);	2,427,628✔
88	while (*refP != NULL) {	102,025✔
89	if ((*refP)->position.file == fileNumber) {
90	log_trace("removing reference to %s at %d:%d", item->linkName,	102,025✔
91	(refP)->position.line, (refP)->position.col);
92	refP = (refP)->next; /* Unlink this reference */	2,325,603✔
93	} else {
94	refP = &((refP)->next); / Move to next */
95	}
96	}	1,256✔
97	}
98	}

thoni56 / c-xrefactory / 1763

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