1696

Committed 05 Jan 2026 06:04PM UTC coverage: 84.597% (+0.3%) from 84.284%

Build # 1696

Build Type

push

travis-ci

Committed by

thoni56

Commit Message

[tests][lsp] Strip Content-Length as they might differ between systems

Run Details

13945 of 16484 relevant lines covered (84.6%)

17448328.82 hits per line

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

91.84

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

void setReferenceableItem(int index, ReferenceableItem *item) {
    referenceableItemTable.tab[index] = item;
}

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) {	234,010,228✔
16	return e1->type==e2->type	234,010,228✔
17	&& e1->storage==e2->storage	130,294,142✔
18	&& e1->visibility==e2->visibility	92,155,512✔
19	&& e1->includeFileNumber==e2->includeFileNumber	92,155,512✔
20	&& strcmp(e1->linkName, e2->linkName)==0;	364,304,370✔
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) {	232✔
31	// We want this in cx_memory, so can't use refTabInit() b.c it allocates in StackMemory
32	referenceableItemTable.tab = cxAlloc(sizesizeof(ReferenceableItem ));	232✔
33	referenceableItemTableNoAllocInit(&referenceableItemTable, size);	232✔
34	}	232✔
35
36	ReferenceableItem *getReferenceableItem(int index) {	1,358,297✔
37	assert(index < referenceableItemTable.size);	1,358,297✔
38	assert(referenceableItemTable.tab[index]);
39	return referenceableItemTable.tab[index];
40	}	1,359,169✔
41		57,132,844✔
42	int getNextExistingReferenceableItem(int index) {	57,131,972✔
43	for (int i=index; i < referenceableItemTable.size; i++)	1,358,297✔
44	if (referenceableItemTable.tab[i] != NULL)	872✔
45	return i;
46	return -1;
47	}	163✔
48		163✔
49	int addToReferenceableItemTable(ReferenceableItem *referenceableItem) {
50	return referenceableItemTableAdd(&referenceableItemTable, referenceableItem);
51	}	356,440✔
52		356,440✔
53	void pushReferenceableItem(ReferenceableItem *element, int offset) {	356,440✔
54	referenceableItemTablePush(&referenceableItemTable, element, offset);
55	}	×
56		×
57	void setReferenceableItem(int index, ReferenceableItem *item) {
58	referenceableItemTable.tab[index] = item;
59	}	106,030,768✔
60
61	bool isMemberInReferenceableItemTable(ReferenceableItem element, int offsetP,	106,030,768✔
62	ReferenceableItem **foundMemberPointer) {
63	return referenceableItemTableIsMember(&referenceableItemTable, element, offsetP,
64	foundMemberPointer);
65	}	193✔
66		193✔
67	void mapOverReferenceableItemTable(void (fun)(ReferenceableItem )) {	193✔
68	ENTER();	193✔
69	referenceableItemTableMap(&referenceableItemTable, fun);	193✔
70	LEAVE();
71	}	14✔
72
73	void mapOverReferenceableItemTableWithPointer(void (fun)(ReferenceableItem , void *),	14✔
74	void *pointer) {	14✔
75	referenceableItemTableMapWithPointer(&referenceableItemTable, fun, pointer);
76	}	×
77		×
78	void mapOverReferenceableItemTableWithIndex(void (*fun)(int index)) {
79	referenceableItemTableMapWithIndex(&referenceableItemTable, fun);
80	}	6✔
81		6✔
82	void removeReferenceableItemsForFile(int fileNumber) {
83	log_trace("removing all references for file number %d", fileNumber);	393,222✔
84		393,216✔
85	for (int i = 0; i < referenceableItemTable.size; i++) {	393,216✔
86	ReferenceableItem *item = referenceableItemTable.tab[i];	391,093✔
87	if (item == NULL)
88	continue;
89		2,123✔
90	/* Remove references matching fileNumber from this item's reference list */	6,960✔
91	Reference **refP = &(item->references);	4,837✔
92	while (*refP != NULL) {	33✔
93	if ((*refP)->position.file == fileNumber) {
94	log_trace("removing reference to %s at %d:%d", item->linkName,	33✔
95	(refP)->position.line, (refP)->position.col);
96	refP = (refP)->next; /* Unlink this reference */	4,804✔
97	} else {
98	refP = &((refP)->next); / Move to next */
99	}
100	}	6✔
101	}
102	}

thoni56 / c-xrefactory / 1696

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