1670

Committed 22 Dec 2025 02:19PM UTC coverage: 82.747% (-0.07%) from 82.813%

Build # 1670

Build Type

push

travis-ci

Committed by

thoni56

Commit Message

[tidy] Remove some OO-prefixes

Run Details

13194 of 15945 relevant lines covered (82.75%)

17986964.81 hits per line

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

93.2

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) {	459,083✔
18	buffer->allocation = (EditorBufferAllocationData){	459,083✔
19	.bufferSize = 0, .text = NULL, .allocatedFreePrefixSize = 0,
20	.allocatedBlock = NULL, .allocatedIndex = 0,
21	.allocatedSize = 0};
22	*buffer = (EditorBuffer){	459,083✔
23	.fileName = realFileName, .fileNumber = fileNumber, .preLoadedFromFile = preLoadedFromFile,
24	.markers = NULL, .allocation = buffer->allocation};	459,083✔
25	buffer->modificationTime = 0;	459,083✔
26	buffer->size = 0;	459,083✔
27	buffer->textLoaded = false;	459,083✔
28	assert(buffer->preLoadedFromFile == NULL \|\| buffer->preLoadedFromFile != buffer->fileName);	459,083✔
29	}
30		459,083✔
31	EditorBuffer newEditorBuffer(char realFileName, int fileNumber, char *preLoadedFromFile, time_t modificationTime,
32	size_t size) {	459,083✔
33	EditorBuffer *editorBuffer = malloc(sizeof(EditorBuffer));	459,083✔
34	fillEmptyEditorBuffer(editorBuffer, realFileName, fileNumber, preLoadedFromFile);	459,083✔
35	editorBuffer->modificationTime = modificationTime;	459,083✔
36	editorBuffer->size = size;	459,083✔
37	return editorBuffer;
38	}
39		459,083✔
40	EditorBuffer createNewEditorBuffer(char realFileName, char *preLoadedFromFile, time_t modificationTime,
41	size_t size) {	459,083✔
42	char *normalizedRealFileName = strdup(normalizeFileName_static(realFileName, cwd));
43		459,083✔
44	assert(preLoadedFromFile == NULL \|\| strcmp(realFileName, preLoadedFromFile) != 0);	459,083✔
45	char *normalizedLoadedFromFile = NULL;	11✔
46	if (preLoadedFromFile != NULL) {	11✔
47	normalizedLoadedFromFile = normalizeFileName_static(preLoadedFromFile, cwd);
48	normalizedLoadedFromFile = strdup(normalizedLoadedFromFile);
49	}	459,083✔
50		459,083✔
51	EditorBuffer *buffer = newEditorBuffer(normalizedRealFileName, 0, normalizedLoadedFromFile, modificationTime, size);
52	log_trace("created buffer '%s'('%s')", buffer->fileName, buffer->preLoadedFromFile?buffer->preLoadedFromFile:"(null)");	459,083✔
53
54	registerEditorBuffer(buffer);
55
56	// set fileNumber last, because, addfiletabitem calls back the statb	459,083✔
57	// from editor, so be tip-top at this moment!
58	buffer->fileNumber = addFileNameToFileTable(normalizedRealFileName);	459,083✔
59
60	return buffer;
61	}	458,716✔
62		458,716✔
63	static void checkForMagicMarker(EditorBufferAllocationData *allocation) {
64	assert(allocation->allocatedBlock[allocation->allocatedSize] == 0x3b);	458,716✔
65	}	458,716✔
66		×
67	static void freeMarkersInEditorBuffer(EditorBuffer *buffer) {	×
68	for (EditorMarker *marker = buffer->markers; marker != NULL;) {	×
69	EditorMarker *next = marker->next;
70	free(marker);	458,716✔
71	marker = next;
72	}	458,717✔
73	}	458,717✔
74		1✔
75	void freeEditorBuffer(EditorBuffer *buffer) {	458,716✔
76	if (buffer == NULL)	458,716✔
77	return;	10✔
78	log_trace("freeing buffer %s==%s", buffer->fileName, buffer->preLoadedFromFile?buffer->preLoadedFromFile:"(null)");
79	if (buffer->preLoadedFromFile != NULL) {	458,716✔
80	free(buffer->preLoadedFromFile);
81	}	458,716✔
82	free(buffer->fileName);
83		458,716✔
84	freeMarkersInEditorBuffer(buffer);	458,716✔
85
86	if (buffer->textLoaded) {	458,716✔
87	log_trace("freeing allocated block %d of size %d", buffer->allocation.allocatedBlock,	458,716✔
88	buffer->allocation.allocatedSize);
89	checkForMagicMarker(&buffer->allocation);
90	freeTextSpace(buffer->allocation.allocatedBlock,	458,716✔
91	buffer->allocation.allocatedIndex);
92	}
93	free(buffer);	175✔
94	}	175✔
95		175✔
96	EditorBuffer getOpenedAndLoadedEditorBuffer(char fileName) {	175✔
97	EditorBuffer *buffer = getEditorBufferForFile(fileName);	×
98	if (buffer!=NULL && buffer->textLoaded)
99	return buffer;
100	return NULL;	8,552,238✔
101	}	8,552,238✔
102
103	EditorBuffer findOrCreateAndLoadEditorBufferForFile(char fileName) {	8,552,238✔
104	EditorBuffer *editorBuffer = getEditorBufferForFile(fileName);
105		548,029✔
106	if (editorBuffer != NULL && editorBuffer->textLoaded)
107	/* Found one with text loaded, return it */	8,004,209✔
108	return editorBuffer;
109		8,004,209✔
110	if (editorBuffer == NULL) {	459,068✔
111	/* No buffer found, create one unless it is a directory */
112	if (fileExists(fileName) && !isDirectory(fileName)) {	459,068✔
113	editorBuffer = createNewEditorBuffer(fileName, NULL, fileModificationTime(fileName),
114	fileSize(fileName));	7,545,141✔
115	loadFileIntoEditorBuffer(editorBuffer, fileModificationTime(fileName), fileSize(fileName));
116	} else
117	return NULL;	459,068✔
118	}
119
120	return editorBuffer;
121	}	17✔
122
123	// Only used from Options for preload
124	EditorBuffer openEditorBufferFromPreload(char fileName, char *preLoadedFromFile) {	17✔
125	EditorBuffer *buffer;	17✔
126		6✔
127	buffer = getEditorBufferForFile(fileName);
128	if (buffer != NULL) {	11✔
129	return buffer;
130	}	11✔
131	buffer = createNewEditorBuffer(fileName, preLoadedFromFile, fileModificationTime(preLoadedFromFile),
132	fileSize(preLoadedFromFile));
133	return buffer;	459,079✔
134	}	459,079✔
135
136	char getTextInEditorBuffer(EditorBuffer buffer) {
137	return buffer->allocation.text;	459,079✔
138	}	459,079✔
139
140	size_t getSizeOfEditorBuffer(EditorBuffer *buffer) {
141	return buffer->allocation.bufferSize;	459,079✔
142	}	459,079✔
143		459,079✔
144	void setSizeOfEditorBuffer(EditorBuffer *buffer, size_t size) {
145	buffer->allocation.bufferSize = size;	191✔
146	}	191✔
147		191✔
148	void setEditorBufferModified(EditorBuffer *buffer) {	191✔
149	buffer->modified = true;
150	buffer->modifiedSinceLastQuasiSave = true;	4✔
151	}
152
153	void renameEditorBuffer(EditorBuffer buffer, char newName, EditorUndo **undo) {	4✔
154	char newFileName[MAX_FILE_NAME_SIZE];
155		4✔
156	strcpy(newFileName, normalizeFileName_static(newName, cwd));	4✔
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);
163	return;	4✔
164	}
165	assert(existing_buffer == buffer);	4✔
166		4✔
167	EditorBuffer *deregistered_original = deregisterEditorBuffer(buffer->fileName);
168	assert(deregistered_original == buffer);
169		4✔
170	char *oldName = buffer->fileName;	4✔
171	buffer->fileName = strdup(newFileName);	4✔
172
173	// Update fileNumber	4✔
174	int newFileNumber = addFileNameToFileTable(newFileName);	4✔
175	getFileItemWithFileNumber(newFileNumber)->isArgument = getFileItemWithFileNumber(buffer->fileNumber)->isArgument;	2✔
176	buffer->fileNumber = newFileNumber;	2✔
177
178	EditorBuffer *existing_buffer_with_the_new_name = getEditorBufferForFile(newFileName);	4✔
179	if (existing_buffer_with_the_new_name != NULL) {
180	EditorBuffer *deleted = deregisterEditorBuffer(newFileName);
181	freeEditorBuffer(deleted);	4✔
182	}	3✔
183	registerEditorBuffer(buffer);
184		4✔
185	// note undo operation
186	if (undo!=NULL) {
187	undo = newUndoRename(buffer, oldName, undo);
188	}
189	setEditorBufferModified(buffer);
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	4✔
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 / 1670

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