1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
|
/*
* Copyright 2018 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef NANO_EXPORTER_UTIL_H_
#define NANO_EXPORTER_UTIL_H_ 1
#include <stdbool.h>
#include <stddef.h>
#include <stdio.h>
// character buffers
/** Opaque type for an internally maintained character (byte) buffer. */
typedef struct bbuf bbuf;
/** Allocates a new buffer with \p initial_size, growing up to \p max_size. */
bbuf *bbuf_alloc(size_t initial_size, size_t max_size);
/** Frees all the storage associated with \p buf. */
void bbuf_free(bbuf *buf);
/** Clears the contents of the buffer, resetting it to the empty string. */
void bbuf_reset(bbuf *buf);
/** Returns the current length of the buffer contents. */
size_t bbuf_len(bbuf *buf);
/** Appends \p len bytes from address \p src to the buffer \p buf. */
void bbuf_put(bbuf *buf, const void *src, size_t len);
/** Appends the null-terminated string at \p src to the buffer \p buf. */
void bbuf_puts(bbuf *buf, const char *src);
/** Appends a single byte \p c to \p buf. */
void bbuf_putc(bbuf *buf, int c);
/** Appends a formatted string to \p buf. */
void bbuf_putf(bbuf *buf, const char *fmt, ...);
/**
* Returns the contents of \p buf, writing the length to \p len.
*
* There may not be a terminating '\0' byte after the contents. And even if there is, the returned
* length will not include it.
*/
char *bbuf_get(struct bbuf *buf, size_t *len);
/** Compares the contents of \p buf to the string in \p other, in shortlex order. */
int bbuf_cmp(bbuf *buf, const char *other);
// string lists
/** Type for a singly linked list of strings. */
struct slist {
struct slist *next;
char data[];
};
/** Splits \p str into a list of strings, using \p delim as the delimiter. */
struct slist *slist_split(const char *str, const char *delim);
/**
* Appends \p str to a string list.
*
* The address of the new element is written to the location pointed by \p prev, which should be
* either the `next` pointer of the last element of an existing list, or (for an empty list) the
* future pointer to a list head. The return value will point at the `next` pointer of the newly
* allocated element, so code like the following can be used to iteratively construct a list:
*
* struct slist *list = 0;
* struct slist **prev = &list;
* while (...) {
* // do something to get a string 'str'
* prev = slist_append(prev, str);
* }
*/
struct slist **slist_append(struct slist **prev, const char *str);
/** Prepends \p str to a string list, returning the new head node. */
struct slist *slist_prepend(struct slist *list, const char *str);
/** Returns `true` if \p list contains as element the string \p key. */
bool slist_contains(const struct slist *list, const char *key);
/**
* Returns `true` if any element of \p list matches \p key.
*
* The strings must match exactly, with the exception that if the list elements ends in the '*'
* character, any \p key string that starts with the prefix before the '*' will count as matching.
*/
bool slist_matches(const struct slist *list, const char *key);
// miscellaneous utilities
/** Calls `malloc(size)` and aborts if memory allocation failed. */
void *must_malloc(size_t size);
/** Calls `realloc(ptr, size)` and aborts if memory allocation failed. */
void *must_realloc(void *ptr, size_t size);
/** Calls `strdup(src)` and aborts if memory allocation failed. */
char *must_strdup(const char *src);
/**
* Reads a full line from \p stream into buffer \p s of size \p size.
*
* This function is otherwise identical to standard `fgets`, except that if a full line did not fit
* in the input buffer, characters are discarded from the stream up to and including the next
* newline character. If the file ends before a newline is encountered, a null pointer is
* required. This way this function always reads complete lines, which are just truncated if they
* don't fit in the buffer.
*/
char *fgets_line(char *s, int size, FILE *stream);
/**
* Fully writes the contents of \p buf (\p len bytes) into file descriptor \p fd.
*
* If not all bytes could be written, this function just tries again. It returns 0 on success, or -1
* if any of the `write` calls failed with an error.
*/
int write_all(int fd, const void *buf, size_t len);
#ifndef PATH
/** Macro for constructing absolute paths in release, relative paths in tests. */
#define PATH(p) p
#endif // PATH
#endif // NANO_EXPORTER_UTIL_H_
|
