1660

Committed 19 Dec 2025 12:09AM UTC coverage: 82.82% (+0.2%) from 82.585%

Build # 1660

Build Type

push

travis-ci

Committed by

thoni56

Commit Message

[flaky] Last(?) attempt to get `test_c-xref` more stable on Travis

Run Details

13276 of 16030 relevant lines covered (82.82%)

17892372.92 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"


#define MAX_UNGET_CHARS 20


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	#define MAX_UNGET_CHARS 20
13
14
15	void fillCharacterBuffer(CharacterBuffer *characterBuffer,	2,136,143✔
16	char *next,
17	char *end,
18	FILE *file,
19	unsigned filePos,
20	int fileNumber,
21	char *lineBegin
22	) {
23	characterBuffer->nextUnread = next;	2,136,143✔
24	characterBuffer->end = end;	2,136,143✔
25	characterBuffer->file = file;	2,136,143✔
26	characterBuffer->filePos = filePos;	2,136,143✔
27	characterBuffer->fileNumber = fileNumber;	2,136,143✔
28	characterBuffer->lineNumber = 0;	2,136,143✔
29	characterBuffer->lineBegin = lineBegin;	2,136,143✔
30	characterBuffer->columnOffset = 0;	2,136,143✔
31	characterBuffer->isAtEOF = false;	2,136,143✔
32	}	2,136,143✔
33
34	void initCharacterBufferFromFile(CharacterBuffer characterbuffer, FILE file) {	1,068,128✔
35	fillCharacterBuffer(characterbuffer, characterbuffer->chars, characterbuffer->chars,	1,068,128✔
36	file, 0, -1, characterbuffer->chars);	1,068,128✔
37	}	1,068,128✔
38
39	void initCharacterBufferFromString(CharacterBuffer characterbuffer, char string) {	11✔
40	strcpy(characterbuffer->chars, string);	11✔
41	fillCharacterBuffer(characterbuffer, characterbuffer->chars, characterbuffer->chars,	11✔
42	NULL, 0, 0, characterbuffer->chars);	11✔
43	characterbuffer->end = &characterbuffer->chars[strlen(string)];	11✔
44	}	11✔
45
46
47	int fileNumberFrom(CharacterBuffer *cb) {	481,255,389✔
48	return cb->fileNumber;	481,255,389✔
49	}
50
51	int lineNumberFrom(CharacterBuffer *cb) {	717,512,892✔
52	return cb->lineNumber;	717,512,892✔
53	}
54
55	/* ***************************************************************** */
56	/* Character reading */
57	/* ***************************************************************** */
58
59
60	static int readFromFileToBuffer(CharacterBuffer buffer, char outBuffer, int max_size) {	1,068,478✔
61	if (buffer->file == NULL)	1,068,478✔
62	return 0;	1,067,993✔
63	else
64	return readFile(buffer->file, outBuffer, 1, max_size);	485✔
65	}
66
67	void closeCharacterBuffer(CharacterBuffer *buffer) {	1,003,348✔
68	ENTER();	1,003,348✔
69	if (buffer->file != NULL)	1,003,348✔
70	closeFile(buffer->file);	×
71	LEAVE();	1,003,348✔
72	}	1,003,348✔
73
74	bool refillBuffer(CharacterBuffer *buffer) {	1,068,478✔
75	char *next = buffer->nextUnread;	1,068,478✔
76	char *end = buffer->end;	1,068,478✔
77
78	char *cp;
79	for (cp=buffer->chars+MAX_UNGET_CHARS; next<end; next++,cp++)	×
80	cp = next;
81		1,068,478✔
82	int max_size = CHARACTER_BUFFER_SIZE - (cp - buffer->chars);
83		1,068,478✔
84	int charactersRead = readFromFileToBuffer(buffer, cp, max_size);
85		1,068,478✔
86	if (charactersRead > 0) {	356✔
87	buffer->filePos += charactersRead;	356✔
88	buffer->end = cp+charactersRead;	356✔
89	buffer->nextUnread = buffer->chars+MAX_UNGET_CHARS;
90	}
91		1,068,478✔
92	log_trace("refillBuffer: (%s) buffer->next=%p, buffer->end=%p", buffer->nextUnread == buffer->end?"equal":"not equal", buffer->nextUnread, buffer->end);	1,068,478✔
93	return buffer->nextUnread != buffer->end;
94	}
95
96		53✔
97	void skipCharacters(CharacterBuffer *buffer, unsigned count) {
98		53✔
99	if (buffer->nextUnread+count < buffer->end) {	53✔
100	buffer->nextUnread += count;	53✔
101	return;
102	}
103		×
104	count -= buffer->end - buffer->nextUnread; /* How many to skip after refilling? */
105
106	char *dd;
107	int n;
108	int max_size;
109		×
110	log_trace("seeking over %d chars", count);	×
111	fseek(buffer->file, count, SEEK_CUR);	×
112	buffer->filePos += count;	×
113	dd = buffer->chars + MAX_UNGET_CHARS;	×
114	max_size = CHARACTER_BUFFER_SIZE - (dd - buffer->chars);	×
115	if (buffer->file == NULL)	×
116	n = 0;
117	else	×
118	n = readFile(buffer->file, dd, 1, max_size);	×
119	buffer->filePos += n;	×
120	buffer->end = dd + n;	×
121	buffer->nextUnread = buffer->chars + MAX_UNGET_CHARS;
122	}
123
124		1,853,802,188✔
125	int columnPosition(CharacterBuffer *cb) {	1,853,802,188✔
126	return cb->nextUnread - cb->lineBegin + cb->columnOffset - 1;
127	}
128
129		802,771,559✔
130	int fileOffsetFor(CharacterBuffer *cb) {	802,771,559✔
131	return cb->filePos - (cb->end - cb->nextUnread) - 1;
132	}
133
134		934,635,858✔
135	int skipBlanks(CharacterBuffer *cb, int ch) {	1,495,469,019✔
136	while (ch==' '\|\| ch=='\t' \|\| ch=='\004') { /* EOT? */	560,833,161✔
137	ch = getChar(cb);
138	}	934,635,858✔
139	return ch;
140	}
141
142		56,304✔
143	int skipWhiteSpace(CharacterBuffer *cb, int ch) {	73,887✔
144	while (ch==' ' \|\| ch=='\n' \|\| ch=='\t') {	17,583✔
145	ch = getChar(cb);
146	}
147		56,304✔
148	return ch;
149	}
150
151	/* Return next unread character from CharacterBuffer and advance */	2,147,483,647✔
152	int getChar(CharacterBuffer *cb) {	2,147,483,647✔
153	if (cb->nextUnread >= cb->end &&	2,136,936✔
154	(cb->isAtEOF \|\| refillBuffer(cb) == 0)) {	2,136,580✔
155	cb->isAtEOF = true;	2,136,580✔
156	return EOF;
157	} else {	2,147,483,647✔
158	return *cb->nextUnread++;
159	}
160	}
161
162		5,402✔
163	void getString(CharacterBuffer cb, char string, int length) {
164	char ch;
165		95,069✔
166	for (int i=0; i<length; i++) {	89,667✔
167	ch = getChar(cb);	89,667✔
168	string[i] = ch;
169	}	5,402✔
170	string[length] = 0;	5,402✔
171	}
172		42,883,286✔
173	void ungetChar(CharacterBuffer *cb, int ch) {	42,883,286✔
174	if (ch == '\n')	2,424,374✔
175	log_trace("Ungetting ('\\n')");
176	else	40,458,912✔
177	log_trace("Ungetting ('%c'=%d)", ch, ch);	42,883,286✔
178	*--(cb->nextUnread) = ch;	42,883,286✔
179	}

thoni56 / c-xrefactory / 1660

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