static int lc_arg_cmp(const void *p1, const void *p2, UNUSED(size_t size))
{
- const lc_arg_t *a1 = p1;
- const lc_arg_t *a2 = p2;
+ const lc_arg_t *a1 = (const lc_arg_t*)p1;
+ const lc_arg_t *a2 = (const lc_arg_t*)p2;
return strcmp(a1->name, a2->name);
}
base = 'a';
}
- ent = set_insert(env->args, &arg, sizeof(arg), HASH_STR(name, strlen(name)));
+ ent = (lc_arg_t*)set_insert(env->args, &arg, sizeof(arg), HASH_STR(name, strlen(name)));
if (ent && base != 0)
map[letter - base] = ent;
int res = 0;
switch (lc_arg_type) {
-#define LC_ARG_TYPE(type,name) \
+#define LC_ARG_TYPE(type,name,va_type) \
case lc_arg_type_ ## name: res = snprintf(buf, len, fmt, val->v_ ## name); break;
#include "lc_printf_arg_types.def"
#undef LC_ARG_TYPE
strncpy(mod, occ->modifier, sizeof(mod) - 1);
mod[LC_MIN(sizeof(mod) - 1, occ->modifier_length)] = '\0';
+#ifdef _MSC_VER
+ /* work-around for buggy mscrt not supporting z, j, and t modifier */
+ if (occ->modifier_length == 1) {
+ if (mod[0] == 'z') {
+ if (sizeof(size_t) == sizeof(int))
+ mod[0] = '\0';
+ if (sizeof(size_t) == sizeof(__int64)) {
+ mod[0] = 'I';
+ mod[1] = '6';
+ mod[2] = '4';
+ mod[3] = '\0';
+ }
+ } else if (mod[0] == 't') {
+ if (sizeof(ptrdiff_t) == sizeof(int))
+ mod[0] = '\0';
+ if (sizeof(ptrdiff_t) == sizeof(__int64)) {
+ mod[0] = 'I';
+ mod[1] = '6';
+ mod[2] = '4';
+ mod[3] = '\0';
+ }
+ } else if (mod[0] == 'j') {
+ if (sizeof(intmax_t) == sizeof(int))
+ mod[0] = '\0';
+ if (sizeof(intmax_t) == sizeof(__int64)) {
+ mod[0] = 'I';
+ mod[1] = '6';
+ mod[2] = '4';
+ mod[3] = '\0';
+ }
+ }
+ } else if (occ->modifier_length == 2) {
+ if (mod[0] == 'h' && mod[1] == 'h') {
+ /* no support for char in mscrt, but we can safely ignore it
+ * because the size is handled by the argument reader code */
+ mod[0] = '\0';
+ }
+ }
+#endif
snprintf(buf, len, "%%%s%s%s%s%s%s%s%s%c",
occ->flag_space ? "#" : "",
occ->flag_hash ? "#" : "",
*/
static int std_get_lc_arg_type(const lc_arg_occ_t *occ)
{
- int modlen = occ->modifier_length;
+ size_t modlen = occ->modifier_length;
/* check, if the type can be derived from the modifier */
if (modlen > 0) {
const char *mod = occ->modifier;
switch (mod[0]) {
+ case 'h':
+ return modlen > 1 && mod[1] == 'h' ? lc_arg_type_char : lc_arg_type_short;
case 'l':
return modlen > 1 && mod[1] == 'l' ? lc_arg_type_long_long : lc_arg_type_long;
#define TYPE_CASE(letter,type) case letter: return lc_arg_type_ ## type;
-#if 0
TYPE_CASE('j', intmax_t);
TYPE_CASE('z', size_t);
TYPE_CASE('t', ptrdiff_t);
-#endif
TYPE_CASE('L', long_double);
#undef TYPE_CASE
}
* int pointer location */
case 'n':
{
- int *num = val->v_ptr;
- *num = app->written;
+ int *num = (int*)val->v_ptr;
+ *num = (int)app->written;
}
break;
* buffer of 128 letters for all other types should be enough. */
case 's':
{
- const char *str = val->v_ptr;
+ const char *str = (const char*)val->v_ptr;
res = lc_arg_append(app, occ, str, strlen(str));
}
break;
for (ch = *s; ch != '}' && ch != '\0'; ch = *++s);
if (s - named) {
- int n = s - named;
+ size_t n = s - named;
char *name;
lc_arg_t tmp;
- name = malloc(sizeof(char) * (n + 1));
+ name = (char*) malloc(sizeof(char) * (n + 1));
memcpy(name, named, sizeof(char) * n);
name[n] = '\0';
tmp.name = name;
- arg = set_find(env->args, &tmp, sizeof(tmp), HASH_STR(named, n));
+ arg = (lc_arg_t*)set_find(env->args, &tmp, sizeof(tmp), HASH_STR(named, n));
occ.modifier = "";
occ.modifier_length = 0;
/* Store the value according to argument information */
switch (occ.lc_arg_type) {
-#define LC_ARG_TYPE(type,name) case lc_arg_type_ ## name: val.v_ ## name = va_arg(args, type); break;
+#define LC_ARG_TYPE(type,name,va_type) \
+ case lc_arg_type_ ## name: val.v_ ## name = va_arg(args, va_type); break;
#include "lc_printf_arg_types.def"
#undef LC_ARG_TYPE
}