ReactOS 0.4.16-dev-927-g467dec4
Functions
scanf.c File Reference
#include <stdio.h>
#include <math.h>
#include "windef.h"
#include "winbase.h"
#include "winnls.h"
#include "wine/test.h"
Include dependency graph for scanf.c:

Go to the source code of this file.

Functions

static int WINAPIV vsscanf_wrapper (unsigned __int64 options, const char *str, size_t len, const char *format,...)
 
static void test_sscanf (void)
 
 START_TEST (scanf)
 

Function Documentation

◆ START_TEST()

START_TEST ( scanf  )

Definition at line 327 of file scanf.c.

328{
329 test_sscanf();
330}
test_sscanf
static void test_sscanf(void)
Definition: scanf.c:60

◆ test_sscanf()

static void test_sscanf ( void  )
static

Definition at line 40 of file scanf.c.

41{
42 static const float float1 = -82.6267f, float2 = 27.76f;
43 char buffer[100], buffer1[100];
44 int result, ret, hour, min, count;
45 LONGLONG result64;
46 DWORD_PTR result_ptr;
47 char c;
48 void *ptr;
49 float ret_float1, ret_float2;
50 double double_res;
51 unsigned int i;
52 size_t ret_size;
53
54 static const unsigned int tests[] =
55 {
56 0,
57 _CRT_INTERNAL_SCANF_LEGACY_WIDE_SPECIFIERS,
58 _CRT_INTERNAL_SCANF_LEGACY_MSVCRT_COMPATIBILITY,
59 };
60
61 for (i = 0; i < ARRAY_SIZE(tests); ++i)
62 {
63 ret = vsscanf_wrapper(tests[i], "", -1, "%d", &result);
64 ok(ret == EOF, "sscanf returned %d for flags %#x\n", ret, tests[i]);
65
66 ret = vsscanf_wrapper(tests[i], "000000000046F170", -1, "%p", &ptr);
67 ok(ret == 1, "sscanf returned %d for flags %#x\n", ret, tests[i]);
68 ok(ptr == (void *)0x46f170, "sscanf reads %p for flags %#x\n", ptr, tests[i]);
69
70 ret = vsscanf_wrapper(tests[i], "0046F171", -1, "%p", &ptr);
71 ok(ret == 1, "sscanf returned %d for flags %#x\n", ret, tests[i]);
72 ok(ptr == (void *)0x46f171, "sscanf reads %p for flags %#x\n", ptr, tests[i]);
73
74 ret = vsscanf_wrapper(tests[i], "46F172", -1, "%p", &ptr);
75 ok(ret == 1, "sscanf returned %d for flags %#x\n", ret, tests[i]);
76 ok(ptr == (void *)0x46f172, "sscanf reads %p for flags %#x\n", ptr, tests[i]);
77
78 ret = vsscanf_wrapper(tests[i], "0x46F173", -1, "%p", &ptr);
79 ok(ret == 1, "sscanf returned %d for flags %#x\n", ret, tests[i]);
80 todo_wine ok(ptr == (void *)0x46f173, "sscanf reads %p for flags %#x\n", ptr, tests[i]);
81
82 ret = vsscanf_wrapper(tests[i], "-46F174", -1, "%p", &ptr);
83 ok(ret == 1, "sscanf returned %d for flags %#x\n", ret, tests[i]);
84 ok(ptr == (void *)(ULONG_PTR)-0x46f174, "sscanf reads %p for flags %#x\n", ptr, tests[i]);
85
86 ret = vsscanf_wrapper(tests[i], "+46F175", -1, "%p", &ptr);
87 ok(ret == 1, "sscanf returned %d for flags %#x\n", ret, tests[i]);
88 ok(ptr == (void *)0x46f175, "sscanf reads %p for flags %#x\n", ptr, tests[i]);
89
90 ret = vsscanf_wrapper(tests[i], "1233", -1, "%p", &ptr);
91 ok(ret == 1, "sscanf returned %d for flags %#x\n", ret, tests[i]);
92 ok(ptr == (void *)0x1233, "sscanf reads %p for flags %#x\n", ptr, tests[i]);
93
94 ret = vsscanf_wrapper(tests[i], "1234", -1, "%P", &ptr);
95 todo_wine ok(ret == 0, "sscanf returned %d for flags %#x\n", ret, tests[i]);
96
97 ret = vsscanf_wrapper(tests[i], "0x519", -1, "%x", &result);
98 ok(ret == 1, "sscanf returned %d for flags %#x\n", ret, tests[i]);
99 ok(result == 0x519, "sscanf reads %#x for flags %#x\n", result, tests[i]);
100
101 ret = vsscanf_wrapper(tests[i], "0x51a", -1, "%x", &result);
102 ok(ret == 1, "sscanf returned %d for flags %#x\n", ret, tests[i]);
103 ok(result == 0x51a, "sscanf reads %#x for flags %#x\n", result, tests[i]);
104
105 ret = vsscanf_wrapper(tests[i], "0x51g", -1, "%x", &result);
106 ok(ret == 1, "sscanf returned %d for flags %#x\n", ret, tests[i]);
107 ok(result == 0x51, "sscanf reads %#x for flags %#x\n", result, tests[i]);
108
109 result = 0;
110 ret = vsscanf_wrapper(tests[i], "-1", -1, "%x", &result);
111 ok(ret == 1, "sscanf returned %d for flags %#x\n", ret, tests[i]);
112 ok(result == -1, "sscanf reads %#x for flags %#x\n", result, tests[i]);
113
114 ret = vsscanf_wrapper(tests[i], "\"%12@", -1, "%\"%%%d%@", &result);
115 todo_wine ok(ret == 0, "sscanf returned %d for flags %#x\n", ret, tests[i]);
116
117 sprintf(buffer, "%f %f", float1, float2);
118 ret = vsscanf_wrapper(tests[i], buffer, -1, "%f%f", &ret_float1, &ret_float2);
119 ok(ret == 2, "sscanf returned %d for flags %#x\n", ret, tests[i]);
120 ok(ret_float1 == float1, "got wrong float %.8e for flags %#x\n", ret_float1, tests[i]);
121 ok(ret_float2 == float2, "got wrong float %.8e for flags %#x\n", ret_float2, tests[i]);
122
123 sprintf(buffer, "%lf", 32.715);
124 ret = vsscanf_wrapper(tests[i], buffer, -1, "%lf", &double_res);
125 ok(ret == 1, "sscanf returned %d for flags %#x\n", ret, tests[i]);
126 ok(double_res == 32.715, "got wrong double %.16e for flags %#x\n", double_res, tests[i]);
127 ret = vsscanf_wrapper(tests[i], buffer, -1, "%Lf", &double_res);
128 ok(ret == 1, "sscanf returned %d for flags %#x\n", ret, tests[i]);
129 ok(double_res == 32.715, "got wrong double %.16e for flags %#x\n", double_res, tests[i]);
130
131 ret = vsscanf_wrapper(tests[i], "1.1e-30", -1, "%lf", &double_res);
132 ok(ret == 1, "sscanf returned %d for flags %#x\n", ret, tests[i]);
133 ok(double_res == 1.1e-30, "got wrong double %.16e for flags %#x\n", double_res, tests[i]);
134
135 ret = vsscanf_wrapper(tests[i], " Waverly", -1, "%*c%[^\n]", buffer);
136 ok(ret == 1, "sscanf returned %d for flags %#x\n", ret, tests[i]);
137 ok(!strcmp(buffer, " Waverly"), "got string '%s' for flags %#x\n", buffer, tests[i]);
138
139 ret = vsscanf_wrapper(tests[i], "abcefgdh", -1, "%*[a-cg-e]%c", &buffer[0]);
140 ok(ret == 1, "sscanf returned %d for flags %#x\n", ret, tests[i]);
141 ok(buffer[0] == 'd', "got char '%c' for flags %#x\n", buffer[0], tests[i]);
142
143 ret = vsscanf_wrapper(tests[i], "abcefgdh", -1, "%*[a-cd-dg-e]%c", &buffer[0]);
144 ok(ret == 1, "sscanf returned %d for flags %#x\n", ret, tests[i]);
145 ok(buffer[0] == 'h', "got char '%c' for flags %#x\n", buffer[0], tests[i]);
146
147 strcpy(buffer, "foo");
148 strcpy(buffer1, "bar");
149 ret = vsscanf_wrapper(tests[i], "a", -1, "%s%s", buffer, buffer1);
150 ok(ret == 1, "sscanf returned %d for flags %#x\n", ret, tests[i]);
151 ok(!strcmp(buffer, "a"), "got string '%s' for flags %#x\n", buffer, tests[i]);
152 ok(!strcmp(buffer1, "bar"), "got string '%s' for flags %#x\n", buffer1, tests[i]);
153
154 ret = vsscanf_wrapper(tests[i], "21:59:20", -1, "%d%n", &result, &count);
155 ok(ret == 1, "sscanf returned %d for flags %#x\n", ret, tests[i]);
156 ok(result == 21, "got wrong number %d for flags %#x\n", result, tests[i]);
157 ok(count == 2, "got wrong count %d for flags %#x\n", count, tests[i]);
158
159 ret = vsscanf_wrapper(tests[i], ":59:20", -1, "%*c%n", &count);
160 ok(ret == 0, "sscanf returned %d for flags %#x\n", ret, tests[i]);
161 ok(count == 1, "got wrong count %d for flags %#x\n", count, tests[i]);
162
163 result = 0xdeadbeef;
164 ret = vsscanf_wrapper(tests[i], "12345678", -1, "%hd", &result);
165 ok(ret == 1, "sscanf returned %d for flags %#x\n", ret, tests[i]);
166 ok(result == 0xdead614e, "got wrong number %#x for flags %#x\n", result, tests[i]);
167
168 result = 0xdeadbeef;
169 ret = vsscanf_wrapper(tests[i], "12345678", -1, "%hhd", &result);
170 ok(ret == 1, "sscanf returned %d for flags %#x\n", ret, tests[i]);
171 ok(result == 0xdeadbe4e, "got wrong number %#x for flags %#x\n", result, tests[i]);
172
173 ret = vsscanf_wrapper(tests[i], "12345678901234", -1, "%lld", &result64);
174 ok(ret == 1, "sscanf returned %d for flags %#x\n", ret, tests[i]);
175 ok(result64 == 12345678901234, "got wrong number 0x%s for flags %#x\n",
176 wine_dbgstr_longlong(result64), tests[i]);
177
178 ret = vsscanf_wrapper(tests[i], "123", -1, "%i", &result);
179 ok(ret == 1, "sscanf returned %d for flags %#x\n", ret, tests[i]);
180 ok(result == 123, "got wrong number %d for flags %#x\n", result, tests[i]);
181
182 ret = vsscanf_wrapper(tests[i], "-1", -1, "%i", &result);
183 ok(ret == 1, "sscanf returned %d for flags %#x\n", ret, tests[i]);
184 ok(result == -1, "got wrong number %d for flags %#x\n", result, tests[i]);
185
186 ret = vsscanf_wrapper(tests[i], "123", -1, "%d", &result);
187 ok(ret == 1, "sscanf returned %d for flags %#x\n", ret, tests[i]);
188 ok(result == 123, "got wrong number %d for flags %#x\n", result, tests[i]);
189
190 ret = vsscanf_wrapper(tests[i], "-1", -1, "%d", &result);
191 ok(ret == 1, "sscanf returned %d for flags %#x\n", ret, tests[i]);
192 ok(result == -1, "got wrong number %d for flags %#x\n", result, tests[i]);
193
194 ret = vsscanf_wrapper(tests[i], "017", -1, "%i", &result);
195 ok(ret == 1, "sscanf returned %d for flags %#x\n", ret, tests[i]);
196 ok(result == 15, "got wrong number %d for flags %#x\n", result, tests[i]);
197
198 ret = vsscanf_wrapper(tests[i], "0x17", -1, "%i", &result);
199 ok(ret == 1, "sscanf returned %d for flags %#x\n", ret, tests[i]);
200 ok(result == 23, "got wrong number %d for flags %#x\n", result, tests[i]);
201
202 ret = vsscanf_wrapper(tests[i], "-1", -1, "%o", &result);
203 ok(ret == 1, "sscanf returned %d for flags %#x\n", ret, tests[i]);
204 ok(result == -1, "got wrong number %d for flags %#x\n", result, tests[i]);
205
206 ret = 0xdeadbeef;
207 ret = vsscanf_wrapper(tests[i], "-1", -1, "%u", &result);
208 ok(ret == 1, "sscanf returned %d for flags %#x\n", ret, tests[i]);
209 ok(result == -1, "got wrong number %d for flags %#x\n", result, tests[i]);
210
211 c = 0x55;
212 ret = vsscanf_wrapper(tests[i], "a", -1, "%c", &c);
213 ok(ret == 1, "sscanf returned %d for flags %#x\n", ret, tests[i]);
214 ok(c == 'a', "got wrong char '%c' for flags %#x\n", c, tests[i]);
215
216 c = 0x55;
217 ret = vsscanf_wrapper(tests[i], " a", -1, "%c", &c);
218 ok(ret == 1, "sscanf returned %d for flags %#x\n", ret, tests[i]);
219 ok(c == ' ', "got wrong char '%c' for flags %#x\n", c, tests[i]);
220
221 c = 0x55;
222 ret = vsscanf_wrapper(tests[i], "18:59", -1, "%d:%d%c", &hour, &min, &c);
223 ok(ret == 2, "sscanf returned %d for flags %#x\n", ret, tests[i]);
224 ok(hour == 18, "got wrong char '%c' for flags %#x\n", hour, tests[i]);
225 ok(min == 59, "got wrong char '%c' for flags %#x\n", min, tests[i]);
226 ok(c == 0x55, "got wrong char '%c' for flags %#x\n", c, tests[i]);
227
228 strcpy(buffer, "foo");
229 strcpy(buffer1, "bar");
230 ret = vsscanf_wrapper(tests[i], "abc def", -1, "%s %n%s", buffer, &count, buffer1);
231 ok(ret == 2, "sscanf returned %d for flags %#x\n", ret, tests[i]);
232 ok(!strcmp(buffer, "abc"), "got wrong string '%s' for flags %#x\n", buffer, tests[i]);
233 ok(count == 6, "got wrong count %d for flags %#x\n", count, tests[i]);
234 ok(!strcmp(buffer1, "def"), "got wrong string '%s' for flags %#x\n", buffer1, tests[i]);
235
236 ret = vsscanf_wrapper(tests[i], "3:45", -1, "%d:%d%n", &hour, &min, &count);
237 ok(ret == 2, "sscanf returned %d for flags %#x\n", ret, tests[i]);
238 ok(hour == 3, "got wrong char '%c' for flags %#x\n", hour, tests[i]);
239 ok(min == 45, "got wrong char '%c' for flags %#x\n", min, tests[i]);
240 ok(count == 4, "got wrong count %d for flags %#x\n", count, tests[i]);
241
242 strcpy(buffer, "foo");
243 strcpy(buffer1, "bar");
244 ret = vsscanf_wrapper(tests[i], "test=value\xda", -1, "%[^=] = %[^;]", buffer, buffer1);
245 ok(ret == 2, "sscanf returned %d for flags %#x\n", ret, tests[i]);
246 ok(!strcmp(buffer, "test"), "got wrong string '%s' for flags %#x\n", buffer, tests[i]);
247 ok(!strcmp(buffer1, "value\xda"), "got wrong string '%s' for flags %#x\n", buffer1, tests[i]);
248
249 ret = vsscanf_wrapper(tests[i], "0.1", 3, "%lf%n", &double_res, &count);
250 ok(ret == 1, "sscanf returned %d for flags %#x\n", ret, tests[i]);
251 ok(double_res == 0.1, "got wrong double %.16e for flags %#x\n", double_res, tests[i]);
252 ok(count == 3, "got wrong count %d for flags %#x\n", count, tests[i]);
253
254 ret = vsscanf_wrapper(tests[i], "a", -1, "%lf%n", &double_res, &count);
255 ok(ret == 0, "sscanf returned %d for flags %#x\n", ret, tests[i]);
256
257 ret = vsscanf_wrapper(tests[i], "aa", -1, "%c%lf%n", &c, &double_res, &count);
258 ok(ret == 1, "sscanf returned %d for flags %#x\n", ret, tests[i]);
259
260 ret = vsscanf_wrapper(tests[i], "a0e", -1, "%c%lf%n", &c, &double_res, &count);
261 ok(ret == 1, "sscanf returned %d for flags %#x\n", ret, tests[i]);
262
263 ret = vsscanf_wrapper(tests[i], "0.", -1, "%lf%n", &double_res, &count);
264 ok(ret == 1, "sscanf returned %d for flags %#x\n", ret, tests[i]);
265 ok(double_res == 0, "got wrong double %.16e for flags %#x\n", double_res, tests[i]);
266 ok(count == 2, "got wrong count %d for flags %#x\n", count, tests[i]);
267
268 ret = vsscanf_wrapper(tests[i], "0.", 2, "%lf%n", &double_res, &count);
269 ok(ret == 1, "sscanf returned %d for flags %#x\n", ret, tests[i]);
270 ok(double_res == 0, "got wrong double %.16e for flags %#x\n", double_res, tests[i]);
271 ok(count == 2, "got wrong count %d for flags %#x\n", count, tests[i]);
272
273 ret = vsscanf_wrapper(tests[i], "1e", -1, "%lf%n", &double_res, &count);
274 ok(ret == -1, "sscanf returned %d for flags %#x\n", ret, tests[i]);
275
276 ret = vsscanf_wrapper(tests[i], "1e ", 2, "%lf%n", &double_res, &count);
277 ok(ret == -1, "sscanf returned %d for flags %#x\n", ret, tests[i]);
278
279 ret = vsscanf_wrapper(tests[i], "1e+", -1, "%lf%n", &double_res, &count);
280 ok(ret == -1, "sscanf returned %d for flags %#x\n", ret, tests[i]);
281
282 ret = vsscanf_wrapper(tests[i], "inf", -1, "%lf%n", &double_res, &count);
283 ok(ret == 1, "sscanf returned %d for flags %#x\n", ret, tests[i]);
284 ok(double_res == INFINITY, "got wrong double %.16e for flags %#x\n", double_res, tests[i]);
285 ok(count == 3, "got wrong count %d for flags %#x\n", count, tests[i]);
286
287 ret = vsscanf_wrapper(tests[i], "infa", -1, "%lf%n", &double_res, &count);
288 ok(ret == 1, "sscanf returned %d for flags %#x\n", ret, tests[i]);
289 ok(double_res == INFINITY, "got wrong double %.16e for flags %#x\n", double_res, tests[i]);
290 ok(count == 3, "got wrong count %d for flags %#x\n", count, tests[i]);
291
292 ret = vsscanf_wrapper(tests[i], "infi", -1, "%lf%n", &double_res, &count);
293 ok(ret == -1, "sscanf returned %d for flags %#x\n", ret, tests[i]);
294
295 ret_size = ~0;
296 ret = vsscanf_wrapper(tests[i], "1", -1, "%zd", &ret_size);
297 ok(ret == 1, "sscanf returned %d for flags %#x\n", ret, tests[i]);
298 ok(ret_size == 1, "got wrong size_t %s for flags %#x\n",
299 wine_dbgstr_longlong((LONGLONG)ret_size), tests[i]);
300
301 result64 = 0;
302 ret = vsscanf_wrapper(tests[i], "12345678901234", -1, "%I64d", &result64);
303 ok(ret == 1, "sscanf returned %d for flags %#x\n", ret, tests[i]);
304 ok(result64 == 12345678901234ll, "got wrong number 0x%s for flags %#x\n",
305 wine_dbgstr_longlong(result64), tests[i]);
306
307 result = 0;
308 ret = vsscanf_wrapper(tests[i], "12345678901234", -1, "%I32d", &result);
309 ok(ret == 1, "sscanf returned %d for flags %#x\n", ret, tests[i]);
310 ok(result == (int)12345678901234ll, /* this is always truncated to 32bit */
311 "got wrong number 0x%d for flags %#x\n", result, tests[i]);
312
313 result_ptr = 0;
314 ret = vsscanf_wrapper(tests[i], "0x87654321", -1, "%Ix", &result_ptr);
315 ok(ret == 1, "sscanf returned %d for flags %#x\n", ret, tests[i]);
316 ok(result_ptr == 0x87654321,
317 "got wrong number %Ix for flags %#x\n", result_ptr, tests[i]);
318
319 result_ptr = 0;
320 ret = vsscanf_wrapper(tests[i], "0x123456789", -1, "%Ix", &result_ptr);
321 ok(ret == 1, "sscanf returned %d for flags %#x\n", ret, tests[i]);
322 ok(result_ptr == (DWORD_PTR)0x123456789ull, /* this is truncated on 32bit systems */
323 "got wrong number %Ix for flags %#x\n", result_ptr, tests[i]);
324 }
325}
strcmp
int strcmp(const char *String1, const char *String2)
Definition: utclib.c:469
ok
#define ok(value,...)
Definition: atltest.h:57
ARRAY_SIZE
#define ARRAY_SIZE(A)
Definition: main.h:20
_CRT_INTERNAL_SCANF_LEGACY_MSVCRT_COMPATIBILITY
#define _CRT_INTERNAL_SCANF_LEGACY_MSVCRT_COMPATIBILITY
Definition: corecrt_stdio_config.h:125
_CRT_INTERNAL_SCANF_LEGACY_WIDE_SPECIFIERS
#define _CRT_INTERNAL_SCANF_LEGACY_WIDE_SPECIFIERS
Definition: corecrt_stdio_config.h:124
wine_dbgstr_longlong
static __inline const char * wine_dbgstr_longlong(ULONGLONG ll)
Definition: compat.h:49
count
GLuint GLuint GLsizei count
Definition: gl.h:1545
buffer
GLuint buffer
Definition: glext.h:5915
c
const GLubyte * c
Definition: glext.h:8905
result
GLuint64EXT * result
Definition: glext.h:11304
i
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
INFINITY
#define INFINITY
Definition: math.h:56
EOF
#define EOF
Definition: stdio.h:24
c
#define c
Definition: ke_i.h:80
ptr
static PVOID ptr
Definition: dispmode.c:27
tests
static struct test_info tests[]
sprintf
#define sprintf(buf, format,...)
Definition: sprintf.c:55
todo_wine
#define todo_wine
Definition: custom.c:89
vsscanf_wrapper
static int WINAPIV vsscanf_wrapper(unsigned __int64 options, const char *str, size_t len, const char *format,...)
Definition: scanf.c:30
min
#define min(a, b)
Definition: monoChain.cc:55
strcpy
strcpy
Definition: string.h:131
DWORD_PTR
uint32_t DWORD_PTR
Definition: typedefs.h:65
LONGLONG
int64_t LONGLONG
Definition: typedefs.h:68
ULONG_PTR
uint32_t ULONG_PTR
Definition: typedefs.h:65
ret
int ret
Definition: wcstombs-tests.c:31

◆ vsscanf_wrapper()

static int WINAPIV vsscanf_wrapper ( unsigned __int64  options,
const char *  str,
size_t  len,
const char *  format,
  ... 
)
static

Definition at line 30 of file scanf.c.

31{
32 int ret;
33 va_list valist;
34 va_start(valist, format);
35 ret = __stdio_common_vsscanf(options, str, len, format, NULL, valist);
36 va_end(valist);
37 return ret;
38}
va_list
char * va_list
Definition: acmsvcex.h:78
va_end
#define va_end(ap)
Definition: acmsvcex.h:90
va_start
#define va_start(ap, A)
Definition: acmsvcex.h:91
NULL
#define NULL
Definition: types.h:112
len
GLenum GLsizei len
Definition: glext.h:6722
__stdio_common_vsscanf
int __cdecl __stdio_common_vsscanf(unsigned __int64 const options, char const *const buffer, size_t const buffer_count, char const *const format, _locale_t const locale, va_list const arglist)
Definition: input.cpp:113
valist
static va_list valist
Definition: printf.c:46
str
const WCHAR * str
Definition: rpc_transport.c:2724
format
Definition: format.c:58

Referenced by test_sscanf().