1598

Committed 08 Oct 2025 10:56AM UTC coverage: 25.401% (-54.8%) from 80.177%

Build # 1598

Build Type

push

travis-ci

Committed by

thoni56

Commit Message

Add llvm-cov to gcov conversion for Emacs cov-mode support

- Create llvm2gcov.sh script to convert Apple coverage to traditional format
- Parse llvm-cov show output and transform to gcov-compatible format
- Handle count formats including 'k' suffix (4.18k -> 4180)
- Generate proper gcov headers for Emacs compatibility
- Integrate conversion into Darwin gcov target
- Preserve full Emacs fringe coverage display functionality

Now Darwin users get both:
- Superior Apple coverage accuracy
- Full Emacs cov-mode integration

Run Details

4019 of 15822 relevant lines covered (25.4%)

3416.81 hits per line

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

8.7

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 "misc.h"
#include "options.h"
#include "type.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 resetReferenceUsage(Reference *reference,  Usage usage) {
    if (reference != NULL && reference->usage > usage) {
        reference->usage = usage;
    }
}

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

    SORTED_LIST_PLACE2(place, reference, list);
    if (*place==NULL || SORTED_LIST_NEQ((*place),reference)
        || options.serverOperation==OLO_EXTRACT) {
        Reference *r = cxAlloc(sizeof(Reference));
        *r = makeReference(pos, 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 *addReferenceWithoutUsageCheck(Reference **listP, Reference *ref) {
    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_trace("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 **listP, Reference *ref) {
    log_trace("checking ref %s %s:%d:%d at %d", usageKindEnumName[ref->usage],
              simpleFileName(getFileItemWithFileNumber(ref->position.file)->name), ref->position.line, ref->position.col, ref);
    if (!isVisibleUsage(ref->usage))
        return NULL; // no regular on-line refs
    return addReferenceWithoutUsageCheck(listP, ref);
}

ReferenceItem makeReferenceItem(char *name, Type type, Storage storage, Scope scope,
                                Visibility visibility, int includedFileNumber) {
    ReferenceItem item;

    item.linkName = name;
    item.type = type;
    item.storage = storage;
    item.scope = scope;
    item.visibility = visibility;
    if (includedFileNumber != NO_FILE_NUMBER)
        assert(type == TypeCppInclude);
    item.includedFileNumber = includedFileNumber;

    item.references = NULL;
    item.next = NULL;

    return item;
}

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 "misc.h"
11	#include "options.h"
12	#include "type.h"
13	#include "usage.h"
14
15
16	Reference newReference(Position position, Usage usage, Reference next) {	1✔
17	Reference *reference = malloc(sizeof(Reference));	1✔
18	reference->usage = usage;	1✔
19	reference->position = position;	1✔
20	reference->next = next;	1✔
21	return reference;	1✔
22	}
23
24	Reference makeReference(Position position, Usage usage, Reference *next) {	×
25	Reference reference;
26	reference.usage = usage;	×
27	reference.position = position;	×
28	reference.next = next;	×
29	return reference;	×
30	}
31
32	Reference duplicateReferenceInCxMemory(Reference original) {	×
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;	×
36	Reference *copy = cxAlloc(sizeof(Reference));	×
37	copy = original;	×
38	original->next = copy;	×
39	return copy;	×
40	}
41
42	void freeReferences(Reference *references) {	×
43	while (references != NULL) {	×
44	Reference *next = references->next;	×
45	free(references);	×
46	references = next;	×
47	}
48	}
49
50	void resetReferenceUsage(Reference *reference, Usage usage) {	×
51	if (reference != NULL && reference->usage > usage) {	×
52	reference->usage = usage;	×
53	}
54	}
55
56	Reference addToReferenceList(Reference list,	×
57	Position pos, Usage usage) {
58	Reference **place;
59	Reference reference = makeReference(pos, usage, NULL);	×
60
61	SORTED_LIST_PLACE2(place, reference, list);	×
62	if (place==NULL \|\| SORTED_LIST_NEQ((place),reference)	×
63	\|\| options.serverOperation==OLO_EXTRACT) {	×
64	Reference *r = cxAlloc(sizeof(Reference));	×
65	*r = makeReference(pos, usage, NULL);	×
66	LIST_CONS(r, (*place));	×
67	} else {
68	assert(*place);	×
69	(*place)->usage = usage;	×
70	}
71	return place;	×
72	}
73
74	bool isReferenceInList(Reference reference, Reference list) {	×
75	Reference *place;
76	SORTED_LIST_FIND2(place,Reference, (*reference),list);	×
77	if (place==NULL \|\| SORTED_LIST_NEQ(place, *reference))	×
78	return false;	×
79	return true;	×
80	}
81
82	static Reference addReferenceWithoutUsageCheck(Reference listP, Reference ref) {	×
83	Reference **placeInList;
84	Reference *r = NULL;	×
85
86	SORTED_LIST_PLACE2(placeInList, *ref, listP);	×
87	if (placeInList==NULL \|\| SORTED_LIST_NEQ(placeInList, *ref)) {	×
88	r = malloc(sizeof(Reference));	×
89	r = ref;	×
90	LIST_CONS(r, *placeInList);	×
91	log_trace("olcx adding %s %s:%d:%d", usageKindEnumName[ref->usage],	×
92	getFileItemWithFileNumber(ref->position.file)->name, ref->position.line,ref->position.col);
93	}
94	return r;	×
95	}
96
97
98	Reference addReferenceToList(Reference listP, Reference ref) {	×
99	log_trace("checking ref %s %s:%d:%d at %d", usageKindEnumName[ref->usage],	×
100	simpleFileName(getFileItemWithFileNumber(ref->position.file)->name), ref->position.line, ref->position.col, ref);
101	if (!isVisibleUsage(ref->usage))	×
102	return NULL; // no regular on-line refs	×
103	return addReferenceWithoutUsageCheck(listP, ref);	×
104	}
105
106	ReferenceItem makeReferenceItem(char *name, Type type, Storage storage, Scope scope,	×
107	Visibility visibility, int includedFileNumber) {
108	ReferenceItem item;
109
110	item.linkName = name;	×
111	item.type = type;	×
112	item.storage = storage;	×
113	item.scope = scope;	×
114	item.visibility = visibility;	×
115	if (includedFileNumber != NO_FILE_NUMBER)	×
116	assert(type == TypeCppInclude);	×
117	item.includedFileNumber = includedFileNumber;	×
118
119	item.references = NULL;	×
120	item.next = NULL;	×
121
122	return item;	×
123	}
124
125	int fileNumberOfReference(Reference reference) {	×
126	return reference.position.file;	×
127	}

thoni56 / c-xrefactory / 1598

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