char *mget_read_file(const char *fname, size_t *size)
{
int fd;
ssize_t nread;
char *buf = NULL;
if (!fname)
return NULL;
if (strcmp(fname,"-")) {
if ((fd = open(fname, O_RDONLY)) != -1) {
struct stat st;
if (fstat(fd, &st) == 0) {
off_t total = 0;
buf = xmalloc(st.st_size + 1);
while (total < st.st_size && (nread = read(fd, buf + total, st.st_size - total)) > 0) {
total += nread;
}
buf[total] = 0;
if (size)
*size = total;
if (total != st.st_size)
error_printf(_("WARNING: Size of %s changed from %lld to %lld while reading. This may lead to unwanted results !\n"),
fname, (long long)st.st_size, (long long)total);
} else
error_printf(_("Failed to fstat %s\n"), fname);
close(fd);
} else
error_printf(_("Failed to open %s\n"), fname);
} else {
// read data from STDIN.
char tmp[4096];
mget_buffer_t buffer;
mget_buffer_init(&buffer, NULL, 4096);
while ((nread = read(STDIN_FILENO, tmp, sizeof(tmp))) > 0) {
mget_buffer_memcat(&buffer, tmp, nread);
}
if (size)
*size = buffer.length;
buf = buffer.data;
buffer.data = NULL;
mget_buffer_deinit(&buffer);
}
return buf;
}
static void css_parse_localfile(const char *fname, mget_iri_t *base, const char *encoding)
{
struct css_context context = { .base = base, .encoding = encoding };
mget_buffer_init(&context.uri_buf, NULL, 128);
mget_css_parse_file(fname, css_parse_uri, css_parse_encoding, &context);
if (context.encoding_allocated)
xfree(context.encoding);
mget_buffer_deinit(&context.uri_buf);
}
int main(void)
{
int it;
char sbuf[128];
mget_buffer_t buf;
mget_buffer_init(&buf,sbuf,sizeof(sbuf));
for (it = 0; it < 10000000; it++) {
// buffer: 0.239s libc: 0.018s (gcc replaces sprintf(%s) by strcpy())
// snprintf(sbuf,sizeof(sbuf),"%s", "teststring sabbeldi heidewitzka\n");
// buffer_printf2(&buf,"%s", "teststring sabbeldi heidewitzka\n");
// buffer: 0.306s libc: 1.040s
// sprintf(sbuf,"%s\n", "teststring sabbeldi heidewitzka\n");
// buffer_printf2(&buf,"%s\n", "teststring sabbeldi heidewitzka\n");
// function call and loop overhead: buffer: 0.072s libc: 0.390s
// buffer_printf2(&buf, "", "teststring sabbeldi heidewitzka\n");
// sprintf(sbuf, "", "teststring sabbeldi heidewitzka\n");
// buffer: 0.392s libc: 0.838s
// sprintf(sbuf,"%.*s\n", 17, "teststring sabbeldi heidewitzka\n");
// buffer_printf2(&buf,"%.*s\n", 17, "teststring sabbeldi heidewitzka\n");
// buffer: 0.407s libc: 0.960s
// sprintf(sbuf,"%d\n", it);
// buffer_printf2(&buf,"%d\n", it);
// buffer: 0.643s libc/sprintf: 1.251s libc/snprintf: 1.253s
// snprintf(sbuf,sizeof(sbuf),"%10.*d\n", 8, it);
// sprintf(sbuf,"%10.*d\n", 8, it);
// buffer_printf2(&buf,"%10.*d\n", 8, it);
// buffer: 0.456s libc: 0.867s
// sprintf(sbuf,"%X\n", it);
mget_buffer_printf2(&buf,"%X\n", it);
// buffer: 0.955s libc: 1.648s
// sprintf(sbuf,"teststring %s sabbeldi %d\n", "[foobar foobar foobar]", it);
// buffer_printf2(&buf,"teststring %s sabbeldi %d\n", "[foobar foobar foobar]", it);
}
mget_buffer_deinit(&buf);
return 0;
}
mget_iri_t *mget_iri_parse_base(mget_iri_t *base, const char *url, const char *encoding)
{
mget_iri_t *iri;
if (base) {
mget_buffer_t buf;
char sbuf[256];
mget_buffer_init(&buf, sbuf, sizeof(sbuf));
iri = mget_iri_parse(mget_iri_relative_to_abs(base, url, strlen(url), &buf), encoding);
mget_buffer_deinit(&buf);
} else {
// no base: just check URL for being an absolute URI
iri = mget_iri_parse(mget_iri_relative_to_abs(NULL, url, strlen(url), NULL), encoding);
}
return iri;
}
static void test_buffer(void)
{
char sbuf[16];
mget_buffer_t buf, *bufp;
// testing buffer on stack, using initial stack memory
// without resizing
mget_buffer_init(&buf, sbuf, sizeof(sbuf));
mget_buffer_deinit(&buf);
// testing buffer on stack, using initial stack memory
// with resizing
mget_buffer_init(&buf, sbuf, sizeof(sbuf));
_test_buffer(&buf, "Test 1");
mget_buffer_deinit(&buf);
// testing buffer on stack, using initial heap memory
// without resizing
mget_buffer_init(&buf, NULL, 16);
mget_buffer_deinit(&buf);
// testing buffer on stack, using initial heap memory
// with resizing
mget_buffer_init(&buf, NULL, 16);
_test_buffer(&buf, "Test 2");
mget_buffer_deinit(&buf);
// testing buffer on heap, using initial stack memory
// without resizing
bufp = mget_buffer_init(NULL, sbuf, sizeof(sbuf));
mget_buffer_deinit(bufp);
bufp = mget_buffer_init(NULL, sbuf, sizeof(sbuf));
mget_buffer_free(&bufp);
// testing buffer on heap, using initial stack memory
// with resizing
bufp = mget_buffer_init(NULL, sbuf, sizeof(sbuf));
_test_buffer(bufp, "Test 3");
mget_buffer_deinit(bufp);
bufp = mget_buffer_init(NULL, sbuf, sizeof(sbuf));
_test_buffer(bufp, "Test 4");
mget_buffer_free(&bufp);
// testing buffer on heap, using initial heap memory
// without resizing
bufp = mget_buffer_alloc(16);
mget_buffer_free(&bufp);
// testing buffer on heap, using initial heap memory
// with resizing
bufp = mget_buffer_alloc(16);
_test_buffer(bufp, "Test 5");
mget_buffer_free(&bufp);
// check that appending works
mget_buffer_init(&buf, sbuf, sizeof(sbuf));
mget_buffer_strcpy(&buf, "A");
mget_buffer_strcat(&buf, "B");
mget_buffer_memcat(&buf, "C", 1);
mget_buffer_memset_append(&buf, 'D', 1);
mget_buffer_printf_append2(&buf, "%s", "E");
if (!strcmp(buf.data, "ABCDE"))
ok++;
else {
failed++;
info_printf("test_buffer.append: got %s (expected %s)\n", buf.data, "ABCDE");
}
mget_buffer_deinit(&buf);
// test mget_buffer_trim()
mget_buffer_init(&buf, sbuf, sizeof(sbuf));
for (int mid_ws = 0; mid_ws <= 2; mid_ws++) {
char expected[16];
snprintf(expected, sizeof(expected), "x%.*sy", mid_ws, " ");
for (int lead_ws = 0; lead_ws <= 2; lead_ws++) {
for (int trail_ws = 0; trail_ws <= 2; trail_ws++) {
mget_buffer_printf2(&buf, "%.*sx%.*sy%.*s", lead_ws, " ", mid_ws, " ", trail_ws, " ");
mget_buffer_trim(&buf);
if (!strcmp(buf.data, expected))
ok++;
else {
failed++;
info_printf("test_buffer_trim: got '%s' (expected '%s') (%d, %d, %d)\n", buf.data, expected, lead_ws, mid_ws, trail_ws);
}
}
}
}
mget_buffer_deinit(&buf);
}
static void test_buffer_printf(void)
{
char buf_static[32];
mget_buffer_t buf;
// testing buffer_printf() by comparing it with C standard function sprintf()
static const char *zero_padded[] = { "", "0" };
static const char *left_adjust[] = { "", "-" };
static const long long number[] = { 0, 1LL, -1LL, 10LL, -10LL, 18446744073709551615ULL };
static const char *modifier[] = { "", "h", "hh", "l", "ll", "z" }; // %L... won't work on OpenBSD5.0
static const char *conversion[] = { "d", "i", "u", "o", "x", "X" };
char fmt[32], result[64], string[32];
size_t z, a, it, n, c, m;
int width, precision;
mget_buffer_init(&buf, buf_static, sizeof(buf_static));
mget_buffer_printf2(&buf, "%s://%s", "http", "host");
if (strcmp("http://host", buf.data)) {
failed++;
info_printf("%s: Failed with format ('%%s://%%s','http','host'): '%s' != 'http://host'\n", __func__, buf.data);
return;
} else
ok++;
for (z = 0; z < countof(zero_padded); z++) {
for (a = 0; a < countof(left_adjust); a++) {
for (width = -1; width < 12; width++) {
for (precision = -1; precision < 12; precision++) {
// testing %s stuff
// Solaris' sprintf uses spaces instead of 0s for e.g. %03s padding
if (width == -1) {
if (precision == -1) {
sprintf(fmt,"abc%%%s%ssxyz", left_adjust[a], zero_padded[z]);
} else {
sprintf(fmt,"abc%%%s%s.%dsxyz", left_adjust[a], zero_padded[z], precision);
}
} else {
if (precision == -1) {
sprintf(fmt,"abc%%%s%s%dsxyz", left_adjust[a], zero_padded[z], width);
} else {
sprintf(fmt,"abc%%%s%s%d.%dsxyz", left_adjust[a], zero_padded[z], width, precision);
}
}
for (it = 0; it < sizeof(string); it++) {
memset(string, 'a', it);
string[it] = 0;
#if defined __clang__ || __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wformat-nonliteral"
#endif
sprintf(result, fmt, string);
mget_buffer_printf2(&buf, fmt, string);
#if defined __clang__ || __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5)
#pragma GCC diagnostic pop
#endif
if (strcmp(result, buf.data)) {
failed++;
info_printf("%s: Failed with format ('%s','%s'): '%s' != '%s'\n", __func__, fmt, string, buf.data, result);
return;
} else {
// info_printf("%s: format ('%s','%s'): '%s' == '%s'\n", __func__, fmt, string, buf.data, result);
ok++;
}
}
if (width == -1) {
if (precision == -1) {
sprintf(fmt,"%%%s%ss", left_adjust[a], zero_padded[z]);
} else {
sprintf(fmt,"%%%s%s.*s", left_adjust[a], zero_padded[z]);
}
} else {
if (precision == -1) {
sprintf(fmt,"%%%s%s*s", left_adjust[a], zero_padded[z]);
} else {
sprintf(fmt,"%%%s%s*.*s", left_adjust[a], zero_padded[z]);
}
}
for (it = 0; it < sizeof(string); it++) {
memset(string, 'a', it);
string[it] = 0;
#if defined __clang__ || __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wformat-nonliteral"
#endif
if (width == -1) {
if (precision == -1) {
sprintf(result, fmt, string);
mget_buffer_printf2(&buf, fmt, string);
} else {
sprintf(result, fmt, precision, string);
mget_buffer_printf2(&buf, fmt, precision, string);
}
} else {
if (precision == -1) {
sprintf(result, fmt, width, string);
mget_buffer_printf2(&buf, fmt, width, string);
} else {
sprintf(result, fmt, width, precision, string);
mget_buffer_printf2(&buf, fmt, width, precision, string);
}
}
#if defined __clang__ || __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5)
#pragma GCC diagnostic pop
#endif
if (strcmp(result, buf.data)) {
failed++;
info_printf("%s: Failed with format ('%s','%s'): '%s' != '%s'\n", __func__, fmt, string, buf.data, result);
return;
} else {
// info_printf("%s: format ('%s','%s'): '%s' == '%s'\n", __func__, fmt, string, buf.data, result);
ok++;
}
}
// testing integer stuff
for (m = 0; m < countof(modifier); m++) {
for (c = 0; c < countof(conversion); c++) {
if (width == -1) {
if (precision == -1) {
sprintf(fmt,"%%%s%s%s%s", left_adjust[a], zero_padded[z], modifier[m], conversion[c]);
} else {
sprintf(fmt,"%%%s%s.%d%s%s", left_adjust[a], zero_padded[z], precision, modifier[m], conversion[c]);
}
} else {
if (precision == -1) {
sprintf(fmt,"%%%s%s%d%s%s", left_adjust[a], zero_padded[z], width, modifier[m], conversion[c]);
} else {
sprintf(fmt,"%%%s%s%d.%d%s%s", left_adjust[a], zero_padded[z], width, precision, modifier[m], conversion[c]);
}
}
for (n = 0; n < countof(number); n++) {
#if defined __clang__ || __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wformat-nonliteral"
#endif
sprintf(result, fmt, number[n]);
mget_buffer_printf2(&buf, fmt, number[n]);
#if defined __clang__ || __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5)
#pragma GCC diagnostic pop
#endif
if (strcmp(result, buf.data)) {
failed++;
info_printf("%s: Failed with format ('%s','%lld'): '%s' != '%s'\n", __func__, fmt, number[n], buf.data, result);
// return;
} else {
// info_printf("%s: format ('%s','%lld'): '%s' == '%s'\n", __func__, fmt, number[n], buf.data, result);
ok++;
}
}
}
}
}
}
}
}
mget_buffer_deinit(&buf);
}
