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

98.28

src/reference.c

#include "reference.h"

#include <stdio.h>
#include <stdlib.h>

#include "commons.h"
#include "filetable.h"
#include "list.h"
#include "log.h"
#include "memory.h"
#include "misc.h"
#include "parsing.h"
#include "usage.h"


Reference *newReference(Position position, Usage usage, Reference *next) {
    Reference *reference = malloc(sizeof(Reference));
    reference->usage = usage;
    reference->position = position;
    reference->next = next;
    return reference;
}

Reference makeReference(Position position, Usage usage, Reference *next) {
    Reference reference;
    reference.usage = usage;
    reference.position = position;
    reference.next = next;
    return reference;
}

Reference *duplicateReferenceInCxMemory(Reference *original) {
    // this is used in extract x=x+2; to re-arrange order of references
    // i.e. usage must be first, lValue second.
    original->usage = UsageNone;
    Reference *copy = cxAlloc(sizeof(Reference));
    *copy = *original;
    original->next = copy;
    return copy;
}

void freeReferences(Reference *references) {
    while (references != NULL) {
        Reference *next = references->next;
        free(references);
        references = next;
    }
}

void setReferenceUsage(Reference *reference,  Usage usage) {
    if (reference != NULL && isLessImportantUsageThan(reference->usage, usage)) {
        reference->usage = usage;
    }
}

Reference **addToReferenceList(Reference **list,
                               Position position, Usage usage) {
    Reference **place;
    Reference reference = makeReference(position, usage, NULL);

    SORTED_LIST_PLACE2(place, reference, list);
    if (*place==NULL || SORTED_LIST_NEQ((*place),reference)
        || allowsDuplicateReferences(parsingConfig.operation)) {
        Reference *r = cxAlloc(sizeof(Reference));
        *r = makeReference(position, usage, NULL);
        LIST_CONS(r, (*place));
    } else {
        assert(*place);
        (*place)->usage = usage;
    }
    return place;
}

bool isReferenceInList(Reference *reference, Reference *list) {
    Reference *place;
    SORTED_LIST_FIND2(place,Reference, (*reference),list);
    if (place==NULL || SORTED_LIST_NEQ(place, *reference))
        return false;
    return true;
}

static Reference *addReferenceToListWithoutUsageCheck(Reference *ref, Reference **listP) {
    Reference **placeInList;
    Reference *r = NULL;

    SORTED_LIST_PLACE2(placeInList, *ref, listP);
    if (*placeInList==NULL || SORTED_LIST_NEQ(*placeInList, *ref)) {
        r = malloc(sizeof(Reference));
        *r = *ref;
        LIST_CONS(r, *placeInList);
        log_debug("olcx adding %s %s:%d:%d", usageKindEnumName[ref->usage],
                  getFileItemWithFileNumber(ref->position.file)->name, ref->position.line,ref->position.col);
    }
    return r;
}


Reference *addReferenceToList(Reference *reference, Reference **listP) {
    log_debug("checking ref %s %s:%d:%d at %d", usageKindEnumName[reference->usage],
              simpleFileName(getFileItemWithFileNumber(reference->position.file)->name),
              reference->position.line, reference->position.col, reference);
    if (!isVisibleUsage(reference->usage))
        return NULL; // no regular on-line refs
    return addReferenceToListWithoutUsageCheck(reference, listP);
}

int fileNumberOfReference(Reference reference) {
    return reference.position.file;
}

1	#include "reference.h"
2
3	#include <stdio.h>
4	#include <stdlib.h>
5
6	#include "commons.h"
7	#include "filetable.h"
8	#include "list.h"
9	#include "log.h"
10	#include "memory.h"
11	#include "misc.h"
12	#include "parsing.h"
13	#include "usage.h"
14
15
16	Reference newReference(Position position, Usage usage, Reference next) {	2✔
17	Reference *reference = malloc(sizeof(Reference));	2✔
18	reference->usage = usage;	2✔
19	reference->position = position;	2✔
20	reference->next = next;	2✔
21	return reference;	2✔
22	}
23
24	Reference makeReference(Position position, Usage usage, Reference *next) {	85,279,380✔
25	Reference reference;
26	reference.usage = usage;	85,279,380✔
27	reference.position = position;	85,279,380✔
28	reference.next = next;	85,279,380✔
29	return reference;	85,279,380✔
30	}
31
32	Reference duplicateReferenceInCxMemory(Reference original) {	378✔
33	// this is used in extract x=x+2; to re-arrange order of references
34	// i.e. usage must be first, lValue second.
35	original->usage = UsageNone;	378✔
36	Reference *copy = cxAlloc(sizeof(Reference));	378✔
37	copy = original;	378✔
38	original->next = copy;	378✔
39	return copy;	378✔
40	}
41
42	void freeReferences(Reference *references) {	263✔
43	while (references != NULL) {	632✔
44	Reference *next = references->next;	369✔
45	free(references);	369✔
46	references = next;	369✔
47	}
48	}	263✔
49
50	void setReferenceUsage(Reference *reference, Usage usage) {	621,703✔
51	if (reference != NULL && isLessImportantUsageThan(reference->usage, usage)) {	621,703✔
52	reference->usage = usage;	186,241✔
53	}
54	}	621,703✔
55
56	Reference addToReferenceList(Reference list,	82,388,520✔
57	Position position, Usage usage) {
58	Reference **place;
59	Reference reference = makeReference(position, usage, NULL);	82,388,520✔
60
61	SORTED_LIST_PLACE2(place, reference, list);	2,147,483,647✔
62	if (place==NULL \|\| SORTED_LIST_NEQ((place),reference)	82,388,520✔
63	\|\| allowsDuplicateReferences(parsingConfig.operation)) {	79,509,321✔
64	Reference *r = cxAlloc(sizeof(Reference));	2,885,553✔
65	*r = makeReference(position, usage, NULL);	2,885,553✔
66	LIST_CONS(r, (*place));	2,885,553✔
67	} else {
68	assert(*place);	79,502,967✔
69	(*place)->usage = usage;
70	}	82,388,520✔
71	return place;
72	}
73		132✔
74	bool isReferenceInList(Reference reference, Reference list) {
75	Reference *place;	317✔
76	SORTED_LIST_FIND2(place,Reference, (*reference),list);	132✔
77	if (place==NULL \|\| SORTED_LIST_NEQ(place, *reference))	131✔
78	return false;	1✔
79	return true;
80	}
81		1,092✔
82	static Reference addReferenceToListWithoutUsageCheck(Reference ref, Reference **listP) {
83	Reference **placeInList;	1,092✔
84	Reference *r = NULL;
85		2,173✔
86	SORTED_LIST_PLACE2(placeInList, *ref, listP);	1,092✔
87	if (placeInList==NULL \|\| SORTED_LIST_NEQ(placeInList, *ref)) {	960✔
88	r = malloc(sizeof(Reference));	960✔
89	r = ref;	960✔
90	LIST_CONS(r, *placeInList);	960✔
91	log_debug("olcx adding %s %s:%d:%d", usageKindEnumName[ref->usage],
92	getFileItemWithFileNumber(ref->position.file)->name, ref->position.line,ref->position.col);
93	}	1,092✔
94	return r;
95	}
96
97		1,092✔
98	Reference addReferenceToList(Reference reference, Reference **listP) {	1,092✔
99	log_debug("checking ref %s %s:%d:%d at %d", usageKindEnumName[reference->usage],
100	simpleFileName(getFileItemWithFileNumber(reference->position.file)->name),
101	reference->position.line, reference->position.col, reference);	1,092✔
102	if (!isVisibleUsage(reference->usage))	×
103	return NULL; // no regular on-line refs	1,092✔
104	return addReferenceToListWithoutUsageCheck(reference, listP);
105	}
106		6✔
107	int fileNumberOfReference(Reference reference) {	6✔
108	return reference.position.file;
109	}

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