3 MPDM - Minimum Profit Data Manager
4 Copyright (C) 2003/2010 Angel Ortega <angel@triptico.com>
6 mpdm_s.c - String management
8 This program is free software; you can redistribute it and/or
9 modify it under the terms of the GNU General Public License
10 as published by the Free Software Foundation; either version 2
11 of the License, or (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
22 http://www.triptico.com
35 #ifdef CONFOPT_GETTEXT
48 void *mpdm_poke_o(void *dst
, int *dsize
, int *offset
, const void *org
, int osize
, int esize
)
50 if (org
!= NULL
&& osize
) {
52 if (*offset
+ osize
> *dsize
) {
56 dst
= realloc(dst
, *dsize
* esize
);
59 memcpy((char *)dst
+ (*offset
* esize
), org
, osize
* esize
);
67 void *mpdm_poke(void *dst
, int *dsize
, const void *org
, int osize
, int esize
)
68 /* pokes (adds) org into dst, which is a dynamic string, making it grow */
72 return mpdm_poke_o(dst
, dsize
, &offset
, org
, osize
, esize
);
76 wchar_t *mpdm_pokewsn(wchar_t *dst
, int *dsize
, const wchar_t *str
, int slen
)
77 /* adds a wide string to dst using mpdm_poke() with size */
80 dst
= mpdm_poke(dst
, dsize
, str
, slen
, sizeof(wchar_t));
86 wchar_t *mpdm_pokews(wchar_t *dst
, int *dsize
, const wchar_t *str
)
87 /* adds a wide string to dst using mpdm_poke() */
90 dst
= mpdm_pokewsn(dst
, dsize
, str
, wcslen(str
));
96 wchar_t *mpdm_pokev(wchar_t * dst
, int *dsize
, const mpdm_t v
)
97 /* adds the string in v to dst using mpdm_poke() */
100 const wchar_t *ptr
= mpdm_string(v
);
103 dst
= mpdm_pokews(dst
, dsize
, ptr
);
111 wchar_t *mpdm_mbstowcs(const char *str
, int *s
, int l
)
112 /* converts an mbs to a wcs, but filling invalid chars
113 with question marks instead of just failing */
116 char tmp
[64]; /* really MB_CUR_MAX + 1 */
121 /* allow NULL values for s */
125 /* if there is a limit, duplicate and break the string */
133 /* try first a direct conversion with mbstowcs */
134 if ((*s
= mbstowcs(NULL
, cstr
, 0)) != -1) {
135 /* direct conversion is possible; do it */
136 if ((ptr
= malloc((*s
+ 1) * sizeof(wchar_t))) != NULL
) {
137 mbstowcs(ptr
, cstr
, *s
);
142 /* zero everything */
146 /* no more characters to process? */
147 if ((c
= cstr
[n
+ i
]) == '\0' && i
== 0)
154 if (mbstowcs(&wc
, tmp
, 1) == (size_t) -1) {
155 /* can still be an incomplete multibyte char? */
156 if (c
!= '\0' && i
<= (int) MB_CUR_MAX
)
159 /* too many failing bytes; skip 1 byte */
165 /* skip used bytes and back again */
170 if ((ptr
= mpdm_poke(ptr
, s
, &wc
, 1, sizeof(wchar_t))) == NULL
)
174 /* null terminate and count one less */
176 ptr
= mpdm_poke(ptr
, s
, L
"", 1, sizeof(wchar_t));
181 /* free the duplicate */
189 char *mpdm_wcstombs(const wchar_t * str
, int *s
)
190 /* converts a wcs to an mbs, but filling invalid chars
191 with question marks instead of just failing */
194 char tmp
[64]; /* really MB_CUR_MAX + 1 */
197 /* allow NULL values for s */
201 /* try first a direct conversion with wcstombs */
202 if ((*s
= wcstombs(NULL
, str
, 0)) != -1) {
203 /* direct conversion is possible; do it and return */
204 if ((ptr
= malloc(*s
+ 1)) != NULL
) {
205 wcstombs(ptr
, str
, *s
);
212 /* invalid encoding? convert characters one by one */
216 if ((l
= wctomb(tmp
, *str
)) <= 0) {
217 /* if char couldn't be converted,
218 write a question mark instead */
219 l
= wctomb(tmp
, L
'?');
223 if ((ptr
= mpdm_poke(ptr
, s
, tmp
, l
, 1)) == NULL
)
229 /* null terminate and count one less */
231 ptr
= mpdm_poke(ptr
, s
, "", 1, 1);
239 mpdm_t
mpdm_new_wcs(int flags
, const wchar_t * str
, int size
, int cpy
)
240 /* creates a new string value from a wcs */
244 /* a size of -1 means 'calculate it' */
245 if (size
== -1 && str
!= NULL
)
250 /* free() on destruction */
254 if ((ptr
= malloc((size
+ 1) * sizeof(wchar_t))) == NULL
)
257 /* if no source, reset to zeroes; otherwise, copy */
259 memset(ptr
, '\0', size
* sizeof(wchar_t));
261 wcsncpy(ptr
, str
, size
);
266 ptr
= (wchar_t *)str
;
269 flags
|= MPDM_STRING
;
271 return mpdm_new(flags
, ptr
, size
);
275 mpdm_t
mpdm_new_mbstowcs(int flags
, const char *str
, int l
)
276 /* creates a new string value from an mbs */
281 if ((ptr
= mpdm_mbstowcs(str
, &size
, l
)) == NULL
)
285 flags
|= (MPDM_STRING
| MPDM_FREE
);
287 return mpdm_new(flags
, ptr
, size
);
291 mpdm_t
mpdm_new_wcstombs(int flags
, const wchar_t * str
)
292 /* creates a new mbs value from a wbs */
297 ptr
= mpdm_wcstombs(str
, &size
);
301 /* unset the string flag; mbs,s are not 'strings' */
302 flags
&= ~MPDM_STRING
;
304 return mpdm_new(flags
, ptr
, size
);
308 mpdm_t
mpdm_new_i(int ival
)
309 /* creates a new string value from an integer */
314 /* creates the visual representation */
315 snprintf(tmp
, sizeof(tmp
), "%d", ival
);
319 return mpdm_set_ival(v
, ival
);
323 mpdm_t
mpdm_new_r(double rval
)
324 /* creates a new string value from a real number */
329 /* creates the visual representation */
330 snprintf(tmp
, sizeof(tmp
), "%lf", rval
);
332 /* manually strip useless zeroes */
333 if (strchr(tmp
, '.') != NULL
) {
336 for (ptr
= tmp
+ strlen(tmp
) - 1; *ptr
== '0'; ptr
--);
338 /* if it's over the ., strip it also */
347 return mpdm_set_rval(v
, rval
);
354 * mpdm_string - Returns a printable representation of a value.
357 * Returns a printable representation of a value. For strings, it's
358 * the value data itself; for any other type, a conversion to string
359 * is returned instead. This value should be used immediately, as it
360 * can be a pointer to a static buffer.
363 wchar_t *mpdm_string(const mpdm_t v
)
365 static wchar_t wtmp
[32];
369 /* if it's NULL, return a constant */
373 /* if it's a string, return it */
374 if (v
->flags
& MPDM_STRING
)
375 ret
= (wchar_t *) v
->data
;
377 /* otherwise, return a visual representation */
378 snprintf(tmp
, sizeof(tmp
), "%p", v
);
379 mbstowcs(wtmp
, tmp
, sizeof(wtmp
));
380 wtmp
[(sizeof(wtmp
) / sizeof(wchar_t)) - 1] = L
'\0';
390 * mpdm_cmp - Compares two values.
391 * @v1: the first value
392 * @v2: the second value
394 * Compares two values. If both has the MPDM_STRING flag set,
395 * a comparison using wcscoll() is returned; if both are arrays,
396 * the size is compared first and, if they have the same number
397 * elements, each one is compared; otherwise, a simple pointer
398 * comparison is done.
401 int mpdm_cmp(const mpdm_t v1
, const mpdm_t v2
)
409 /* is any value NULL? */
416 /* different values, but same content? (unlikely) */
417 if (v1
->data
== v2
->data
)
420 if (MPDM_IS_STRING(v1
) && MPDM_IS_STRING(v2
))
421 r
= wcscoll((wchar_t *) v1
->data
, (wchar_t *) v2
->data
);
423 if (MPDM_IS_ARRAY(v1
) && MPDM_IS_ARRAY(v2
)) {
424 /* compare first the sizes */
425 if ((r
= mpdm_size(v1
) - mpdm_size(v2
)) == 0) {
428 /* they have the same size;
429 compare each pair of elements */
430 for (n
= 0; n
< mpdm_size(v1
); n
++) {
431 if ((r
= mpdm_cmp(mpdm_aget(v1
, n
),
432 mpdm_aget(v2
, n
))) != 0)
438 /* in any other case, compare just pointers */
439 r
= (int) ((char *)v1
->data
- (char *)v2
->data
);
446 * mpdm_cmp_s - Compares two values (string version).
447 * @v1: the first value
448 * @v2: the second value
450 * Compares two values. Compares both values using wcscoll()
451 * if the first one is a string, or returns 1 otherwise.
453 int mpdm_cmp_s(const mpdm_t v1
, const wchar_t *v2
)
459 if (MPDM_IS_STRING(v1
))
460 r
= wcscoll((wchar_t *) v1
->data
, v2
);
462 r
= (int) ((wchar_t *)v1
->data
- v2
);
471 * mpdm_splice - Creates a new string value from another.
472 * @v: the original value
473 * @i: the value to be inserted
474 * @offset: offset where the substring is to be inserted
475 * @del: number of characters to delete
477 * Creates a new string value from @v, deleting @del chars at @offset
478 * and substituting them by @i. If @del is 0, no deletion is done.
479 * both @offset and @del can be negative; if this is the case, it's
480 * assumed as counting from the end of @v. If @v is NULL, @i will become
481 * the new string, and both @offset and @del will be ignored. If @v is
482 * not NULL and @i is, no insertion process is done (only deletion, if
485 * Returns a two element array, with the new string in the first
486 * element and the deleted string in the second (with a NULL value
490 mpdm_t
mpdm_splice(const mpdm_t v
, const mpdm_t i
, int offset
, int del
)
505 /* negative offsets start from the end */
507 offset
= os
+ 1 - offset
;
509 /* never add further the end */
513 /* negative del counts as 'characters left' */
515 del
= os
+ 1 - offset
+ del
;
517 /* something to delete? */
519 /* never delete further the end */
520 if (offset
+ del
> os
)
524 d
= MPDM_NS(((wchar_t *) v
->data
) + offset
, del
);
529 /* something to insert? */
532 /* new size and remainder */
536 n
= MPDM_NS(NULL
, ns
);
538 ptr
= (wchar_t *)n
->data
;
540 /* copy the beginning */
542 wcsncpy(ptr
, v
->data
, offset
);
546 /* copy the text to be inserted */
548 wcsncpy(ptr
, i
->data
, ins
);
552 /* copy the remaining */
555 wcsncpy(ptr
, ((wchar_t *) v
->data
) + r
, os
);
565 /* creates the output array */
581 * mpdm_strcat_sn - Concatenates two strings (string with size version).
582 * @s1: the first string
583 * @s2: the second string
584 * @size: the size of the second string
586 * Returns a new string formed by the concatenation of @s1 and @s2.
589 mpdm_t
mpdm_strcat_sn(const mpdm_t s1
, const wchar_t *s2
, int size
)
595 if (s1
== NULL
&& s2
== NULL
)
598 ptr
= mpdm_pokev(ptr
, &s
, s1
);
599 ptr
= mpdm_pokewsn(ptr
, &s
, s2
, size
);
601 ptr
= mpdm_poke(ptr
, &s
, L
"", 1, sizeof(wchar_t));
602 r
= MPDM_ENS(ptr
, s
- 1);
610 * mpdm_strcat_s - Concatenates two strings (string version).
611 * @s1: the first string
612 * @s2: the second string
614 * Returns a new string formed by the concatenation of @s1 and @s2.
617 mpdm_t
mpdm_strcat_s(const mpdm_t s1
, const wchar_t *s2
)
619 return mpdm_strcat_sn(s1
, s2
, s2
? wcslen(s2
) : 0);
624 * mpdm_strcat - Concatenates two strings.
625 * @s1: the first string
626 * @s2: the second string
628 * Returns a new string formed by the concatenation of @s1 and @s2.
631 mpdm_t
mpdm_strcat(const mpdm_t s1
, const mpdm_t s2
)
636 r
= mpdm_strcat_s(s1
, s2
? mpdm_string(s2
) : NULL
);
644 * mpdm_ival - Returns a value's data as an integer.
647 * Returns a value's data as an integer. If the value is a string,
648 * it's converted via sscanf and returned; non-string values have all
649 * an ival of 0. The converted integer is cached, so costly string
650 * conversions are only done once. Values created with the MPDM_IVAL
651 * flag set have its ival cached from the beginning.
655 int mpdm_ival(mpdm_t v
)
662 /* if there is no cached integer, calculate it */
663 if (!(v
->flags
& MPDM_IVAL
)) {
664 /* if it's a string, calculate it; other
665 values will have an ival of 0 */
666 if (v
->flags
& MPDM_STRING
) {
670 wcstombs(tmp
, (wchar_t *) v
->data
, sizeof(tmp
));
671 tmp
[sizeof(tmp
) - 1] = '\0';
673 /* workaround for mingw32: as it doesn't
674 correctly parse octal and hexadecimal
675 numbers, they are tried as special cases */
677 if (tmp
[1] == 'b' || tmp
[1] == 'B') {
682 while (*ptr
== '0' || *ptr
== '1') {
692 if (tmp
[1] == 'x' || tmp
[1] == 'X')
699 sscanf(tmp
, fmt
, &i
);
715 * mpdm_rval - Returns a value's data as a real number (double).
718 * Returns a value's data as a real number (double float). If the value
719 * is a string, it's converted via sscanf and returned; non-string values
720 * have all an rval of 0. The converted double is cached, so costly string
721 * conversions are only done once. Values created with the MPDM_RVAL
722 * flag set have its rval cached from the beginning.
726 double mpdm_rval(mpdm_t v
)
733 /* if there is no cached double, calculate it */
734 if (!(v
->flags
& MPDM_RVAL
)) {
735 /* if it's a string, calculate it; other
736 values will have an rval of 0.0 */
737 if (v
->flags
& MPDM_STRING
) {
741 wcstombs(tmp
, (wchar_t *) v
->data
, sizeof(tmp
));
742 tmp
[sizeof(tmp
) - 1] = '\0';
744 /* if the number starts with 0, it's
745 an octal or hexadecimal number; just
746 take the integer value and cast it */
747 if (tmp
[0] == '0' && tmp
[1] != '.')
748 r
= (double) mpdm_ival(v
);
750 /* set locale to C for non locale-dependent
751 floating point conversion */
752 prev_locale
= setlocale(LC_NUMERIC
, "C");
755 sscanf(tmp
, "%lf", &r
);
757 /* set previous locale */
758 setlocale(LC_NUMERIC
, prev_locale
);
775 * mpdm_gettext - Translates a string to the current language.
778 * Translates the @str string to the current language.
780 * This function can still be used even if there is no real gettext
781 * support() by manually filling the __I18N__ hash.
783 * If the string is found in the current table, the translation is
784 * returned; otherwise, the same @str value is returned.
788 mpdm_t
mpdm_gettext(const mpdm_t str
)
794 if ((i18n
= mpdm_hget_s(mpdm_root(), L
"__I18N__")) == NULL
)
795 i18n
= mpdm_hset_s(mpdm_root(), L
"__I18N__", MPDM_H(0));
799 /* try first the cache */
800 if ((v
= mpdm_hget(i18n
, str
)) == NULL
) {
801 #ifdef CONFOPT_GETTEXT
806 t
= mpdm_ref(MPDM_2MBS(str
->data
));
808 /* ask gettext for it */
809 s
= gettext((char *) t
->data
);
818 #else /* CONFOPT_GETTEXT */
822 #endif /* CONFOPT_GETTEXT */
824 /* store in the cache */
825 mpdm_hset(i18n
, str
, v
);
835 * mpdm_gettext_domain - Sets domain and data directory for translations.
836 * @dom: the domain (application name)
837 * @data: directory contaning the .mo files
839 * Sets the domain (application name) and translation data for translating
840 * strings that will be returned by mpdm_gettext().@data must point to a
841 * directory containing the .mo (compiled .po) files.
843 * If there is no gettext support, returns 0, or 1 otherwise.
847 int mpdm_gettext_domain(const mpdm_t dom
, const mpdm_t data
)
854 #ifdef CONFOPT_GETTEXT
859 /* convert both to mbs,s */
860 dm
= mpdm_ref(MPDM_2MBS(dom
->data
));
861 dt
= mpdm_ref(MPDM_2MBS(data
->data
));
863 /* bind and set domain */
864 bindtextdomain((char *) dm
->data
, (char *) dt
->data
);
865 textdomain((char *) dm
->data
);
867 mpdm_hset_s(mpdm_root(), L
"__I18N__", MPDM_H(0));
874 #endif /* CONFOPT_GETTEXT */
880 if ((v
= mpdm_hget_s(mpdm_root(), L
"ENV")) != NULL
&&
881 mpdm_hget_s(v
, L
"LANG") == NULL
) {
882 wchar_t *wptr
= L
"en";
884 /* MS Windows crappy language constants... */
886 switch((GetSystemDefaultLangID() & 0x00ff)) {
887 case 0x01: wptr
= L
"ar"; break; /* arabic */
888 case 0x02: wptr
= L
"bg"; break; /* bulgarian */
889 case 0x03: wptr
= L
"ca"; break; /* catalan */
890 case 0x04: wptr
= L
"zh"; break; /* chinese */
891 case 0x05: wptr
= L
"cz"; break; /* czech */
892 case 0x06: wptr
= L
"da"; break; /* danish */
893 case 0x07: wptr
= L
"de"; break; /* german */
894 case 0x08: wptr
= L
"el"; break; /* greek */
895 case 0x09: wptr
= L
"en"; break; /* english */
896 case 0x0a: wptr
= L
"es"; break; /* spanish */
897 case 0x0b: wptr
= L
"fi"; break; /* finnish */
898 case 0x0c: wptr
= L
"fr"; break; /* french */
899 case 0x0d: wptr
= L
"he"; break; /* hebrew */
900 case 0x0e: wptr
= L
"hu"; break; /* hungarian */
901 case 0x0f: wptr
= L
"is"; break; /* icelandic */
902 case 0x10: wptr
= L
"it"; break; /* italian */
903 case 0x11: wptr
= L
"jp"; break; /* japanese */
904 case 0x12: wptr
= L
"ko"; break; /* korean */
905 case 0x13: wptr
= L
"nl"; break; /* dutch */
906 case 0x14: wptr
= L
"no"; break; /* norwegian */
907 case 0x15: wptr
= L
"po"; break; /* polish */
908 case 0x16: wptr
= L
"pt"; break; /* portuguese */
909 case 0x17: wptr
= L
"rm"; break; /* romansh (switzerland) */
910 case 0x18: wptr
= L
"ro"; break; /* romanian */
911 case 0x19: wptr
= L
"ru"; break; /* russian */
912 case 0x1a: wptr
= L
"sr"; break; /* serbian */
913 case 0x1b: wptr
= L
"sk"; break; /* slovak */
914 case 0x1c: wptr
= L
"sq"; break; /* albanian */
915 case 0x1d: wptr
= L
"sv"; break; /* swedish */
918 mpdm_hset_s(v
, L
"LANG", MPDM_S(wptr
));
921 #endif /* CONFOPT_WIN32 */
930 #ifdef CONFOPT_WCWIDTH
932 int wcwidth(wchar_t);
934 int mpdm_wcwidth(wchar_t c
)
939 #else /* CONFOPT_WCWIDTH */
943 int mpdm_wcwidth(wchar_t c
)
945 return mk_wcwidth(c
);
948 #endif /* CONFOPT_WCWIDTH */
952 * mpdm_sprintf - Formats a sprintf()-like string.
953 * @fmt: the string format
954 * @args: an array of values
956 * Formats a string using the sprintf() format taking the values from @args.
959 mpdm_t
mpdm_sprintf(const mpdm_t fmt
, const mpdm_t args
)
961 const wchar_t *i
= fmt
->data
;
969 /* loop all characters */
970 while ((c
= *i
++) != L
'\0') {
972 wchar_t *tptr
= NULL
;
973 wchar_t *wptr
= NULL
;
976 /* format directive */
985 /* transform the format to mbs */
986 while (*i
!= L
'\0' &&
987 m
< (int)(sizeof(t_fmt
) - MB_CUR_MAX
- 1) &&
988 wcschr(L
"-.0123456789", *i
) != NULL
)
989 m
+= wctomb(&t_fmt
[m
], *i
++);
991 /* transfer the directive */
992 m
+= wctomb(&t_fmt
[m
], *i
++);
996 /* by default, copies the format */
999 /* pick next value */
1000 v
= mpdm_aget(args
, n
++);
1002 switch (t_fmt
[m
- 1]) {
1011 snprintf(tmp
, sizeof(tmp
) - 1,
1012 t_fmt
, mpdm_ival(v
));
1017 /* float (real) value */
1018 snprintf(tmp
, sizeof(tmp
) - 1,
1019 t_fmt
, mpdm_rval(v
));
1025 ptr
= mpdm_wcstombs(mpdm_string(v
), NULL
);
1026 snprintf(tmp
, sizeof(tmp
) - 1, t_fmt
, ptr
);
1045 mask
= 1 << ((sizeof(int) * 8) - 1);
1047 if (mask
& (unsigned int) mpdm_ival(v
)) {
1074 wptr
= tptr
= mpdm_mbstowcs(tmp
, &m
, -1);
1083 o
= mpdm_poke(o
, &l
, wptr
, m
, sizeof(wchar_t));
1085 /* free the temporary buffer, if any */
1093 /* null-terminate */
1094 o
= mpdm_poke(o
, &l
, L
"", 1, sizeof(wchar_t));
1099 return MPDM_ENS(o
, l
- 1);
1104 * mpdm_ulc - Converts a string to uppercase or lowecase.
1106 * @u: convert to uppercase (1) or to lowercase (0).
1108 * Converts @s to uppercase (for @u == 1) or to lowercase (@u == 0).
1111 mpdm_t
mpdm_ulc(const mpdm_t s
, int u
)
1121 if ((optr
= malloc((i
+ 1) * sizeof(wchar_t))) != NULL
) {
1122 wchar_t *iptr
= mpdm_string(s
);
1125 for (n
= 0; n
< i
; n
++)
1126 optr
[n
] = u
? towupper(iptr
[n
]) : towlower(iptr
[n
]);
1129 r
= MPDM_ENS(optr
, i
);
1138 /* scanf working buffers */
1139 #define SCANF_BUF_SIZE 1024
1140 static wchar_t scanf_yset
[SCANF_BUF_SIZE
];
1141 static wchar_t scanf_nset
[SCANF_BUF_SIZE
];
1142 static wchar_t scanf_mark
[SCANF_BUF_SIZE
];
1149 { L
's', L
"", L
" \t" },
1150 { L
'u', L
"0123456789", L
"" },
1151 { L
'd', L
"-0123456789", L
"" },
1152 { L
'i', L
"-0123456789", L
"" },
1153 { L
'f', L
"-0123456789.", L
"" },
1154 { L
'x', L
"-0123456789xabcdefABCDEF", L
"" },
1155 { L
'\0', NULL
, NULL
},
1159 * mpdm_sscanf - Extracts data like sscanf().
1160 * @fmt: the string format
1161 * @str: the string to be parsed
1162 * @offset: the character offset to start scanning
1164 * Extracts data from a string using a special format pattern, very
1165 * much like the scanf() series of functions in the C library. Apart
1166 * from the standard percent-sign-commands (s, u, d, i, f, x,
1167 * n, [, with optional size and * to ignore), it implements S,
1168 * to match a string of characters upto what follows in the format
1169 * string. Also, the [ set of characters can include other % formats.
1171 * Returns an array with the extracted values. If %n is used, the
1172 * position in the scanned string is returned as the value.
1175 mpdm_t
mpdm_sscanf(const mpdm_t fmt
, const mpdm_t str
, int offset
)
1177 wchar_t *i
= (wchar_t *)str
->data
;
1178 wchar_t *f
= (wchar_t *)fmt
->data
;
1190 wchar_t *ptr
= NULL
;
1197 /* empty all buffers */
1198 scanf_yset
[0] = scanf_nset
[0] = scanf_mark
[0] = L
'\0';
1202 /* an asterisk? don't return next value */
1208 /* does it have a size? */
1209 while (wcschr(L
"0123456789", *f
)) {
1215 /* if no size, set it to an arbitrary big limit */
1219 /* now *f should contain a command */
1223 /* is it a verbatim percent sign? */
1227 wcscpy(scanf_yset
, L
"%");
1234 mpdm_push(r
, MPDM_I(i
- (wchar_t *)str
->data
));
1237 /* string upto a mark */
1241 /* fill the mark upto another command */
1246 /* is it an 'n'? ignore and go on */
1253 scanf_mark
[msize
++] = *tmp
;
1258 scanf_mark
[msize
++] = *tmp
;
1263 scanf_mark
[msize
] = L
'\0';
1269 wchar_t *set
= scanf_yset
;
1271 /* is it an inverse set? */
1277 /* first one is a ]? add it */
1283 /* now build the set */
1284 for (; n
< SCANF_BUF_SIZE
- 1 && *f
&& *f
!= L
']'; f
++) {
1285 /* is it a range? */
1289 /* start or end? hyphen itself */
1290 if (n
== 0 || *f
== L
']')
1293 /* pick previous char */
1294 wchar_t c
= set
[n
- 1];
1297 while (n
< SCANF_BUF_SIZE
- 1 && c
< *f
)
1302 /* is it another command? */
1307 for (i
= 0; scanf_sets
[i
].cmd
; i
++) {
1308 if (*f
== scanf_sets
[i
].cmd
) {
1310 wcscat(set
, scanf_sets
[i
].yset
);
1311 n
+= wcslen(scanf_sets
[i
].yset
);
1326 /* a standard set? */
1330 for (n
= 0; scanf_sets
[n
].cmd
!= L
'\0'; n
++) {
1331 if (cmd
== scanf_sets
[n
].cmd
) {
1332 wcscpy(scanf_yset
, scanf_sets
[n
].yset
);
1333 wcscpy(scanf_nset
, scanf_sets
[n
].nset
);
1339 /* now fill the dynamic string */
1341 !wcschr(scanf_nset
, *i
) &&
1342 (scanf_yset
[0] == L
'\0' || wcschr(scanf_yset
, *i
)) &&
1343 (msize
== 0 || wcsncmp(i
, scanf_mark
, msize
) != 0)) {
1345 /* only add if not being ignored */
1347 ptr
= mpdm_poke(ptr
, &size
, i
, 1, sizeof(wchar_t));
1353 if (!ignore
&& size
) {
1354 /* null terminate and push */
1355 ptr
= mpdm_poke(ptr
, &size
, L
"", 1, sizeof(wchar_t));
1356 mpdm_push(r
, MPDM_ENS(ptr
, size
- 1));
1360 if (*f
== L
' ' || *f
== L
'\t') {
1361 /* if it's a blank, sync to next non-blank */
1364 while (*i
== L
' ' || *i
== L
'\t')
1368 /* test for literals in the format string */