1795

Committed 17 May 2026 09:16PM UTC coverage: 85.242% (+0.1%) from 85.141%

Build # 1795

Build Type

push

travis-ci

Committed by

thoni56

Commit Message

[requests][tidy] Change request -olcxnext/previous to -browse-next/previous

Coverage Stats

16381 of 19217 relevant lines covered (85.24%)

15918297.46 hits per line

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

93.97

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 "timestamp.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 = NULL_TIMESTAMP;
    buffer->size = 0;
    buffer->textLoaded = false;
    assert(buffer->preLoadedFromFile == NULL || buffer->preLoadedFromFile != buffer->fileName);
}

EditorBuffer *newEditorBuffer(char *realFileName, int fileNumber, char *preLoadedFromFile, FileTimestamp 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, FileTimestamp 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;
    }
}

bool isPreloaded(EditorBuffer *buffer) {
    return buffer != NULL && buffer->preLoadedFromFile != NULL;
}

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

    freeMarkersInEditorBuffer(buffer);

    if (buffer->textLoaded) {
        log_trace("freeing allocated block 0x%x 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 = getEditorBufferForFile(fileName);
    if (buffer != NULL) {
        FileTimestamp incomingMtime = fileModificationTime(preLoadedFromFile);
        if (fileTimestampsEqual(incomingMtime, buffer->modificationTime)) {
            log_debug("Preload '%s': unchanged (mtime %ld), keeping existing buffer", fileName, fileTimestampSeconds(incomingMtime));
            buffer->preloadedThisRequest = true;
            return buffer;
        }
        log_debug("Preload '%s': content changed (mtime %ld -> %ld), reloading", fileName,
                  fileTimestampSeconds(buffer->modificationTime), fileTimestampSeconds(incomingMtime));
        free(buffer->preLoadedFromFile);
        buffer->preLoadedFromFile = strdup(normalizeFileName_static(preLoadedFromFile, cwd));
        loadFileIntoEditorBuffer(buffer, incomingMtime, fileSize(preLoadedFromFile));
        buffer->preloadedThisRequest = true;
        return buffer;
    }
    buffer = createNewEditorBuffer(fileName, preLoadedFromFile, fileModificationTime(preLoadedFromFile),
                                   fileSize(preLoadedFromFile));
    buffer->preloadedThisRequest = true;
    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;
    buffer->modificationTime = fileTimestampNow();
}

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

thoni56 / c-xrefactory / 1795

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