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

84.95

src/characterreader.c

#include "characterreader.h"

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

#include "head.h"
#include "fileio.h"

#include "log.h"


void fillCharacterBuffer(CharacterBuffer *characterBuffer,
                         char *next,
                         char *end,
                         FILE *file,
                         unsigned filePos,
                         int fileNumber,
                         char *lineBegin
) {
    characterBuffer->nextUnread = next;
    characterBuffer->end = end;
    characterBuffer->file = file;
    characterBuffer->filePos = filePos;
    characterBuffer->fileNumber = fileNumber;
    characterBuffer->lineNumber = 0;
    characterBuffer->lineBegin = lineBegin;
    characterBuffer->columnOffset = 0;
    characterBuffer->isAtEOF = false;
}

void initCharacterBufferFromFile(CharacterBuffer *characterbuffer, FILE *file) {
    fillCharacterBuffer(characterbuffer, characterbuffer->chars, characterbuffer->chars,
                        file, 0, -1, characterbuffer->chars);
}

void initCharacterBufferFromString(CharacterBuffer *characterbuffer, char *string) {
    strcpy(characterbuffer->chars, string);
    fillCharacterBuffer(characterbuffer, characterbuffer->chars, characterbuffer->chars,
                        NULL, 0, 0, characterbuffer->chars);
    characterbuffer->end = &characterbuffer->chars[strlen(string)];
}


int fileNumberFrom(CharacterBuffer *cb) {
    return cb->fileNumber;
}

int lineNumberFrom(CharacterBuffer *cb) {
    return cb->lineNumber;
}

/* ***************************************************************** */
/*                        Character reading                          */
/* ***************************************************************** */


static int readFromFileToBuffer(CharacterBuffer  *buffer, char *outBuffer, int max_size) {
    if (buffer->file == NULL)
        return 0;
    else
        return readFile(buffer->file, outBuffer, 1, max_size);
}

void closeCharacterBuffer(CharacterBuffer *buffer) {
    ENTER();
    if (buffer->file != NULL)
        closeFile(buffer->file);
    LEAVE();
}

bool refillBuffer(CharacterBuffer *buffer) {
    char *next = buffer->nextUnread;
    char *end = buffer->end;

    char *cp;
    for (cp=buffer->chars+MAX_UNGET_CHARS; next<end; next++,cp++)
        *cp = *next;

    int max_size = CHARACTER_BUFFER_SIZE - (cp - buffer->chars);

    int charactersRead = readFromFileToBuffer(buffer, cp, max_size);

    if (charactersRead > 0) {
        buffer->filePos += charactersRead;
        buffer->end = cp+charactersRead;
        buffer->nextUnread = buffer->chars+MAX_UNGET_CHARS;
    }

    log_trace("refillBuffer: (%s) buffer->next=%p, buffer->end=%p", buffer->nextUnread == buffer->end?"equal":"not equal", buffer->nextUnread, buffer->end);
    return buffer->nextUnread != buffer->end;
}


void skipCharacters(CharacterBuffer *buffer, unsigned count) {

    if (buffer->nextUnread+count < buffer->end) {
        buffer->nextUnread += count;
        return;
    }

    count -= buffer->end - buffer->nextUnread;        /* How many to skip after refilling? */

    char *dd;
    int n;
    int max_size;

    log_trace("seeking over %d chars", count);
    fseek(buffer->file, count, SEEK_CUR);
    buffer->filePos += count;
    dd = buffer->chars + MAX_UNGET_CHARS;
    max_size = CHARACTER_BUFFER_SIZE - (dd - buffer->chars);
    if (buffer->file == NULL)
        n = 0;
    else
        n = readFile(buffer->file, dd, 1, max_size);
    buffer->filePos += n;
    buffer->end = dd + n;
    buffer->nextUnread = buffer->chars + MAX_UNGET_CHARS;
}


int columnPosition(CharacterBuffer *cb) {
    return cb->nextUnread - cb->lineBegin + cb->columnOffset - 1;
}


int fileOffsetFor(CharacterBuffer *cb) {
    return cb->filePos - (cb->end - cb->nextUnread) - 1;
}


int skipBlanks(CharacterBuffer *cb, int ch) {
    while (ch==' '|| ch=='\t' || ch=='\004') { /* EOT? */
        ch = getChar(cb);
    }
    return ch;
}


int skipWhiteSpace(CharacterBuffer *cb, int ch) {
    while (ch==' ' || ch=='\n' || ch=='\t') {
        ch = getChar(cb);
    }

    return ch;
}

/* Return next unread character from CharacterBuffer and advance */
int getChar(CharacterBuffer *cb) {
        if (cb->nextUnread >= cb->end &&
            (cb->isAtEOF || refillBuffer(cb) == 0)) {
                cb->isAtEOF = true;
                return EOF;
        } else {
            return *cb->nextUnread++;
        }
}


void getString(CharacterBuffer *cb, char *string, int length) {
    char ch;

    for (int i=0; i<length; i++) {
        ch = getChar(cb);
        string[i] = ch;
    }
    string[length] = 0;
}

void ungetChar(CharacterBuffer *cb, int ch) {
    if (ch == '\n')
        log_trace("Ungetting ('\\n')");
    else
        log_trace("Ungetting ('%c'=%d)", ch, ch);
    *--(cb->nextUnread) = ch;
}

1	#include "characterreader.h"
2
3	#include <stdlib.h>
4	#include <string.h>
5
6	#include "head.h"
7	#include "fileio.h"
8
9	#include "log.h"
10
11
12	void fillCharacterBuffer(CharacterBuffer *characterBuffer,	159,234✔
13	char *next,
14	char *end,
15	FILE *file,
16	unsigned filePos,
17	int fileNumber,
18	char *lineBegin
19	) {
20	characterBuffer->nextUnread = next;	159,234✔
21	characterBuffer->end = end;	159,234✔
22	characterBuffer->file = file;	159,234✔
23	characterBuffer->filePos = filePos;	159,234✔
24	characterBuffer->fileNumber = fileNumber;	159,234✔
25	characterBuffer->lineNumber = 0;	159,234✔
26	characterBuffer->lineBegin = lineBegin;	159,234✔
27	characterBuffer->columnOffset = 0;	159,234✔
28	characterBuffer->isAtEOF = false;	159,234✔
29	}	159,234✔
30
31	void initCharacterBufferFromFile(CharacterBuffer characterbuffer, FILE file) {	79,661✔
32	fillCharacterBuffer(characterbuffer, characterbuffer->chars, characterbuffer->chars,	79,661✔
33	file, 0, -1, characterbuffer->chars);	79,661✔
34	}	79,661✔
35
36	void initCharacterBufferFromString(CharacterBuffer characterbuffer, char string) {	11✔
37	strcpy(characterbuffer->chars, string);	11✔
38	fillCharacterBuffer(characterbuffer, characterbuffer->chars, characterbuffer->chars,	11✔
39	NULL, 0, 0, characterbuffer->chars);	11✔
40	characterbuffer->end = &characterbuffer->chars[strlen(string)];	11✔
41	}	11✔
42
43
44	int fileNumberFrom(CharacterBuffer *cb) {	30,801,605✔
45	return cb->fileNumber;	30,801,605✔
46	}
47
48	int lineNumberFrom(CharacterBuffer *cb) {	41,120,791✔
49	return cb->lineNumber;	41,120,791✔
50	}
51
52	/* ***************************************************************** */
53	/* Character reading */
54	/* ***************************************************************** */
55
56
57	static int readFromFileToBuffer(CharacterBuffer buffer, char outBuffer, int max_size) {	79,973✔
58	if (buffer->file == NULL)	79,973✔
59	return 0;	79,551✔
60	else
61	return readFile(buffer->file, outBuffer, 1, max_size);	422✔
62	}
63
64	void closeCharacterBuffer(CharacterBuffer *buffer) {	23,892✔
65	ENTER();	23,892✔
66	if (buffer->file != NULL)	23,892✔
67	closeFile(buffer->file);	×
68	LEAVE();	23,892✔
69	}	23,892✔
70
71	bool refillBuffer(CharacterBuffer *buffer) {	79,973✔
72	char *next = buffer->nextUnread;	79,973✔
73	char *end = buffer->end;	79,973✔
74
75	char *cp;
76	for (cp=buffer->chars+MAX_UNGET_CHARS; next<end; next++,cp++)	×
77	cp = next;
78		79,973✔
79	int max_size = CHARACTER_BUFFER_SIZE - (cp - buffer->chars);
80		79,973✔
81	int charactersRead = readFromFileToBuffer(buffer, cp, max_size);
82		79,973✔
83	if (charactersRead > 0) {	318✔
84	buffer->filePos += charactersRead;	318✔
85	buffer->end = cp+charactersRead;	318✔
86	buffer->nextUnread = buffer->chars+MAX_UNGET_CHARS;
87	}
88		79,973✔
89	log_trace("refillBuffer: (%s) buffer->next=%p, buffer->end=%p", buffer->nextUnread == buffer->end?"equal":"not equal", buffer->nextUnread, buffer->end);	79,973✔
90	return buffer->nextUnread != buffer->end;
91	}
92
93		45✔
94	void skipCharacters(CharacterBuffer *buffer, unsigned count) {
95		45✔
96	if (buffer->nextUnread+count < buffer->end) {	45✔
97	buffer->nextUnread += count;	45✔
98	return;
99	}
100		×
101	count -= buffer->end - buffer->nextUnread; /* How many to skip after refilling? */
102
103	char *dd;
104	int n;
105	int max_size;
106		×
107	log_trace("seeking over %d chars", count);	×
108	fseek(buffer->file, count, SEEK_CUR);	×
109	buffer->filePos += count;	×
110	dd = buffer->chars + MAX_UNGET_CHARS;	×
111	max_size = CHARACTER_BUFFER_SIZE - (dd - buffer->chars);	×
112	if (buffer->file == NULL)	×
113	n = 0;
114	else	×
115	n = readFile(buffer->file, dd, 1, max_size);	×
116	buffer->filePos += n;	×
117	buffer->end = dd + n;	×
118	buffer->nextUnread = buffer->chars + MAX_UNGET_CHARS;
119	}
120
121		112,058,913✔
122	int columnPosition(CharacterBuffer *cb) {	112,058,913✔
123	return cb->nextUnread - cb->lineBegin + cb->columnOffset - 1;
124	}
125
126		50,852,754✔
127	int fileOffsetFor(CharacterBuffer *cb) {	50,852,754✔
128	return cb->filePos - (cb->end - cb->nextUnread) - 1;
129	}
130
131		54,761,180✔
132	int skipBlanks(CharacterBuffer *cb, int ch) {	102,663,562✔
133	while (ch==' '\|\| ch=='\t' \|\| ch=='\004') { /* EOT? */	47,902,382✔
134	ch = getChar(cb);
135	}	54,761,180✔
136	return ch;
137	}
138
139		56,064✔
140	int skipWhiteSpace(CharacterBuffer *cb, int ch) {	73,227✔
141	while (ch==' ' \|\| ch=='\n' \|\| ch=='\t') {	17,163✔
142	ch = getChar(cb);
143	}
144		56,064✔
145	return ch;
146	}
147
148	/* Return next unread character from CharacterBuffer and advance */	482,965,578✔
149	int getChar(CharacterBuffer *cb) {	482,965,578✔
150	if (cb->nextUnread >= cb->end &&	159,899✔
151	(cb->isAtEOF \|\| refillBuffer(cb) == 0)) {	159,581✔
152	cb->isAtEOF = true;	159,581✔
153	return EOF;
154	} else {	482,805,997✔
155	return *cb->nextUnread++;
156	}
157	}
158
159		5,333✔
160	void getString(CharacterBuffer cb, char string, int length) {
161	char ch;
162		92,921✔
163	for (int i=0; i<length; i++) {	87,588✔
164	ch = getChar(cb);	87,588✔
165	string[i] = ch;
166	}	5,333✔
167	string[length] = 0;	5,333✔
168	}
169		2,152,781✔
170	void ungetChar(CharacterBuffer *cb, int ch) {	2,152,781✔
171	if (ch == '\n')	97,535✔
172	log_trace("Ungetting ('\\n')");
173	else	2,055,246✔
174	log_trace("Ungetting ('%c'=%d)", ch, ch);	2,152,781✔
175	*--(cb->nextUnread) = ch;	2,152,781✔
176	}

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