ObjFW  Diff

Differences From Artifact [cd42320784]:

To Artifact [35d52654ca]:

  • File src/of_asprintf.m — part of check-in [7267f55840] at 2021-01-01 18:36:01 on branch trunk — Better fallback asprintf() implementation

    Instead of trying if it's C99 compliant and falling back to a 64 KB
    buffer if it is not, resize the buffer in powers of 2 until it fits.

    The problem is that some implementations that are not compliant with C99
    don't just return -1 for a length of 0, but actually crash (e.g. HP-UX). (user: js, size: 16630) [annotate] [blame] [check-ins using]


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
129
130
131
132


133

134

135
136
137
138
139
140
141
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
129

130
131
132
133
134
135
136
137







-
+
-

-
+

-
-
-
+
+
-
-
-
-

-
-
+
+

-
-
+
+

+
+
-
-
+
+
+
-
-
-
+
+

+
+
-
+
-
-
-
-
-
+
+

+
-
+







}
#endif

#ifndef HAVE_ASPRINTF
static int
vasprintf(char **string, const char *format, va_list arguments)
{
	int expectedLength, length;
	size_t length, bufferLength = 128;
	va_list argumentsCopy;

	va_copy(argumentsCopy, arguments);
	*string = NULL;

	expectedLength = vsnprintf(NULL, 0, format, argumentsCopy);
	if (expectedLength == -1)
		/*
	for (;;) {
		free(*string);
		 * We have no way to know how large it is. Let's try 64 KB and
		 * hope.
		 */
		expectedLength = 65535;

	if ((*string = malloc((size_t)expectedLength + 1)) == NULL)
		return -1;
		if ((*string = malloc(bufferLength)) == NULL)
			return -1;

	length = vsnprintf(*string, (size_t)expectedLength + 1,
	    format, arguments);
		length = vsnprintf(*string, bufferLength - 1, format,
		    arguments);

		if (length > 0 && (size_t)length < bufferLength - 1)
			break;
	if (length == -1 || length > expectedLength) {
		free(*string);

		if (bufferLength > INT_MAX / 2) {
			free(*string);
		*string = NULL;
		return -1;
	}
			return -1;
		}

		bufferLength <<= 1;
	}
	/*

	 * In case we could not determine the size, resize to the actual size
	 * needed, but ignore any failure to do so.
	 */
	if (length < expectedLength) {
		char *resized;
	if (length != bufferLength - 1) {
		char *resized = realloc(*string, length + 1);

		/* Ignore if making it smaller failed. */
		if ((resized = realloc(*string, length + 1)) != NULL)
		if (resized != NULL)
			*string = resized;
	}

	return length;
}

static int