1 : #define VSTR_CNTL_C
2 : /*
3 : * Copyright (C) 1999, 2000, 2001, 2002, 2003 James Antill
4 : *
5 : * This library is free software; you can redistribute it and/or
6 : * modify it under the terms of the GNU Lesser General Public
7 : * License as published by the Free Software Foundation; either
8 : * version 2 of the License, or (at your option) any later version.
9 : *
10 : * This library is distributed in the hope that it will be useful,
11 : * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 : * Lesser General Public License for more details.
14 : *
15 : * You should have received a copy of the GNU Lesser General Public
16 : * License along with this library; if not, write to the Free Software
17 : * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 : *
19 : * email: james@and.org
20 : */
21 : /* functions for the "misc" control stuff. like reading struct values etc. */
22 : #include "main.h"
23 :
24 :
25 : Vstr__options vstr__options =
26 : {
27 : NULL, /* def */
28 :
29 : 0, /* mmap count */
30 :
31 : 0, /* fd count */
32 : 0, /* fd close fail num */
33 :
34 : /* BEG: mem */
35 : 0, /* sz */
36 : 0, /* num */
37 : 0, /* fail num */
38 : NULL /* values */
39 : /* END: mem */
40 : };
41 :
42 : int vstr_cntl_opt(int option, ...)
43 129788 : {
44 129788 : int ret = 0;
45 :
46 129788 : va_list ap;
47 :
48 129788 : va_start(ap, option);
49 :
50 129788 : switch (option)
51 : {
52 : case VSTR_CNTL_OPT_GET_CONF:
53 : {
54 10 : Vstr_conf **val = va_arg(ap, Vstr_conf **);
55 :
56 10 : vstr__add_user_conf(*val = vstr__options.def);
57 :
58 10 : ret = TRUE;
59 : }
60 10 : break;
61 :
62 : case VSTR_CNTL_OPT_SET_CONF:
63 : {
64 5 : Vstr_conf *val = va_arg(ap, Vstr_conf *);
65 :
66 5 : ASSERT(val);
67 :
68 5 : if (vstr__options.def != val)
69 : {
70 5 : vstr_free_conf(vstr__options.def);
71 5 : vstr__add_user_conf(vstr__options.def = val);
72 : }
73 :
74 5 : ret = TRUE;
75 : }
76 :
77 : #if USE_MALLOC_CHECK || USE_FD_CLOSE_CHECK
78 1 : break;
79 :
80 : case 666:
81 : {
82 54145 : unsigned long valT = va_arg(ap, unsigned long);
83 54145 : unsigned long valV = va_arg(ap, unsigned long);
84 :
85 54145 : ASSERT((valT == 0x0F0F) || (valT == 0xF0F0));
86 :
87 54145 : if (0) {}
88 54145 : else if (USE_FD_CLOSE_CHECK && (valT == 0x0F0F))
89 9 : { vstr__options.fd_close_fail_num = valV; ret = TRUE; }
90 54136 : else if (USE_MALLOC_CHECK && (valT == 0xF0F0))
91 54136 : { vstr__options.mem_fail_num = valV; ret = TRUE; }
92 : }
93 : #endif
94 :
95 54136 : ASSERT_NO_SWITCH_DEF();
96 : }
97 :
98 129788 : va_end(ap);
99 :
100 129788 : return (ret);
101 : }
102 :
103 : int vstr_cntl_base(Vstr_base *base, int option, ...)
104 4178 : {
105 4178 : int ret = 0;
106 :
107 4178 : va_list ap;
108 :
109 4178 : va_start(ap, option);
110 :
111 4178 : switch (option)
112 : {
113 : case VSTR_CNTL_BASE_GET_CONF:
114 : {
115 30 : Vstr_conf **val = va_arg(ap, Vstr_conf **);
116 :
117 30 : vstr__add_user_conf(*val = base->conf);
118 :
119 30 : ret = TRUE;
120 : }
121 30 : break;
122 :
123 : case VSTR_CNTL_BASE_SET_CONF:
124 : {
125 20 : Vstr_conf *val = va_arg(ap, Vstr_conf *);
126 :
127 20 : if (!val)
128 5 : val = vstr__options.def;
129 :
130 20 : if (base->conf == val)
131 5 : ret = TRUE;
132 15 : else if (((val->buf_sz == base->conf->buf_sz) || !base->len) &&
133 : vstr__cache_subset_cbs(val, base->conf))
134 : {
135 15 : vstr__del_conf(base->conf);
136 15 : vstr__add_base_conf(base, val);
137 :
138 15 : ret = TRUE;
139 : }
140 : }
141 15 : break;
142 :
143 : case VSTR_CNTL_BASE_GET_FLAG_HAVE_CACHE:
144 : {
145 4108 : int *val = va_arg(ap, int *);
146 :
147 4108 : *val = !!base->cache_available;
148 :
149 4108 : ret = TRUE;
150 : }
151 4108 : break;
152 :
153 : case VSTR_CNTL_BASE_GET_TYPE_GRPALLOC_CACHE:
154 : {
155 20 : unsigned int *val = va_arg(ap, unsigned int *);
156 :
157 20 : *val = base->grpalloc_cache;
158 :
159 20 : ret = TRUE;
160 : }
161 :
162 4 : ASSERT_NO_SWITCH_DEF();
163 : }
164 :
165 4178 : va_end(ap);
166 :
167 4178 : return (ret);
168 : }
169 :
170 : int vstr_cntl_conf(Vstr_conf *passed_conf, int option, ...)
171 2511952 : {
172 2511952 : Vstr_conf *conf = passed_conf ? passed_conf : vstr__options.def;
173 2511952 : int ret = 0;
174 2511952 : va_list ap;
175 :
176 2511952 : assert(conf->user_ref <= conf->ref);
177 :
178 2511952 : va_start(ap, option);
179 :
180 2511952 : switch (option)
181 : {
182 : case VSTR_CNTL_CONF_GET_NUM_REF:
183 : {
184 25 : int *val = va_arg(ap, int *);
185 :
186 25 : *val = conf->ref;
187 25 : ret = TRUE;
188 : }
189 25 : break;
190 :
191 : case VSTR_CNTL_CONF_GET_NUM_IOV_MIN_ALLOC:
192 : {
193 1027 : int *val = va_arg(ap, int *);
194 :
195 1027 : *val = conf->iov_min_alloc;
196 :
197 1027 : ret = TRUE;
198 : }
199 1027 : break;
200 :
201 : case VSTR_CNTL_CONF_SET_NUM_IOV_MIN_ALLOC:
202 : {
203 1027 : int val = va_arg(ap, int);
204 :
205 1027 : conf->iov_min_alloc = val;
206 :
207 1027 : ret = TRUE;
208 : }
209 1027 : break;
210 :
211 : case VSTR_CNTL_CONF_GET_NUM_IOV_MIN_OFFSET:
212 : {
213 10 : int *val = va_arg(ap, int *);
214 :
215 10 : *val = conf->iov_min_offset;
216 :
217 10 : ret = TRUE;
218 : }
219 10 : break;
220 :
221 : case VSTR_CNTL_CONF_SET_NUM_IOV_MIN_OFFSET:
222 : {
223 10 : int val = va_arg(ap, int);
224 :
225 10 : conf->iov_min_offset = val;
226 :
227 10 : ret = TRUE;
228 : }
229 10 : break;
230 :
231 : case VSTR_CNTL_CONF_GET_NUM_BUF_SZ:
232 : {
233 1174 : unsigned int *val = va_arg(ap, unsigned int *);
234 :
235 1174 : *val = conf->buf_sz;
236 :
237 1174 : ret = TRUE;
238 : }
239 1174 : break;
240 :
241 : case VSTR_CNTL_CONF_SET_NUM_BUF_SZ:
242 : {
243 2955 : unsigned int val = va_arg(ap, unsigned int);
244 :
245 2955 : if (val > VSTR_MAX_NODE_BUF)
246 5 : val = VSTR_MAX_NODE_BUF;
247 :
248 : /* this is too restrictive, but getting it "right" would require too much
249 : * bookkeeping. */
250 2955 : if (!conf->spare_buf_num && (conf->user_ref == conf->ref))
251 : {
252 2955 : conf->buf_sz = val;
253 :
254 2955 : ret = TRUE;
255 : }
256 : }
257 2955 : break;
258 :
259 : case VSTR_CNTL_CONF_SET_LOC_CSTR_AUTO_NAME_NUMERIC:
260 : {
261 1035 : const char *val = va_arg(ap, const char *);
262 :
263 1035 : ret = vstr__make_conf_loc_numeric(conf, val);
264 : }
265 1035 : break;
266 :
267 : case VSTR_CNTL_CONF_GET_LOC_CSTR_NAME_NUMERIC:
268 : {
269 20 : const char **val = va_arg(ap, const char **);
270 :
271 20 : *val = conf->loc->name_lc_numeric_ref->ptr;
272 :
273 20 : ret = TRUE;
274 : }
275 20 : break;
276 :
277 : case VSTR_CNTL_CONF_SET_LOC_CSTR_NAME_NUMERIC:
278 : {
279 247 : const char *val = va_arg(ap, const char *);
280 247 : Vstr_ref *tmp = NULL;
281 :
282 247 : if (!(tmp = vstr_ref_make_strdup(val)))
283 1 : break;
284 :
285 246 : vstr_ref_del(conf->loc->name_lc_numeric_ref);
286 246 : conf->loc->name_lc_numeric_ref = tmp;
287 246 : conf->loc->name_lc_numeric_len = strlen(tmp->ptr);
288 :
289 246 : ret = TRUE;
290 : }
291 246 : break;
292 :
293 : case VSTR_CNTL_CONF_GET_LOC_CSTR_DEC_POINT:
294 : {
295 20 : const char **val = va_arg(ap, const char **);
296 20 : Vstr_locale_num_base *srch = vstr__loc_num_srch(conf->loc, 0, FALSE);
297 :
298 20 : *val = srch->decimal_point_ref->ptr;
299 :
300 20 : ret = TRUE;
301 : }
302 20 : break;
303 :
304 : case VSTR_CNTL_CONF_SET_LOC_CSTR_DEC_POINT:
305 : {
306 19 : const char *val = va_arg(ap, const char *);
307 19 : Vstr_ref *tmp = NULL;
308 19 : Vstr_locale_num_base *srch = vstr__loc_num_srch(conf->loc, 0, FALSE);
309 :
310 19 : if (!(tmp = vstr_ref_make_strdup(val)))
311 1 : break;
312 :
313 18 : vstr_ref_del(srch->decimal_point_ref);
314 18 : srch->decimal_point_ref = tmp;
315 18 : srch->decimal_point_len = strlen(tmp->ptr);
316 :
317 18 : ret = TRUE;
318 : }
319 18 : break;
320 :
321 : case VSTR_CNTL_CONF_GET_LOC_CSTR_THOU_SEP:
322 : {
323 20 : const char **val = va_arg(ap, const char **);
324 20 : Vstr_locale_num_base *srch = vstr__loc_num_srch(conf->loc, 0, FALSE);
325 :
326 20 : *val = srch->thousands_sep_ref->ptr;
327 :
328 20 : ret = TRUE;
329 : }
330 20 : break;
331 :
332 : case VSTR_CNTL_CONF_SET_LOC_CSTR_THOU_SEP:
333 : {
334 255 : const char *val = va_arg(ap, const char *);
335 255 : Vstr_ref *tmp = NULL;
336 255 : Vstr_locale_num_base *srch = vstr__loc_num_srch(conf->loc, 0, FALSE);
337 :
338 255 : if (!(tmp = vstr_ref_make_strdup(val)))
339 1 : break;
340 :
341 254 : vstr_ref_del(srch->thousands_sep_ref);
342 254 : srch->thousands_sep_ref = tmp;
343 254 : srch->thousands_sep_len = strlen(tmp->ptr);
344 :
345 254 : ret = TRUE;
346 : }
347 254 : break;
348 :
349 : case VSTR_CNTL_CONF_GET_LOC_CSTR_THOU_GRP:
350 : {
351 20 : const char **val = va_arg(ap, const char **);
352 20 : Vstr_locale_num_base *srch = vstr__loc_num_srch(conf->loc, 0, FALSE);
353 :
354 20 : *val = srch->grouping->ptr;
355 :
356 20 : ret = TRUE;
357 : }
358 20 : break;
359 :
360 : case VSTR_CNTL_CONF_SET_LOC_CSTR_THOU_GRP:
361 : {
362 266 : const char *val = va_arg(ap, const char *);
363 266 : Vstr_ref *tmp = NULL;
364 266 : size_t len = vstr__loc_thou_grp_strlen(val);
365 266 : Vstr_locale_num_base *srch = vstr__loc_num_srch(conf->loc, 0, FALSE);
366 :
367 266 : if (!(tmp = vstr_ref_make_malloc(len + 1)))
368 1 : break;
369 :
370 265 : vstr_ref_del(srch->grouping);
371 265 : if (len)
372 265 : vstr_wrap_memcpy(tmp->ptr, val, len);
373 265 : ((char *)tmp->ptr)[len] = 0;
374 265 : srch->grouping = tmp;
375 :
376 265 : ret = TRUE;
377 : }
378 265 : break;
379 :
380 : case VSTR_CNTL_CONF_GET_FLAG_IOV_UPDATE:
381 : {
382 10 : int *val = va_arg(ap, int *);
383 :
384 10 : *val = conf->iovec_auto_update;
385 :
386 10 : ret = TRUE;
387 : }
388 10 : break;
389 :
390 : case VSTR_CNTL_CONF_SET_FLAG_IOV_UPDATE:
391 : {
392 5 : int val = va_arg(ap, int);
393 :
394 5 : assert(val == !!val);
395 :
396 5 : conf->iovec_auto_update = val;
397 :
398 5 : ret = TRUE;
399 : }
400 5 : break;
401 :
402 : case VSTR_CNTL_CONF_GET_FLAG_DEL_SPLIT:
403 : {
404 10 : int *val = va_arg(ap, int *);
405 :
406 10 : *val = conf->split_buf_del;
407 :
408 10 : ret = TRUE;
409 : }
410 10 : break;
411 :
412 : case VSTR_CNTL_CONF_SET_FLAG_DEL_SPLIT:
413 : {
414 10 : int val = va_arg(ap, int);
415 :
416 10 : assert(val == !!val);
417 :
418 10 : conf->split_buf_del = val;
419 :
420 10 : ret = TRUE;
421 : }
422 10 : break;
423 :
424 : case VSTR_CNTL_CONF_GET_FLAG_ALLOC_CACHE:
425 : {
426 2114 : int *val = va_arg(ap, int *);
427 :
428 2114 : *val = !conf->no_cache;
429 :
430 2114 : ret = TRUE;
431 : }
432 2114 : break;
433 :
434 : case VSTR_CNTL_CONF_SET_FLAG_ALLOC_CACHE:
435 : {
436 1047 : int val = va_arg(ap, int);
437 :
438 1047 : assert(val == !!val);
439 :
440 1047 : ret = TRUE;
441 :
442 1047 : if (conf->no_cache == !val)
443 10 : break;
444 :
445 1037 : vstr__del_grpalloc(conf, conf->spare_base_num);
446 :
447 1037 : conf->no_cache = !val;
448 1037 : if (conf->no_cache)
449 1032 : conf->grpalloc_cache = VSTR_TYPE_CNTL_CONF_GRPALLOC_NONE;
450 : else
451 5 : conf->grpalloc_cache = VSTR_TYPE_CNTL_CONF_GRPALLOC_POS;
452 : }
453 5 : break;
454 :
455 : case VSTR_CNTL_CONF_GET_FMT_CHAR_ESC:
456 : {
457 10 : char *val = va_arg(ap, char *);
458 :
459 10 : *val = conf->fmt_usr_escape;
460 :
461 10 : ret = TRUE;
462 : }
463 10 : break;
464 :
465 : case VSTR_CNTL_CONF_SET_FMT_CHAR_ESC:
466 : {
467 408 : int val = va_arg(ap, int);
468 :
469 408 : conf->fmt_usr_escape = val;
470 :
471 408 : ret = TRUE;
472 : }
473 408 : break;
474 :
475 : case VSTR_CNTL_CONF_GET_NUM_SPARE_BUF:
476 : case VSTR_CNTL_CONF_GET_NUM_SPARE_NON:
477 : case VSTR_CNTL_CONF_GET_NUM_SPARE_PTR:
478 : case VSTR_CNTL_CONF_GET_NUM_SPARE_REF:
479 : {
480 140 : unsigned int *val = va_arg(ap, unsigned int *);
481 :
482 140 : switch (option)
483 : {
484 35 : case VSTR_CNTL_CONF_GET_NUM_SPARE_BUF: *val= conf->spare_buf_num; break;
485 35 : case VSTR_CNTL_CONF_GET_NUM_SPARE_NON: *val= conf->spare_non_num; break;
486 35 : case VSTR_CNTL_CONF_GET_NUM_SPARE_PTR: *val= conf->spare_ptr_num; break;
487 35 : case VSTR_CNTL_CONF_GET_NUM_SPARE_REF: *val= conf->spare_ref_num; break;
488 : }
489 :
490 140 : ret = TRUE;
491 : }
492 140 : break;
493 :
494 : case VSTR_CNTL_CONF_SET_NUM_SPARE_BUF:
495 : case VSTR_CNTL_CONF_SET_NUM_SPARE_NON:
496 : case VSTR_CNTL_CONF_SET_NUM_SPARE_PTR:
497 : case VSTR_CNTL_CONF_SET_NUM_SPARE_REF:
498 : {
499 349556 : unsigned int val = va_arg(ap, unsigned int);
500 349556 : unsigned int type = 0;
501 349556 : unsigned int spare_num = 0;
502 :
503 349556 : switch (option)
504 : {
505 : case VSTR_CNTL_CONF_SET_NUM_SPARE_BUF:
506 160380 : type = VSTR_TYPE_NODE_BUF;
507 160380 : spare_num = conf->spare_buf_num;
508 160380 : break;
509 : case VSTR_CNTL_CONF_SET_NUM_SPARE_NON:
510 1095 : type = VSTR_TYPE_NODE_NON;
511 1095 : spare_num = conf->spare_non_num;
512 1095 : break;
513 : case VSTR_CNTL_CONF_SET_NUM_SPARE_PTR:
514 114974 : type = VSTR_TYPE_NODE_PTR;
515 114974 : spare_num = conf->spare_ptr_num;
516 114974 : break;
517 : case VSTR_CNTL_CONF_SET_NUM_SPARE_REF:
518 73107 : type = VSTR_TYPE_NODE_REF;
519 73107 : spare_num = conf->spare_ref_num;
520 : break;
521 : }
522 :
523 349556 : if (val == spare_num)
524 : { /* do nothing */ }
525 349556 : else if (val > spare_num)
526 : {
527 349434 : unsigned int num = 0;
528 :
529 349434 : num = vstr_make_spare_nodes(conf, type, val - spare_num);
530 349434 : if (num != (val - spare_num))
531 : {
532 32753 : assert(ret == FALSE);
533 37 : break;
534 : }
535 : }
536 122 : else if (val < spare_num)
537 : {
538 122 : unsigned int num = 0;
539 :
540 122 : num = vstr_free_spare_nodes(conf, type, spare_num - val);
541 207959 : ASSERT(num == (spare_num - val));
542 : }
543 :
544 316803 : ret = TRUE;
545 : }
546 316803 : break;
547 :
548 : case VSTR_CNTL_CONF_SET_NUM_RANGE_SPARE_BUF:
549 : case VSTR_CNTL_CONF_SET_NUM_RANGE_SPARE_NON:
550 : case VSTR_CNTL_CONF_SET_NUM_RANGE_SPARE_PTR:
551 : case VSTR_CNTL_CONF_SET_NUM_RANGE_SPARE_REF:
552 : {
553 2059975 : unsigned int val_min = va_arg(ap, unsigned int);
554 2059975 : unsigned int val_max = va_arg(ap, unsigned int);
555 2059975 : unsigned int type = 0;
556 2059975 : unsigned int spare_num = 0;
557 :
558 2059975 : ASSERT(val_min <= val_max);
559 :
560 2059975 : switch (option)
561 : {
562 : case VSTR_CNTL_CONF_SET_NUM_RANGE_SPARE_BUF:
563 575983 : type = VSTR_CNTL_CONF_SET_NUM_SPARE_BUF;
564 575983 : spare_num = conf->spare_buf_num;
565 575983 : break;
566 : case VSTR_CNTL_CONF_SET_NUM_RANGE_SPARE_NON:
567 15216 : type = VSTR_CNTL_CONF_SET_NUM_SPARE_NON;
568 15216 : spare_num = conf->spare_non_num;
569 15216 : break;
570 : case VSTR_CNTL_CONF_SET_NUM_RANGE_SPARE_PTR:
571 548623 : type = VSTR_CNTL_CONF_SET_NUM_SPARE_PTR;
572 548623 : spare_num = conf->spare_ptr_num;
573 548623 : break;
574 : case VSTR_CNTL_CONF_SET_NUM_RANGE_SPARE_REF:
575 920153 : type = VSTR_CNTL_CONF_SET_NUM_SPARE_REF;
576 920153 : spare_num = conf->spare_ref_num;
577 :
578 211722 : ASSERT_NO_SWITCH_DEF();
579 : }
580 :
581 2059975 : if (0)
582 2059975 : { ASSERT(FALSE); }
583 2059975 : else if (val_min > spare_num)
584 349405 : return (vstr_cntl_conf(conf, type, val_min));
585 1710570 : else if (val_max < spare_num)
586 117 : return (vstr_cntl_conf(conf, type, val_max));
587 :
588 1710453 : ret = TRUE;
589 : }
590 1710453 : break;
591 :
592 : case VSTR_CNTL_CONF_GET_FLAG_ATOMIC_OPS:
593 : {
594 10 : int *val = va_arg(ap, int *);
595 :
596 10 : *val = conf->atomic_ops;
597 :
598 10 : ret = TRUE;
599 : }
600 10 : break;
601 :
602 : case VSTR_CNTL_CONF_SET_FLAG_ATOMIC_OPS:
603 : {
604 5 : int val = va_arg(ap, int);
605 :
606 5 : assert(val == !!val);
607 :
608 5 : conf->atomic_ops = val;
609 :
610 5 : ret = TRUE;
611 : }
612 5 : break;
613 :
614 : case VSTR_CNTL_CONF_GET_TYPE_GRPALLOC_CACHE:
615 : {
616 60 : unsigned int *val = va_arg(ap, unsigned int *);
617 :
618 60 : *val = conf->grpalloc_cache;
619 :
620 60 : ret = TRUE;
621 : }
622 60 : break;
623 :
624 : case VSTR_CNTL_CONF_SET_TYPE_GRPALLOC_CACHE:
625 : {
626 161 : unsigned int val = va_arg(ap, unsigned int);
627 :
628 161 : ASSERT_RET(((val == VSTR_TYPE_CNTL_CONF_GRPALLOC_NONE) ||
629 : (val == VSTR_TYPE_CNTL_CONF_GRPALLOC_POS) ||
630 : (val == VSTR_TYPE_CNTL_CONF_GRPALLOC_IOVEC) ||
631 : (val == VSTR_TYPE_CNTL_CONF_GRPALLOC_CSTR) ||
632 : FALSE), FALSE);
633 :
634 161 : ret = TRUE;
635 :
636 161 : if (conf->grpalloc_cache == val)
637 20 : break;
638 :
639 141 : vstr__del_grpalloc(conf, conf->spare_base_num);
640 :
641 141 : conf->grpalloc_cache = val;
642 141 : if (val == VSTR_TYPE_CNTL_CONF_GRPALLOC_NONE)
643 5 : conf->no_cache = TRUE;
644 : else
645 136 : conf->no_cache = FALSE;
646 : }
647 136 : break;
648 :
649 : case VSTR_CNTL_CONF_GET_NUM_SPARE_BASE:
650 : {
651 180 : unsigned int *val = va_arg(ap, unsigned int *);
652 :
653 180 : *val = conf->spare_base_num;
654 :
655 180 : ret = TRUE;
656 : }
657 180 : break;
658 :
659 : case VSTR_CNTL_CONF_SET_NUM_SPARE_BASE:
660 : {
661 206 : unsigned int val = va_arg(ap, unsigned int);
662 206 : unsigned int spare_num = conf->spare_base_num;
663 :
664 206 : if (val == spare_num)
665 : { /* do nothing */ }
666 205 : else if (val > spare_num)
667 : {
668 21 : Vstr_base *tmp = NULL;
669 21 : Vstr_base *old_beg = NULL;
670 21 : unsigned int old_num = 0;
671 :
672 61 : while (conf->spare_base_num < val)
673 : {
674 41 : old_beg = conf->spare_base_beg;
675 41 : old_num = conf->spare_base_num;
676 :
677 41 : conf->spare_base_beg = NULL;
678 41 : conf->spare_base_num = 0;
679 :
680 41 : tmp = vstr_make_base(conf);
681 :
682 41 : conf->spare_base_beg = old_beg;
683 41 : conf->spare_base_num = old_num;
684 :
685 41 : if (!tmp)
686 1 : return (FALSE);
687 :
688 40 : vstr_free_base(tmp);
689 : }
690 : }
691 184 : else if (val < spare_num)
692 184 : vstr__del_grpalloc(conf, spare_num - val);
693 :
694 205 : ret = TRUE;
695 : }
696 205 : break;
697 :
698 : case VSTR_CNTL_CONF_SET_NUM_RANGE_SPARE_BASE:
699 : {
700 89724 : unsigned int val_min = va_arg(ap, unsigned int);
701 89724 : unsigned int val_max = va_arg(ap, unsigned int);
702 89724 : unsigned int spare_num = conf->spare_base_num;
703 :
704 89724 : ASSERT(val_min <= val_max);
705 :
706 89724 : if (0)
707 89724 : { ASSERT(FALSE); }
708 89724 : else if (val_min > spare_num)
709 21 : return (vstr_cntl_conf(conf,
710 : VSTR_CNTL_CONF_SET_NUM_SPARE_BASE, val_min));
711 89703 : else if (val_max < spare_num)
712 40 : return (vstr_cntl_conf(conf,
713 : VSTR_CNTL_CONF_SET_NUM_SPARE_BASE, val_max));
714 :
715 89663 : ret = TRUE;
716 : }
717 89663 : break;
718 :
719 : case VSTR_CNTL_CONF_GET_LOC_REF_NAME_NUMERIC:
720 : {
721 10 : Vstr_ref **val_ref = va_arg(ap, Vstr_ref **);
722 10 : size_t *val_len = va_arg(ap, size_t *);
723 :
724 10 : *val_ref = vstr_ref_add(conf->loc->name_lc_numeric_ref);
725 10 : *val_len = conf->loc->name_lc_numeric_len;
726 :
727 10 : ret = TRUE;
728 : }
729 10 : break;
730 :
731 : case VSTR_CNTL_CONF_SET_LOC_REF_NAME_NUMERIC:
732 : {
733 5 : Vstr_ref *tmp = va_arg(ap, Vstr_ref *);
734 5 : size_t len = va_arg(ap, size_t);
735 :
736 5 : vstr_ref_del(conf->loc->name_lc_numeric_ref);
737 :
738 5 : conf->loc->name_lc_numeric_ref = vstr_ref_add(tmp);
739 5 : conf->loc->name_lc_numeric_len = len;
740 :
741 5 : ret = TRUE;
742 : }
743 5 : break;
744 :
745 : case VSTR_CNTL_CONF_GET_LOC_REF_DEC_POINT:
746 : {
747 50 : unsigned int nb = va_arg(ap, unsigned int);
748 50 : Vstr_ref **val_ref = va_arg(ap, Vstr_ref **);
749 50 : size_t *val_len = va_arg(ap, size_t *);
750 50 : Vstr_locale_num_base *srch = vstr__loc_num_srch(conf->loc, nb, FALSE);
751 :
752 50 : *val_ref = vstr_ref_add(srch->decimal_point_ref);
753 50 : *val_len = srch->decimal_point_len;
754 :
755 50 : ret = TRUE;
756 : }
757 50 : break;
758 :
759 : case VSTR_CNTL_CONF_SET_LOC_REF_DEC_POINT:
760 : {
761 25 : unsigned int nb = va_arg(ap, unsigned int);
762 25 : Vstr_ref *tmp = va_arg(ap, Vstr_ref *);
763 25 : size_t len = va_arg(ap, size_t);
764 25 : Vstr_locale_num_base *srch = vstr__loc_num_srch(conf->loc, nb, TRUE);
765 :
766 25 : if (!srch) break;
767 :
768 25 : vstr_ref_del(srch->decimal_point_ref);
769 :
770 25 : srch->decimal_point_ref = vstr_ref_add(tmp);
771 25 : srch->decimal_point_len = len;
772 :
773 25 : ret = TRUE;
774 : }
775 25 : break;
776 :
777 : case VSTR_CNTL_CONF_GET_LOC_REF_THOU_SEP:
778 : {
779 10 : unsigned int nb = va_arg(ap, unsigned int);
780 10 : Vstr_ref **val_ref = va_arg(ap, Vstr_ref **);
781 10 : size_t *val_len = va_arg(ap, size_t *);
782 10 : Vstr_locale_num_base *srch = vstr__loc_num_srch(conf->loc, nb, FALSE);
783 :
784 10 : *val_ref = vstr_ref_add(srch->thousands_sep_ref);
785 10 : *val_len = srch->thousands_sep_len;
786 :
787 10 : ret = TRUE;
788 : }
789 10 : break;
790 :
791 : case VSTR_CNTL_CONF_SET_LOC_REF_THOU_SEP:
792 : {
793 31 : unsigned int nb = va_arg(ap, unsigned int);
794 31 : Vstr_ref *tmp = va_arg(ap, Vstr_ref *);
795 31 : size_t len = va_arg(ap, size_t);
796 31 : Vstr_locale_num_base *srch = vstr__loc_num_srch(conf->loc, nb, TRUE);
797 :
798 31 : if (!srch) break;
799 :
800 30 : vstr_ref_del(srch->thousands_sep_ref);
801 :
802 30 : srch->thousands_sep_ref = vstr_ref_add(tmp);
803 30 : srch->thousands_sep_len = len;
804 :
805 30 : ret = TRUE;
806 : }
807 30 : break;
808 :
809 : case VSTR_CNTL_CONF_GET_LOC_REF_THOU_GRP:
810 : {
811 10 : unsigned int nb = va_arg(ap, unsigned int);
812 10 : Vstr_ref **val_ref = va_arg(ap, Vstr_ref **);
813 10 : Vstr_locale_num_base *srch = vstr__loc_num_srch(conf->loc, nb, FALSE);
814 :
815 10 : *val_ref = vstr_ref_add(srch->grouping);
816 :
817 10 : ret = TRUE;
818 : }
819 10 : break;
820 :
821 : case VSTR_CNTL_CONF_SET_LOC_REF_THOU_GRP:
822 : {
823 25 : unsigned int nb = va_arg(ap, unsigned int);
824 25 : Vstr_ref *tmp = va_arg(ap, Vstr_ref *);
825 25 : Vstr_locale_num_base *srch = vstr__loc_num_srch(conf->loc, nb, TRUE);
826 :
827 25 : if (!srch) break;
828 :
829 25 : vstr_ref_del(srch->grouping);
830 :
831 25 : srch->grouping = vstr_ref_add(tmp);
832 :
833 25 : ret = TRUE;
834 : }
835 25 : break;
836 :
837 : case VSTR_CNTL_CONF_GET_LOC_REF_NULL_PTR:
838 : {
839 10 : Vstr_ref **val_ref = va_arg(ap, Vstr_ref **);
840 10 : size_t *val_len = va_arg(ap, size_t *);
841 :
842 10 : *val_ref = vstr_ref_add(conf->loc->null_ref);
843 10 : *val_len = conf->loc->null_len;
844 :
845 10 : ret = TRUE;
846 : }
847 10 : break;
848 :
849 : case VSTR_CNTL_CONF_SET_LOC_REF_NULL_PTR:
850 : {
851 15 : Vstr_ref *tmp = va_arg(ap, Vstr_ref *);
852 15 : size_t len = va_arg(ap, size_t);
853 :
854 15 : vstr_ref_del(conf->loc->null_ref);
855 :
856 15 : conf->loc->null_ref = vstr_ref_add(tmp);
857 15 : conf->loc->null_len = len;
858 :
859 15 : ret = TRUE;
860 : }
861 : /* break in assert */
862 :
863 3 : ASSERT_NO_SWITCH_DEF();
864 : }
865 :
866 2162368 : va_end(ap);
867 :
868 2162368 : return (ret);
869 : }
|
