1617

Committed 19 Nov 2025 11:56PM UTC coverage: 81.092% (+54.7%) from 26.404%

Build # 1617

Build Type

push

travis-ci

Committed by

thoni56

Commit Message

[tests] Trying to get C11 test more platform independent

The output is the references but they vary depending on the standard include design.

Run Details

12836 of 15829 relevant lines covered (81.09%)

1769773.98 hits per line

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

91.18

src/editorbuffer.c

#include "editorbuffer.h"

#include <string.h>
#include <stdlib.h>

#include "commons.h"
#include "editor.h"
#include "editorbuffertable.h"
#include "fileio.h"
#include "filetable.h"
#include "globals.h"
#include "log.h"
#include "memory.h"
#include "undo.h"


static void fillEmptyEditorBuffer(EditorBuffer *buffer, char *realFileName, int fileNumber, char *preLoadedFromFile) {
    buffer->allocation = (EditorBufferAllocationData){
        .bufferSize = 0, .text = NULL, .allocatedFreePrefixSize = 0,
        .allocatedBlock = NULL, .allocatedIndex = 0,
        .allocatedSize = 0};
    *buffer = (EditorBuffer){
        .fileName = realFileName, .fileNumber = fileNumber, .preLoadedFromFile = preLoadedFromFile,
        .markers = NULL, .allocation = buffer->allocation};
    buffer->modificationTime = 0;
    buffer->size = 0;
    buffer->textLoaded = false;
    assert(buffer->preLoadedFromFile == NULL || buffer->preLoadedFromFile != buffer->fileName);
}

EditorBuffer *newEditorBuffer(char *realFileName, int fileNumber, char *preLoadedFromFile, time_t modificationTime,
                              size_t size) {
    EditorBuffer *editorBuffer = malloc(sizeof(EditorBuffer));
    fillEmptyEditorBuffer(editorBuffer, realFileName, fileNumber, preLoadedFromFile);
    editorBuffer->modificationTime = modificationTime;
    editorBuffer->size = size;
    return editorBuffer;
}

EditorBuffer *createNewEditorBuffer(char *realFileName, char *preLoadedFromFile, time_t modificationTime,
                                    size_t size) {
    char *normalizedRealFileName = strdup(normalizeFileName_static(realFileName, cwd));

    assert(preLoadedFromFile == NULL || strcmp(realFileName, preLoadedFromFile) != 0);
    char *normalizedLoadedFromFile = NULL;
    if (preLoadedFromFile != NULL) {
        normalizedLoadedFromFile = normalizeFileName_static(preLoadedFromFile, cwd);
        normalizedLoadedFromFile = strdup(normalizedLoadedFromFile);
    }

    EditorBuffer *buffer = newEditorBuffer(normalizedRealFileName, 0, normalizedLoadedFromFile, modificationTime, size);
    log_trace("created buffer '%s'('%s')", buffer->fileName, buffer->preLoadedFromFile?buffer->preLoadedFromFile:"(null)");

    registerEditorBuffer(buffer);

    // set fileNumber last, because, addfiletabitem calls back the statb
    // from editor, so be tip-top at this moment!
    buffer->fileNumber = addFileNameToFileTable(normalizedRealFileName);

    return buffer;
}

static void checkForMagicMarker(EditorBufferAllocationData *allocation) {
    assert(allocation->allocatedBlock[allocation->allocatedSize] == 0x3b);
}

static void freeMarkersInEditorBuffer(EditorBuffer *buffer) {
    for (EditorMarker *marker = buffer->markers; marker != NULL;) {
        EditorMarker *next = marker->next;
        free(marker);
        marker = next;
    }
}

void freeEditorBuffer(EditorBuffer *buffer) {
    if (buffer == NULL)
        return;
    log_trace("freeing buffer %s==%s", buffer->fileName, buffer->preLoadedFromFile?buffer->preLoadedFromFile:"(null)");
    if (buffer->preLoadedFromFile != NULL) {
        free(buffer->preLoadedFromFile);
    }
    free(buffer->fileName);

    freeMarkersInEditorBuffer(buffer);

    if (buffer->textLoaded) {
        log_trace("freeing allocated block %d of size %d", buffer->allocation.allocatedBlock,
                  buffer->allocation.allocatedSize);
        checkForMagicMarker(&buffer->allocation);
        freeTextSpace(buffer->allocation.allocatedBlock,
                      buffer->allocation.allocatedIndex);
    }
    free(buffer);
}

EditorBuffer *getOpenedAndLoadedEditorBuffer(char *fileName) {
    EditorBuffer *buffer = getEditorBufferForFile(fileName);
    if (buffer!=NULL && buffer->textLoaded)
        return buffer;
    return NULL;
}

EditorBuffer *findOrCreateAndLoadEditorBufferForFile(char *fileName) {
    EditorBuffer *editorBuffer = getEditorBufferForFile(fileName);

    if (editorBuffer != NULL && editorBuffer->textLoaded)
        /* Found one with text loaded, return it */
        return editorBuffer;

    if (editorBuffer == NULL) {
        /* No buffer found, create one unless it is a directory */
        if (fileExists(fileName) && !isDirectory(fileName)) {
            editorBuffer = createNewEditorBuffer(fileName, NULL, fileModificationTime(fileName),
                                                 fileSize(fileName));
            loadFileIntoEditorBuffer(editorBuffer, fileModificationTime(fileName), fileSize(fileName));
        } else
            return NULL;
    }

    return editorBuffer;
}

// Only used from Options for preload
EditorBuffer *openEditorBufferFromPreload(char *fileName, char *preLoadedFromFile) {
    EditorBuffer  *buffer;

    buffer = getEditorBufferForFile(fileName);
    if (buffer != NULL) {
        return buffer;
    }
    buffer = createNewEditorBuffer(fileName, preLoadedFromFile, fileModificationTime(preLoadedFromFile),
                                   fileSize(preLoadedFromFile));
    return buffer;
}

char *getTextInEditorBuffer(EditorBuffer *buffer) {
    return buffer->allocation.text;
}

size_t getSizeOfEditorBuffer(EditorBuffer *buffer) {
    return buffer->allocation.bufferSize;
}

void setSizeOfEditorBuffer(EditorBuffer *buffer, size_t size) {
    buffer->allocation.bufferSize = size;
}

void setEditorBufferModified(EditorBuffer *buffer) {
    buffer->modified = true;
    buffer->modifiedSinceLastQuasiSave = true;
}

void renameEditorBuffer(EditorBuffer *buffer, char *newName, EditorUndo **undo) {
    char newFileName[MAX_FILE_NAME_SIZE];

    strcpy(newFileName, normalizeFileName_static(newName, cwd));

    EditorBuffer *existing_buffer = getEditorBufferForFile(buffer->fileName);
    if (existing_buffer == NULL) {
        char tmpBuffer[TMP_BUFF_SIZE];
        sprintf(tmpBuffer, "Trying to rename non existing buffer %s", buffer->fileName);
        errorMessage(ERR_INTERNAL, tmpBuffer);
        return;
    }
    assert(existing_buffer == buffer);

    EditorBuffer *deregistered_original = deregisterEditorBuffer(buffer->fileName);
    assert(deregistered_original == buffer);

    char *oldName = buffer->fileName;
    buffer->fileName = strdup(newFileName);

    // Update fileNumber
    int newFileNumber = addFileNameToFileTable(newFileName);
    getFileItemWithFileNumber(newFileNumber)->isArgument = getFileItemWithFileNumber(buffer->fileNumber)->isArgument;
    buffer->fileNumber = newFileNumber;

    EditorBuffer *existing_buffer_with_the_new_name = getEditorBufferForFile(newFileName);
    if (existing_buffer_with_the_new_name != NULL) {
        EditorBuffer *deleted = deregisterEditorBuffer(newFileName);
        freeEditorBuffer(deleted);
    }
    registerEditorBuffer(buffer);

    // note undo operation
    if (undo!=NULL) {
        *undo = newUndoRename(buffer, oldName, *undo);
    }
    setEditorBufferModified(buffer);

    // finally create a buffer with old name and empty text in order
    // to keep information that the file is no longer existing
    // so old references will be removed on update (fixing problem of
    // of moving a package into an existing package).
    EditorBuffer *removed = createNewEditorBuffer(oldName, NULL, buffer->modificationTime, buffer->size);
    allocateNewEditorBufferTextSpace(removed, 0);
    removed->textLoaded = true;
    setEditorBufferModified(removed);
}

1	#include "editorbuffer.h"
2
3	#include <string.h>
4	#include <stdlib.h>
5
6	#include "commons.h"
7	#include "editor.h"
8	#include "editorbuffertable.h"
9	#include "fileio.h"
10	#include "filetable.h"
11	#include "globals.h"
12	#include "log.h"
13	#include "memory.h"
14	#include "undo.h"
15
16
17	static void fillEmptyEditorBuffer(EditorBuffer buffer, char realFileName, int fileNumber, char *preLoadedFromFile) {	20,476✔
18	buffer->allocation = (EditorBufferAllocationData){	20,476✔
19	.bufferSize = 0, .text = NULL, .allocatedFreePrefixSize = 0,
20	.allocatedBlock = NULL, .allocatedIndex = 0,
21	.allocatedSize = 0};
22	*buffer = (EditorBuffer){	20,476✔
23	.fileName = realFileName, .fileNumber = fileNumber, .preLoadedFromFile = preLoadedFromFile,
24	.markers = NULL, .allocation = buffer->allocation};	20,476✔
25	buffer->modificationTime = 0;	20,476✔
26	buffer->size = 0;	20,476✔
27	buffer->textLoaded = false;	20,476✔
28	assert(buffer->preLoadedFromFile == NULL \|\| buffer->preLoadedFromFile != buffer->fileName);	20,476✔
29	}
30		20,476✔
31	EditorBuffer newEditorBuffer(char realFileName, int fileNumber, char *preLoadedFromFile, time_t modificationTime,
32	size_t size) {	20,476✔
33	EditorBuffer *editorBuffer = malloc(sizeof(EditorBuffer));	20,476✔
34	fillEmptyEditorBuffer(editorBuffer, realFileName, fileNumber, preLoadedFromFile);	20,476✔
35	editorBuffer->modificationTime = modificationTime;	20,476✔
36	editorBuffer->size = size;	20,476✔
37	return editorBuffer;
38	}
39		20,476✔
40	EditorBuffer createNewEditorBuffer(char realFileName, char *preLoadedFromFile, time_t modificationTime,
41	size_t size) {	20,476✔
42	char *normalizedRealFileName = strdup(normalizeFileName_static(realFileName, cwd));
43		20,476✔
44	assert(preLoadedFromFile == NULL \|\| strcmp(realFileName, preLoadedFromFile) != 0);	20,476✔
45	char *normalizedLoadedFromFile = NULL;	2✔
46	if (preLoadedFromFile != NULL) {	2✔
47	normalizedLoadedFromFile = normalizeFileName_static(preLoadedFromFile, cwd);
48	normalizedLoadedFromFile = strdup(normalizedLoadedFromFile);
49	}	20,476✔
50		20,476✔
51	EditorBuffer *buffer = newEditorBuffer(normalizedRealFileName, 0, normalizedLoadedFromFile, modificationTime, size);
52	log_trace("created buffer '%s'('%s')", buffer->fileName, buffer->preLoadedFromFile?buffer->preLoadedFromFile:"(null)");	20,476✔
53
54	registerEditorBuffer(buffer);
55
56	// set fileNumber last, because, addfiletabitem calls back the statb	20,476✔
57	// from editor, so be tip-top at this moment!
58	buffer->fileNumber = addFileNameToFileTable(normalizedRealFileName);	20,476✔
59
60	return buffer;
61	}	20,108✔
62		20,108✔
63	static void checkForMagicMarker(EditorBufferAllocationData *allocation) {
64	assert(allocation->allocatedBlock[allocation->allocatedSize] == 0x3b);	20,108✔
65	}	20,108✔
66		×
67	static void freeMarkersInEditorBuffer(EditorBuffer *buffer) {	×
68	for (EditorMarker *marker = buffer->markers; marker != NULL;) {	×
69	EditorMarker *next = marker->next;
70	free(marker);	20,108✔
71	marker = next;
72	}	20,109✔
73	}	20,109✔
74		1✔
75	void freeEditorBuffer(EditorBuffer *buffer) {	20,108✔
76	if (buffer == NULL)	×
77	return;
78	log_trace("freeing buffer %s==%s", buffer->fileName, buffer->preLoadedFromFile?buffer->preLoadedFromFile:"(null)");	20,108✔
79	if (buffer->preLoadedFromFile != NULL) {
80	free(buffer->preLoadedFromFile);	20,108✔
81	}
82	free(buffer->fileName);	20,108✔
83		20,108✔
84	freeMarkersInEditorBuffer(buffer);
85		20,108✔
86	if (buffer->textLoaded) {	20,108✔
87	log_trace("freeing allocated block %d of size %d", buffer->allocation.allocatedBlock,
88	buffer->allocation.allocatedSize);
89	checkForMagicMarker(&buffer->allocation);	20,108✔
90	freeTextSpace(buffer->allocation.allocatedBlock,
91	buffer->allocation.allocatedIndex);
92	}	2✔
93	free(buffer);	2✔
94	}	2✔
95		2✔
96	EditorBuffer getOpenedAndLoadedEditorBuffer(char fileName) {	×
97	EditorBuffer *buffer = getEditorBufferForFile(fileName);
98	if (buffer!=NULL && buffer->textLoaded)
99	return buffer;	164,841✔
100	return NULL;	164,841✔
101	}
102		164,841✔
103	EditorBuffer findOrCreateAndLoadEditorBufferForFile(char fileName) {
104	EditorBuffer *editorBuffer = getEditorBufferForFile(fileName);	7,044✔
105
106	if (editorBuffer != NULL && editorBuffer->textLoaded)	157,797✔
107	/* Found one with text loaded, return it */
108	return editorBuffer;	157,797✔
109		20,470✔
110	if (editorBuffer == NULL) {
111	/* No buffer found, create one unless it is a directory */	20,470✔
112	if (fileExists(fileName) && !isDirectory(fileName)) {
113	editorBuffer = createNewEditorBuffer(fileName, NULL, fileModificationTime(fileName),	137,327✔
114	fileSize(fileName));
115	loadFileIntoEditorBuffer(editorBuffer, fileModificationTime(fileName), fileSize(fileName));
116	} else	20,470✔
117	return NULL;
118	}
119
120	return editorBuffer;	2✔
121	}
122
123	// Only used from Options for preload	2✔
124	EditorBuffer openEditorBufferFromPreload(char fileName, char *preLoadedFromFile) {	2✔
125	EditorBuffer *buffer;	×
126
127	buffer = getEditorBufferForFile(fileName);	2✔
128	if (buffer != NULL) {
129	return buffer;	2✔
130	}
131	buffer = createNewEditorBuffer(fileName, preLoadedFromFile, fileModificationTime(preLoadedFromFile),
132	fileSize(preLoadedFromFile));	20,471✔
133	return buffer;	20,471✔
134	}
135
136	char getTextInEditorBuffer(EditorBuffer buffer) {	20,471✔
137	return buffer->allocation.text;	20,471✔
138	}
139
140	size_t getSizeOfEditorBuffer(EditorBuffer *buffer) {	20,471✔
141	return buffer->allocation.bufferSize;	20,471✔
142	}	20,471✔
143
144	void setSizeOfEditorBuffer(EditorBuffer *buffer, size_t size) {	191✔
145	buffer->allocation.bufferSize = size;	191✔
146	}	191✔
147		191✔
148	void setEditorBufferModified(EditorBuffer *buffer) {
149	buffer->modified = true;	4✔
150	buffer->modifiedSinceLastQuasiSave = true;
151	}
152		4✔
153	void renameEditorBuffer(EditorBuffer buffer, char newName, EditorUndo **undo) {
154	char newFileName[MAX_FILE_NAME_SIZE];	4✔
155		4✔
156	strcpy(newFileName, normalizeFileName_static(newName, cwd));
157		×
158	EditorBuffer *existing_buffer = getEditorBufferForFile(buffer->fileName);	×
159	if (existing_buffer == NULL) {	×
160	char tmpBuffer[TMP_BUFF_SIZE];
161	sprintf(tmpBuffer, "Trying to rename non existing buffer %s", buffer->fileName);
162	errorMessage(ERR_INTERNAL, tmpBuffer);	4✔
163	return;
164	}	4✔
165	assert(existing_buffer == buffer);	4✔
166
167	EditorBuffer *deregistered_original = deregisterEditorBuffer(buffer->fileName);
168	assert(deregistered_original == buffer);	4✔
169		4✔
170	char *oldName = buffer->fileName;	4✔
171	buffer->fileName = strdup(newFileName);
172		4✔
173	// Update fileNumber	4✔
174	int newFileNumber = addFileNameToFileTable(newFileName);	2✔
175	getFileItemWithFileNumber(newFileNumber)->isArgument = getFileItemWithFileNumber(buffer->fileNumber)->isArgument;	2✔
176	buffer->fileNumber = newFileNumber;
177		4✔
178	EditorBuffer *existing_buffer_with_the_new_name = getEditorBufferForFile(newFileName);
179	if (existing_buffer_with_the_new_name != NULL) {
180	EditorBuffer *deleted = deregisterEditorBuffer(newFileName);	4✔
181	freeEditorBuffer(deleted);	3✔
182	}
183	registerEditorBuffer(buffer);	4✔
184
185	// note undo operation
186	if (undo!=NULL) {
187	undo = newUndoRename(buffer, oldName, undo);
188	}
189	setEditorBufferModified(buffer);	4✔
190		4✔
191	// finally create a buffer with old name and empty text in order	4✔
192	// to keep information that the file is no longer existing	4✔
193	// so old references will be removed on update (fixing problem of
194	// of moving a package into an existing package).
195	EditorBuffer *removed = createNewEditorBuffer(oldName, NULL, buffer->modificationTime, buffer->size);
196	allocateNewEditorBufferTextSpace(removed, 0);
197	removed->textLoaded = true;
198	setEditorBufferModified(removed);
199	}

thoni56 / c-xrefactory / 1617

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