aremmell / libsir / 433

Committed 05 Sep 2023 12:02AM UTC coverage: 94.671% (-0.2%) from 94.865%

Build # 433

Build Type

Pull #257

gitlab-ci

Committed by

aremmell

Commit Message

flip ifdef logic for static init

Pull Request Pull Request #257: General performance enhancements & portability improvements

Run Details

236 of 236 new or added lines in 13 files covered. (100.0%)

3020 of 3190 relevant lines covered (94.67%)

632992.37 hits per line

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

92.31

/src/sirhelpers.c

/*
 * sirhelpers.c
 *
 * Author:    Ryan M. Lederman <lederman@gmail.com>
 * Copyright: Copyright (c) 2018-2023
 * Version:   2.2.3
 * License:   The MIT License (MIT)
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of
 * this software and associated documentation files (the "Software"), to deal in
 * the Software without restriction, including without limitation the rights to
 * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
 * the Software, and to permit persons to whom the Software is furnished to do so,
 * subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
 * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
 * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */
#include "sir/helpers.h"
#include "sir/errors.h"

void __sir_safefree(void** pp) {
    if (!pp || !*pp)
        return;

    free(*pp);
    *pp = NULL;
}

void _sir_safeclose(int* restrict fd) {
    if (!fd || 0 > *fd)
        return;

    if (-1 == close(*fd))
        (void)_sir_handleerr(errno);

    *fd = -1;
}

void _sir_safefclose(FILE* restrict* restrict f) {
    if (!f || !*f)
        return;

    if (0 != fclose(*f))
        (void)_sir_handleerr(errno);

    *f = NULL;
}

bool _sir_validfd(int fd) {
    /** stdin, stdout, stderr use up 0, 1, 2 */
    if (2 >= fd)
        return _sir_handleerr(EBADF);

#if !defined(__WIN__)
    int ret = fcntl(fd, F_GETFL);
#else /* __WIN__ */
# if !defined(SIR_MSVCRT_MINGW)
    invalparamfn old = _set_thread_local_invalid_parameter_handler(_sir_invalidparameter);
# endif
    struct _stat st;
    int ret = _fstat(fd, &st);
# if !defined(SIR_MSVCRT_MINGW)
    _set_thread_local_invalid_parameter_handler(old);
# endif
#endif
    return (-1 != ret || EBADF != errno) ? true : _sir_handleerr(errno);
}

/** Validates a sir_update_config_data structure. */
bool _sir_validupdatedata(sir_update_config_data* data) {
    if (!_sir_validptr(data))
        return false;

    bool valid = true;
    if ((data->fields & SIRU_ALL) == 0U || (data->fields & ~SIRU_ALL) != 0U)
        valid = false;

    if (valid && _sir_bittest(data->fields, SIRU_LEVELS))
        valid &= (_sir_validptrnofail(data->levels) &&
            _sir_validlevels(*data->levels));

    if (valid && _sir_bittest(data->fields, SIRU_OPTIONS))
        valid &= (_sir_validptrnofail(data->opts) &&
            _sir_validopts(*data->opts));

    if (valid && _sir_bittest(data->fields, SIRU_SYSLOG_ID))
        valid &= _sir_validstrnofail(data->sl_identity);

    if (valid && _sir_bittest(data->fields, SIRU_SYSLOG_CAT))
        valid &= _sir_validstrnofail(data->sl_category);

    if (!valid) {
        (void)_sir_seterror(_SIR_E_INVALID);
        SIR_ASSERT(!valid);
    }

    return valid;
}

bool _sir_validlevels(sir_levels levels) {
    if ((SIRL_ALL == levels || SIRL_NONE == levels) ||
        ((_sir_bittest(levels, SIRL_INFO)           ||
         _sir_bittest(levels, SIRL_DEBUG)           ||
         _sir_bittest(levels, SIRL_NOTICE)          ||
         _sir_bittest(levels, SIRL_WARN)            ||
         _sir_bittest(levels, SIRL_ERROR)           ||
         _sir_bittest(levels, SIRL_CRIT)            ||
         _sir_bittest(levels, SIRL_ALERT)           ||
         _sir_bittest(levels, SIRL_EMERG))          &&
         ((levels & ~SIRL_ALL) == 0U)))
         return true;

    _sir_selflog("invalid levels: %04"PRIx16, levels);
    return _sir_seterror(_SIR_E_LEVELS);
}

bool _sir_validlevel(sir_level level) {
    if (SIRL_INFO   == level || SIRL_DEBUG == level ||
        SIRL_NOTICE == level || SIRL_WARN  == level ||
        SIRL_ERROR  == level || SIRL_CRIT  == level ||
        SIRL_ALERT  == level || SIRL_EMERG == level)
        return true;

    _sir_selflog("invalid level: %04"PRIx16, level);
    return _sir_seterror(_SIR_E_LEVELS);
}

bool _sir_validopts(sir_options opts) {
    if ((SIRO_ALL == opts || SIRO_MSGONLY == opts) ||
        ((_sir_bittest(opts, SIRO_NOTIME)          ||
         _sir_bittest(opts, SIRO_NOHOST)           ||
         _sir_bittest(opts, SIRO_NOLEVEL)          ||
         _sir_bittest(opts, SIRO_NONAME)           ||
         _sir_bittest(opts, SIRO_NOMSEC)           ||
         _sir_bittest(opts, SIRO_NOPID)            ||
         _sir_bittest(opts, SIRO_NOTID)            ||
         _sir_bittest(opts, SIRO_NOHDR))           &&
         ((opts & ~(SIRO_MSGONLY | SIRO_NOHDR)) == 0U)))
         return true;

    _sir_selflog("invalid options: %08"PRIx32, opts);
    return _sir_seterror(_SIR_E_OPTIONS);
}

bool _sir_validtextattr(sir_textattr attr) {
    switch(attr) {
        case SIRTA_NORMAL:
        case SIRTA_BOLD:
        case SIRTA_DIM:
        case SIRTA_EMPH:
        case SIRTA_ULINE:
            return true;
        default: {
            _sir_selflog("invalid text attr: %d", attr);
            return _sir_seterror(_SIR_E_TEXTATTR);
        }
    }
}

bool _sir_validtextcolor(sir_colormode mode, sir_textcolor color) {
    bool valid = false;
    switch (mode) {
        case SIRCM_16:
            /* in 16-color mode:
             * compare to 30..37, 39, 40..47, 49, 90..97, 100..107. */
            valid = SIRTC_DEFAULT == color ||
                    (color >= 30U && color <= 37U) || color == 39U ||
                    (color >= 40U && color <= 47U) || color == 49U ||
                    (color >= 90U && color <= 97U) || (color >= 100U && color <= 107U);
            break;
        case SIRCM_256:
            /* in 256-color mode: compare to 0..255. sir_textcolor is unsigned,
             * so only need to ensure it's <= 255. */
            valid = SIRTC_DEFAULT == color || color <= 255U;
            break;
        case SIRCM_RGB: {
            /* in RGB-color mode: mask and compare to 0x00ffffff. */
            valid = SIRTC_DEFAULT == color || ((color & 0xff000000U) == 0U);
            break;
        }
        case SIRCM_INVALID: // GCOVR_EXCL_START
        default:
            valid = false;
            break;
    } // GCOVR_EXCL_STOP

    if (!valid) {
        _sir_selflog("invalid text color for mode %d %08"PRIx32" (%"PRIu32")",
            mode, color, color);
        (void)_sir_seterror(_SIR_E_TEXTCOLOR);
    }

    return valid;
}

bool _sir_validcolormode(sir_colormode mode) {
    switch (mode) {
        case SIRCM_16:
        case SIRCM_256:
        case SIRCM_RGB:
            return true;
        case SIRCM_INVALID:
        default: {
            _sir_selflog("invalid color mode: %d", mode);
            return _sir_seterror(_SIR_E_COLORMODE);
        }
    }
}

int _sir_strncpy(char* restrict dest, size_t destsz, const char* restrict src,
    size_t count) {
    if (_sir_validptr(dest) && _sir_validstr(src)) {
#if defined(__HAVE_STDC_SECURE_OR_EXT1__)
        int ret = strncpy_s(dest, destsz, src, count);
        if (0 != ret) {
            (void)_sir_handleerr(ret);
            return -1;
        }
        return 0;
#else
        SIR_UNUSED(count);
        size_t cpy = strlcpy(dest, src, destsz);
        SIR_ASSERT_UNUSED(cpy < destsz, cpy);
        return 0;
#endif
    }

    return -1;
}

int _sir_strncat(char* restrict dest, size_t destsz, const char* restrict src,
    size_t count) {
    if (_sir_validptr(dest) && _sir_validstr(src)) {
#if defined(__HAVE_STDC_SECURE_OR_EXT1__)
        int ret = strncat_s(dest, destsz, src, count);
        if (0 != ret) {
            (void)_sir_handleerr(ret);
            return -1;
        }
        return 0;
#else
        SIR_UNUSED(count);
        size_t cat = strlcat(dest, src, destsz);
        SIR_ASSERT_UNUSED(cat < destsz, cat);
        return 0;
#endif
    }

    return -1;
}

int _sir_fopen(FILE* restrict* restrict streamptr, const char* restrict filename,
    const char* restrict mode) {
    if (_sir_validptrptr(streamptr) && _sir_validstr(filename) && _sir_validstr(mode)) {
#if defined(__HAVE_STDC_SECURE_OR_EXT1__)
        int ret = fopen_s(streamptr, filename, mode);
        if (0 != ret) {
            (void)_sir_handleerr(ret);
            return -1;
        }
        return 0;
#else
        *streamptr = fopen(filename, mode);
        if (!*streamptr) {
            (void)_sir_handleerr(errno);
            return -1;
        }
        return 0;
#endif
    }

    return -1;
}

bool _sir_getchar(char* input) {
    if (!_sir_validptr(input))
        return false;

#if defined(__WIN__)
# if defined(__EMBARCADEROC__)
     *input = (char)getch();
# else
     *input = (char)_getch();
# endif
     return true;
#else /* !__WIN__ */
    struct termios cur = {0}, new = {0};
    if (0 != tcgetattr(STDIN_FILENO, &cur))
        return _sir_handleerr(errno);

    memcpy(&new, &cur, sizeof(struct termios));
    new.c_lflag &= ~(ICANON | ECHO);

    if (0 != tcsetattr(STDIN_FILENO, TCSANOW, &new))
        return _sir_handleerr(errno);

    *input = (char)getchar();

    return 0 == tcsetattr(STDIN_FILENO, TCSANOW, &cur) ? true
        : _sir_handleerr(errno);
#endif
}

1	/*
2	* sirhelpers.c
3	*
4	* Author: Ryan M. Lederman <lederman@gmail.com>
5	* Copyright: Copyright (c) 2018-2023
6	* Version: 2.2.3
7	* License: The MIT License (MIT)
8	*
9	* Permission is hereby granted, free of charge, to any person obtaining a copy of
10	* this software and associated documentation files (the "Software"), to deal in
11	* the Software without restriction, including without limitation the rights to
12	* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
13	* the Software, and to permit persons to whom the Software is furnished to do so,
14	* subject to the following conditions:
15	*
16	* The above copyright notice and this permission notice shall be included in all
17	* copies or substantial portions of the Software.
18	*
19	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
20	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
21	* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
22	* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
23	* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
24	* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
25	*/
26	#include "sir/helpers.h"
27	#include "sir/errors.h"
28
29	void __sir_safefree(void** pp) {	884,176✔
30	if (!pp \|\| !*pp)	884,176✔
31	return;	227,509✔
32
33	free(*pp);	614,130✔
34	*pp = NULL;	614,130✔
35	}
36
37	void _sir_safeclose(int* restrict fd) {	269✔
38	if (!fd \|\| 0 > *fd)	269✔
39	return;	×
40
41	if (-1 == close(*fd))	269✔
42	(void)_sir_handleerr(errno);	×
43
44	*fd = -1;	269✔
45	}
46
47	void _sir_safefclose(FILE* restrict* restrict f) {	36,882✔
48	if (!f \|\| !*f)	36,882✔
49	return;	4✔
50
51	if (0 != fclose(*f))	36,878✔
52	(void)_sir_handleerr(errno);	×
53
54	*f = NULL;	36,878✔
55	}
56
57	bool _sir_validfd(int fd) {	111✔
58	/** stdin, stdout, stderr use up 0, 1, 2 */
59	if (2 >= fd)	111✔
60	return _sir_handleerr(EBADF);	69✔
61
62	#if !defined(__WIN__)
63	int ret = fcntl(fd, F_GETFL);	42✔
64	#else /* __WIN__ */
65	# if !defined(SIR_MSVCRT_MINGW)
66	invalparamfn old = _set_thread_local_invalid_parameter_handler(_sir_invalidparameter);
67	# endif
68	struct _stat st;
69	int ret = _fstat(fd, &st);
70	# if !defined(SIR_MSVCRT_MINGW)
71	_set_thread_local_invalid_parameter_handler(old);
72	# endif
73	#endif
74	return (-1 != ret \|\| EBADF != errno) ? true : _sir_handleerr(errno);	42✔
75	}
76
77	/** Validates a sir_update_config_data structure. */
78	bool _sir_validupdatedata(sir_update_config_data* data) {	145,602✔
79	if (!_sir_validptr(data))	145,602✔
80	return false;	×
81
82	bool valid = true;	121,455✔
83	if ((data->fields & SIRU_ALL) == 0U \|\| (data->fields & ~SIRU_ALL) != 0U)	145,598✔
84	valid = false;	×
85
86	if (valid && _sir_bittest(data->fields, SIRU_LEVELS))	145,600✔
87	valid &= (_sir_validptrnofail(data->levels) &&	2,662✔
88	_sir_validlevels(*data->levels));	1,331✔
89
90	if (valid && _sir_bittest(data->fields, SIRU_OPTIONS))	145,570✔
91	valid &= (_sir_validptrnofail(data->opts) &&	287,523✔
92	_sir_validopts(*data->opts));	143,846✔
93
94	if (valid && _sir_bittest(data->fields, SIRU_SYSLOG_ID))	145,225✔
95	valid &= _sir_validstrnofail(data->sl_identity);	125✔
96
97	if (valid && _sir_bittest(data->fields, SIRU_SYSLOG_CAT))	145,178✔
98	valid &= _sir_validstrnofail(data->sl_category);	98✔
99
100	if (!valid) {	145,143✔
101	(void)_sir_seterror(_SIR_E_INVALID);	28✔
102	SIR_ASSERT(!valid);	×
103	}
104
105	return valid;	121,085✔
106	}
107
108	bool _sir_validlevels(sir_levels levels) {	78,024✔
109	if ((SIRL_ALL == levels \|\| SIRL_NONE == levels) \|\|	79,809✔
110	((_sir_bittest(levels, SIRL_INFO) \|\|	3,338✔
111	_sir_bittest(levels, SIRL_DEBUG) \|\|	2,468✔
112	_sir_bittest(levels, SIRL_NOTICE) \|\|	2,023✔
113	_sir_bittest(levels, SIRL_WARN) \|\|	1,662✔
114	_sir_bittest(levels, SIRL_ERROR) \|\|	1,117✔
115	_sir_bittest(levels, SIRL_CRIT) \|\|	616✔
116	_sir_bittest(levels, SIRL_ALERT) \|\|	370✔
117	_sir_bittest(levels, SIRL_EMERG)) &&	2,166✔
118	((levels & ~SIRL_ALL) == 0U)))
119	return true;	64,974✔
120
121	_sir_selflog("invalid levels: %04"PRIx16, levels);	99✔
122	return _sir_seterror(_SIR_E_LEVELS);	104✔
123	}
124
125	bool _sir_validlevel(sir_level level) {	4,564,960✔
126	if (SIRL_INFO == level \|\| SIRL_DEBUG == level \|\|	4,564,960✔
127	SIRL_NOTICE == level \|\| SIRL_WARN == level \|\|	7,602✔
128	SIRL_ERROR == level \|\| SIRL_CRIT == level \|\|	4,543✔
129	SIRL_ALERT == level \|\| SIRL_EMERG == level)	1,521✔
130	return true;	4,476,968✔
131
132	_sir_selflog("invalid level: %04"PRIx16, level);	22✔
133	return _sir_seterror(_SIR_E_LEVELS);	23✔
134	}
135
136	bool _sir_validopts(sir_options opts) {	220,738✔
137	if ((SIRO_ALL == opts \|\| SIRO_MSGONLY == opts) \|\|	342,876✔
138	((_sir_bittest(opts, SIRO_NOTIME) \|\|	236,437✔
139	_sir_bittest(opts, SIRO_NOHOST) \|\|	108,428✔
140	_sir_bittest(opts, SIRO_NOLEVEL) \|\|	701✔
141	_sir_bittest(opts, SIRO_NONAME) \|\|	576✔
142	_sir_bittest(opts, SIRO_NOMSEC) \|\|	455✔
143	_sir_bittest(opts, SIRO_NOPID) \|\|	322✔
144	_sir_bittest(opts, SIRO_NOTID) \|\|	195✔
145	_sir_bittest(opts, SIRO_NOHDR)) &&	92✔
146	((opts & ~(SIRO_MSGONLY \| SIRO_NOHDR)) == 0U)))	146,173✔
147	return true;	183,628✔
148
149	_sir_selflog("invalid options: %08"PRIx32, opts);	314✔
150	return _sir_seterror(_SIR_E_OPTIONS);	346✔
151	}
152
153	bool _sir_validtextattr(sir_textattr attr) {	168,917✔
154	switch(attr) {	168,917✔
155	case SIRTA_NORMAL:	141,618✔
156	case SIRTA_BOLD:
157	case SIRTA_DIM:
158	case SIRTA_EMPH:
159	case SIRTA_ULINE:
160	return true;	141,618✔
161	default: {	23✔
162	_sir_selflog("invalid text attr: %d", attr);	22✔
163	return _sir_seterror(_SIR_E_TEXTATTR);	23✔
164	}
165	}
166	}
167
168	bool _sir_validtextcolor(sir_colormode mode, sir_textcolor color) {	337,765✔
169	bool valid = false;	283,216✔
170	switch (mode) {	337,765✔
171	case SIRCM_16:	313,477✔
172	/* in 16-color mode:
173	* compare to 30..37, 39, 40..47, 49, 90..97, 100..107. */
174	valid = SIRTC_DEFAULT == color \|\|	313,477✔
175	(color >= 30U && color <= 37U) \|\| color == 39U \|\|	313,477✔
176	(color >= 40U && color <= 47U) \|\| color == 49U \|\|	135,234✔
177	(color >= 90U && color <= 97U) \|\| (color >= 100U && color <= 107U);	524,192✔
178	break;	262,096✔
179	case SIRCM_256:	12,098✔
180	/* in 256-color mode: compare to 0..255. sir_textcolor is unsigned,
181	* so only need to ensure it's <= 255. */
182	valid = SIRTC_DEFAULT == color \|\| color <= 255U;	12,098✔
183	break;	12,098✔
184	case SIRCM_RGB: {	12,190✔
185	/* in RGB-color mode: mask and compare to 0x00ffffff. */
186	valid = SIRTC_DEFAULT == color \|\| ((color & 0xff000000U) == 0U);	12,190✔
187	break;	12,190✔
188	}
189	case SIRCM_INVALID: // GCOVR_EXCL_START
190	default:
191	valid = false;
192	break;
193	} // GCOVR_EXCL_STOP
194
195	if (!valid) {	286,384✔
196	_sir_selflog("invalid text color for mode %d %08"PRIx32" (%"PRIu32")",	22✔
197	mode, color, color);
198	(void)_sir_seterror(_SIR_E_TEXTCOLOR);	23✔
199	}
200
201	return valid;	337,765✔
202	}
203
204	bool _sir_validcolormode(sir_colormode mode) {	169,754✔
205	switch (mode) {	169,754✔
206	case SIRCM_16:	142,344✔
207	case SIRCM_256:
208	case SIRCM_RGB:
209	return true;	142,344✔
210	case SIRCM_INVALID:	23✔
211	default: {
212	_sir_selflog("invalid color mode: %d", mode);	22✔
213	return _sir_seterror(_SIR_E_COLORMODE);	23✔
214	}
215	}
216	}
217
218	int _sir_strncpy(char* restrict dest, size_t destsz, const char* restrict src,	4,338,652✔
219	size_t count) {
220	if (_sir_validptr(dest) && _sir_validstr(src)) {	4,338,652✔
221	#if defined(__HAVE_STDC_SECURE_OR_EXT1__)
222	int ret = strncpy_s(dest, destsz, src, count);
223	if (0 != ret) {
224	(void)_sir_handleerr(ret);
225	return -1;
226	}
227	return 0;
228	#else
229	SIR_UNUSED(count);
230	size_t cpy = strlcpy(dest, src, destsz);	4,283,193✔
231	SIR_ASSERT_UNUSED(cpy < destsz, cpy);	4,314,909✔
232	return 0;	4,330,765✔
233	#endif
234	}
235
236	return -1;	7,882✔
237	}
238
239	int _sir_strncat(char* restrict dest, size_t destsz, const char* restrict src,	29,252,873✔
240	size_t count) {
241	if (_sir_validptr(dest) && _sir_validstr(src)) {	29,252,873✔
242	#if defined(__HAVE_STDC_SECURE_OR_EXT1__)
243	int ret = strncat_s(dest, destsz, src, count);
244	if (0 != ret) {
245	(void)_sir_handleerr(ret);
246	return -1;
247	}
248	return 0;
249	#else
250	SIR_UNUSED(count);
251	size_t cat = strlcat(dest, src, destsz);	28,878,765✔
252	SIR_ASSERT_UNUSED(cat < destsz, cat);	29,126,743✔
253	return 0;	29,247,276✔
254	#endif
255	}
256
257	return -1;	6,168✔
258	}
259
260	int _sir_fopen(FILE* restrict* restrict streamptr, const char* restrict filename,	36,974✔
261	const char* restrict mode) {
262	if (_sir_validptrptr(streamptr) && _sir_validstr(filename) && _sir_validstr(mode)) {	36,974✔
263	#if defined(__HAVE_STDC_SECURE_OR_EXT1__)
264	int ret = fopen_s(streamptr, filename, mode);
265	if (0 != ret) {
266	(void)_sir_handleerr(ret);
267	return -1;
268	}
269	return 0;
270	#else
271	*streamptr = fopen(filename, mode);	36,974✔
272	if (!*streamptr) {	36,974✔
273	(void)_sir_handleerr(errno);	74✔
274	return -1;	74✔
275	}
276	return 0;	30,718✔
277	#endif
278	}
279
280	return -1;	×
281	}
282
283	bool _sir_getchar(char* input) {	1✔
284	if (!_sir_validptr(input))	1✔
285	return false;	×
286
287	#if defined(__WIN__)
288	# if defined(__EMBARCADEROC__)
289	*input = (char)getch();
290	# else
291	*input = (char)_getch();
292	# endif
293	return true;
294	#else /* !__WIN__ */
295	struct termios cur = {0}, new = {0};	1✔
296	if (0 != tcgetattr(STDIN_FILENO, &cur))	1✔
297	return _sir_handleerr(errno);	×
298
299	memcpy(&new, &cur, sizeof(struct termios));	×
300	new.c_lflag &= ~(ICANON \| ECHO);	1✔
301
302	if (0 != tcsetattr(STDIN_FILENO, TCSANOW, &new))	1✔
303	return _sir_handleerr(errno);	×
304
305	*input = (char)getchar();	1✔
306
307	return 0 == tcsetattr(STDIN_FILENO, TCSANOW, &cur) ? true	1✔
308	: _sir_handleerr(errno);	1✔
309	#endif
310	}

aremmell / libsir / 433

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