Mercurial > sci

comparison libsci/util.c @ 33:1d0ddf9e6efd

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
misc: general documentation
author David Demelier <markand@malikania.fr>
date Thu, 04 Aug 2022 16:47:10 +0200
parents lib/util.c@081e1c258e64
children e52c762d8ba8
comparison
equal deleted inserted replaced
32:081e1c258e64 33:1d0ddf9e6efd
1 /*
2 * util.c -- miscellaneous utilities
3 *
4 * Copyright (c) 2021-2022 David Demelier <markand@malikania.fr>
5 *
6 * Permission to use, copy, modify, and/or distribute this software for any
7 * purpose with or without fee is hereby granted, provided that the above
8 * copyright notice and this permission notice appear in all copies.
9 *
10 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
11 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
13 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
15 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
16 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17 */
18
19 #include <sys/stat.h>
20 #include <assert.h>
21 #include <errno.h>
22 #include <fcntl.h>
23 #include <libgen.h>
24 #include <limits.h>
25 #include <stdarg.h>
26 #include <stdio.h>
27 #include <stdlib.h>
28 #include <string.h>
29 #include <unistd.h>
30
31 #include "util.h"
32
33 void *
34 util_malloc(size_t size)
35 {
36 void *ret;
37
38 if (!(ret = malloc(size)))
39 util_die("malloc: %s\n", strerror(errno));
40
41 return ret;
42 }
43
44 void *
45 util_calloc(size_t n, size_t size)
46 {
47 void *ret;
48
49 if (!(ret = calloc(n, size)))
50 util_die("calloc: %s\n", strerror(errno));
51
52 return ret;
53 }
54
55 void *
56 util_realloc(void *ptr, size_t size)
57 {
58 void *ret;
59
60 if (!(ret = realloc(ptr, size)) && size)
61 util_die("realloc: %s\n", strerror(errno));
62
63 return ret;
64 }
65
66 void *
67 util_memdup(const void *ptr, size_t size)
68 {
69 void *ret;
70
71 if (!(ret = malloc(size)))
72 util_die("malloc: %s\n", strerror(errno));
73
74 return memcpy(ret, ptr, size);
75 }
76
77 char *
78 util_strdup(const char *src)
79 {
80 char *ret;
81
82 if (!(ret = strdup(src)))
83 util_die("strdup: %s\n", strerror(errno));
84
85 return ret;
86 }
87
88 char *
89 util_strndup(const char *src, size_t n)
90 {
91 assert(src);
92
93 char *ret;
94
95 if (!(ret = strndup(src, n)))
96 util_die("strndup: %s\n", strerror(errno));
97
98 return ret;
99 }
100
101 char *
102 util_basename(const char *str)
103 {
104 static char ret[PATH_MAX];
105 char tmp[PATH_MAX];
106
107 util_strlcpy(tmp, str, sizeof (tmp));
108 util_strlcpy(ret, basename(tmp), sizeof (ret));
109
110 return ret;
111 }
112
113 char *
114 util_dirname(const char *str)
115 {
116 static char ret[PATH_MAX];
117 char tmp[PATH_MAX];
118
119 util_strlcpy(tmp, str, sizeof (tmp));
120 util_strlcpy(ret, dirname(tmp), sizeof (ret));
121
122 return ret;
123 }
124
125 FILE *
126 util_fmemopen(void *buf, size_t size, const char *mode)
127 {
128 FILE *fp;
129
130 if (!(fp = fmemopen(buf, size, mode)))
131 util_die("fmemopen: %s\n", strerror(errno));
132
133 return fp;
134 }
135
136 FILE *
137 util_open_memstream(char **out, size_t *outsz)
138 {
139 assert(out);
140 assert(outsz);
141
142 FILE *fp;
143
144 if (!(fp = open_memstream(out, outsz)))
145 util_die("open_memstream: %s\n", strerror(errno));
146
147 return fp;
148 }
149
150 char *
151 util_read(const char *path)
152 {
153 int fd;
154 struct stat st;
155 char *ret;
156
157 if ((fd = open(path, O_RDONLY)) < 0)
158 return NULL;
159 if (fstat(fd, &st) < 0)
160 return close(fd), NULL;
161
162 ret = util_calloc(1, st.st_size + 1);
163
164 if (read(fd, ret, st.st_size) != st.st_size) {
165 free(ret);
166 ret = NULL;
167 }
168
169 close(fd);
170
171 return ret;
172 }
173
174 void
175 util_die(const char *fmt, ...)
176 {
177 assert(fmt);
178
179 va_list ap;
180
181 va_start(ap, fmt);
182 vfprintf(stderr, fmt, ap);
183 va_end(ap);
184 exit(1);
185 }
186
187 json_t *
188 util_json_pack(const char *fmt, ...)
189 {
190 va_list ap;
191 json_t *doc;
192 json_error_t err;
193
194 va_start(ap, fmt);
195 doc = json_vpack_ex(&err, 0, fmt, ap);
196 va_end(ap);
197
198 if (!doc)
199 util_die("json_vpack_ex: %s\n", err.text);
200
201 return doc;
202 }
203
204 char *
205 util_json_dump(const json_t *json)
206 {
207 assert(json);
208
209 char *ret;
210
211 if (!(ret = json_dumps(json, JSON_COMPACT)))
212 util_die("json_dump: %s\n", strerror(ENOMEM));
213
214 return ret;
215 }