mpdm_s.c

   1 /*
   2
   3     MPDM - Minimum Profit Data Manager
   4     Copyright (C) 2003/2010 Angel Ortega <angel@triptico.com>
   5
   6     mpdm_s.c - String management
   7
   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.
  12
  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.
  17
  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.
  21
  22     http://www.triptico.com
  23
  24 */
  25
  26 #include "config.h"
  27
  28 #include <stdio.h>
  29 #include <stdlib.h>
  30 #include <string.h>
  31 #include <wchar.h>
  32 #include <locale.h>
  33 #include <wctype.h>
  34
  35 #ifdef CONFOPT_GETTEXT
  36 #include <libintl.h>
  37 #endif
  38
  39 #ifdef CONFOPT_WIN32
  40 #include <windows.h>
  41 #endif
  42
  43 #include "mpdm.h"
  44
  45
  46 /** code **/
  47
  48 void *mpdm_poke_o(void *dst, int *dsize, int *offset, const void *org, int osize, int esize)
  49 {
  50         if (org != NULL && osize) {
  51                 /* enough room? */
  52                 if (*offset + osize > *dsize) {
  53                         /* no; enlarge */
  54                         *dsize += osize;
  55
  56                         dst = realloc(dst, *dsize * esize);
  57                 }
  58
  59                 memcpy((char *)dst + (*offset * esize), org, osize * esize);
  60                 *offset += osize;
  61         }
  62
  63         return dst;
  64 }
  65
  66
  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 */
  69 {
  70         int offset = *dsize;
  71
  72         return mpdm_poke_o(dst, dsize, &offset, org, osize, esize);
  73 }
  74
  75
  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 */
  78 {
  79         if (str)
  80                 dst = mpdm_poke(dst, dsize, str, slen, sizeof(wchar_t));
  81
  82         return dst;
  83 }
  84
  85
  86 wchar_t *mpdm_pokews(wchar_t *dst, int *dsize, const wchar_t *str)
  87 /* adds a wide string to dst using mpdm_poke() */
  88 {
  89         if (str)
  90                 dst = mpdm_pokewsn(dst, dsize, str, wcslen(str));
  91
  92         return dst;
  93 }
  94
  95
  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() */
  98 {
  99         if (v != NULL) {
 100                 const wchar_t *ptr = mpdm_string(v);
 101
 102                 dst = mpdm_pokews(dst, dsize, ptr);
 103         }
 104
 105         return dst;
 106 }
 107
 108
 109 wchar_t *mpdm_mbstowcs(const char *str, int *s, int l)
 110 /* converts an mbs to a wcs, but filling invalid chars
 111    with question marks instead of just failing */
 112 {
 113         wchar_t *ptr = NULL;
 114         char tmp[64];           /* really MB_CUR_MAX + 1 */
 115         wchar_t wc;
 116         int n, i, c, t = 0;
 117         char *cstr;
 118
 119         /* allow NULL values for s */
 120         if (s == NULL)
 121                 s = &t;
 122
 123         /* if there is a limit, duplicate and break the string */
 124         if (l >= 0) {
 125                 cstr = strdup(str);
 126                 cstr[l] = '\0';
 127         }
 128         else
 129                 cstr = (char *) str;
 130
 131         /* try first a direct conversion with mbstowcs */
 132         if ((*s = mbstowcs(NULL, cstr, 0)) != -1) {
 133                 /* direct conversion is possible; do it */
 134                 if ((ptr = malloc((*s + 1) * sizeof(wchar_t))) != NULL) {
 135                         mbstowcs(ptr, cstr, *s);
 136                         ptr[*s] = L'\0';
 137                 }
 138         }
 139         else {
 140                 /* zero everything */
 141                 *s = n = i = 0;
 142
 143                 for (;;) {
 144                         /* no more characters to process? */
 145                         if ((c = cstr[n + i]) == '\0' && i == 0)
 146                                 break;
 147
 148                         tmp[i++] = c;
 149                         tmp[i] = '\0';
 150
 151                         /* try to convert */
 152                         if (mbstowcs(&wc, tmp, 1) == (size_t) -1) {
 153                                 /* can still be an incomplete multibyte char? */
 154                                 if (c != '\0' && i <= (int) MB_CUR_MAX)
 155                                         continue;
 156                                 else {
 157                                         /* too many failing bytes; skip 1 byte */
 158                                         wc = L'?';
 159                                         i = 1;
 160                                 }
 161                         }
 162
 163                         /* skip used bytes and back again */
 164                         n += i;
 165                         i = 0;
 166
 167                         /* store new char */
 168                         if ((ptr = mpdm_poke(ptr, s, &wc, 1, sizeof(wchar_t))) == NULL)
 169                                 break;
 170                 }
 171
 172                 /* null terminate and count one less */
 173                 if (ptr != NULL) {
 174                         ptr = mpdm_poke(ptr, s, L"", 1, sizeof(wchar_t));
 175                         (*s)--;
 176                 }
 177         }
 178
 179         /* free the duplicate */
 180         if (cstr != str)
 181                 free(cstr);
 182
 183         return ptr;
 184 }
 185
 186
 187 char *mpdm_wcstombs(const wchar_t * str, int *s)
 188 /* converts a wcs to an mbs, but filling invalid chars
 189    with question marks instead of just failing */
 190 {
 191         char *ptr = NULL;
 192         char tmp[64];           /* really MB_CUR_MAX + 1 */
 193         int l, t = 0;
 194
 195         /* allow NULL values for s */
 196         if (s == NULL)
 197                 s = &t;
 198
 199         /* try first a direct conversion with wcstombs */
 200         if ((*s = wcstombs(NULL, str, 0)) != -1) {
 201                 /* direct conversion is possible; do it and return */
 202                 if ((ptr = malloc(*s + 1)) != NULL) {
 203                         wcstombs(ptr, str, *s);
 204                         ptr[*s] = '\0';
 205                 }
 206
 207                 return ptr;
 208         }
 209
 210         /* invalid encoding? convert characters one by one */
 211         *s = 0;
 212
 213         while (*str) {
 214                 if ((l = wctomb(tmp, *str)) <= 0) {
 215                         /* if char couldn't be converted,
 216                            write a question mark instead */
 217                         l = wctomb(tmp, L'?');
 218                 }
 219
 220                 tmp[l] = '\0';
 221                 if ((ptr = mpdm_poke(ptr, s, tmp, l, 1)) == NULL)
 222                         break;
 223
 224                 str++;
 225         }
 226
 227         /* null terminate and count one less */
 228         if (ptr != NULL) {
 229                 ptr = mpdm_poke(ptr, s, "", 1, 1);
 230                 (*s)--;
 231         }
 232
 233         return ptr;
 234 }
 235
 236
 237 mpdm_t mpdm_new_wcs(int flags, const wchar_t * str, int size, int cpy)
 238 /* creates a new string value from a wcs */
 239 {
 240         wchar_t *ptr;
 241
 242         /* a size of -1 means 'calculate it' */
 243         if (size == -1 && str != NULL)
 244                 size = wcslen(str);
 245
 246         /* create a copy? */
 247         if (cpy) {
 248                 /* free() on destruction */
 249                 flags |= MPDM_FREE;
 250
 251                 /* allocs */
 252                 if ((ptr = malloc((size + 1) * sizeof(wchar_t))) == NULL)
 253                         return NULL;
 254
 255                 /* if no source, reset to zeroes; otherwise, copy */
 256                 if (str == NULL)
 257                         memset(ptr, '\0', size * sizeof(wchar_t));
 258                 else {
 259                         wcsncpy(ptr, str, size);
 260                         ptr[size] = L'\0';
 261                 }
 262         }
 263         else
 264                 ptr = (wchar_t *)str;
 265
 266         /* it's a string */
 267         flags |= MPDM_STRING;
 268
 269         return mpdm_new(flags, ptr, size);
 270 }
 271
 272
 273 mpdm_t mpdm_new_mbstowcs(int flags, const char *str, int l)
 274 /* creates a new string value from an mbs */
 275 {
 276         wchar_t *ptr;
 277         int size;
 278
 279         if ((ptr = mpdm_mbstowcs(str, &size, l)) == NULL)
 280                 return NULL;
 281
 282         /* it's a string */
 283         flags |= (MPDM_STRING | MPDM_FREE);
 284
 285         return mpdm_new(flags, ptr, size);
 286 }
 287
 288
 289 mpdm_t mpdm_new_wcstombs(int flags, const wchar_t * str)
 290 /* creates a new mbs value from a wbs */
 291 {
 292         char *ptr;
 293         int size;
 294
 295         ptr = mpdm_wcstombs(str, &size);
 296
 297         flags |= MPDM_FREE;
 298
 299         /* unset the string flag; mbs,s are not 'strings' */
 300         flags &= ~MPDM_STRING;
 301
 302         return mpdm_new(flags, ptr, size);
 303 }
 304
 305
 306 mpdm_t mpdm_new_i(int ival)
 307 /* creates a new string value from an integer */
 308 {
 309         mpdm_t v;
 310         char tmp[32];
 311
 312         /* creates the visual representation */
 313         snprintf(tmp, sizeof(tmp), "%d", ival);
 314
 315         v = MPDM_MBS(tmp);
 316
 317         return mpdm_set_ival(v, ival);
 318 }
 319
 320
 321 mpdm_t mpdm_new_r(double rval)
 322 /* creates a new string value from a real number */
 323 {
 324         mpdm_t v;
 325         char tmp[128];
 326
 327         /* creates the visual representation */
 328         snprintf(tmp, sizeof(tmp), "%lf", rval);
 329
 330         /* manually strip useless zeroes */
 331         if (strchr(tmp, '.') != NULL) {
 332                 char *ptr;
 333
 334                 for (ptr = tmp + strlen(tmp) - 1; *ptr == '0'; ptr--);
 335
 336                 /* if it's over the ., strip it also */
 337                 if (*ptr != '.')
 338                         ptr++;
 339
 340                 *ptr = '\0';
 341         }
 342
 343         v = MPDM_MBS(tmp);
 344
 345         return mpdm_set_rval(v, rval);
 346 }
 347
 348
 349 /* interface */
 350
 351 /**
 352  * mpdm_string - Returns a printable representation of a value.
 353  * @v: the value
 354  *
 355  * Returns a printable representation of a value. For strings, it's
 356  * the value data itself; for any other type, a conversion to string
 357  * is returned instead. This value should be used immediately, as it
 358  * can be a pointer to a static buffer.
 359  * [Strings]
 360  */
 361 wchar_t *mpdm_string(const mpdm_t v)
 362 {
 363         static wchar_t wtmp[32];
 364         char tmp[32];
 365
 366         /* if it's NULL, return a constant */
 367         if (v == NULL)
 368                 return L"[NULL]";
 369
 370         /* if it's a string, return it */
 371         if (v->flags & MPDM_STRING)
 372                 return (wchar_t *) v->data;
 373
 374         /* otherwise, return a visual representation */
 375         snprintf(tmp, sizeof(tmp), "%p", v);
 376         mbstowcs(wtmp, tmp, sizeof(wtmp));
 377         wtmp[(sizeof(wtmp) / sizeof(wchar_t)) - 1] = L'\0';
 378
 379         return wtmp;
 380 }
 381
 382
 383 /**
 384  * mpdm_cmp - Compares two values.
 385  * @v1: the first value
 386  * @v2: the second value
 387  *
 388  * Compares two values. If both has the MPDM_STRING flag set,
 389  * a comparison using wcscoll() is returned; if both are arrays,
 390  * the size is compared first and, if they have the same number
 391  * elements, each one is compared; otherwise, a simple pointer
 392  * comparison is done.
 393  * [Strings]
 394  */
 395 int mpdm_cmp(const mpdm_t v1, const mpdm_t v2)
 396 {
 397         int r;
 398
 399         /* same values? */
 400         if (v1 == v2)
 401                 return 0;
 402
 403         /* is any value NULL? */
 404         if (v1 == NULL)
 405                 return -1;
 406         if (v2 == NULL)
 407                 return 1;
 408
 409         /* different values, but same content? (unlikely) */
 410         if (v1->data == v2->data)
 411                 return 0;
 412
 413         if (MPDM_IS_STRING(v1) && MPDM_IS_STRING(v2))
 414                 r = wcscoll((wchar_t *) v1->data, (wchar_t *) v2->data);
 415         else
 416         if (MPDM_IS_ARRAY(v1) && MPDM_IS_ARRAY(v2)) {
 417                 /* compare first the sizes */
 418                 if ((r = mpdm_size(v1) - mpdm_size(v2)) == 0) {
 419                         int n;
 420
 421                         /* they have the same size;
 422                            compare each pair of elements */
 423                         for (n = 0; n < mpdm_size(v1); n++) {
 424                                 if ((r = mpdm_cmp(mpdm_aget(v1, n),
 425                                         mpdm_aget(v2, n))) != 0)
 426                                         break;
 427                         }
 428                 }
 429         }
 430         else
 431                 /* in any other case, compare just pointers */
 432                 r = (int) ((char *)v1->data - (char *)v2->data);
 433
 434         return r;
 435 }
 436
 437
 438 /**
 439  * mpdm_cmp_s - Compares two values (string version).
 440  * @v1: the first value
 441  * @v2: the second value
 442  *
 443  * Compares two values. Compares both values using wcscoll()
 444  * if the first one is a string, or returns 1 otherwise.
 445  */
 446 int mpdm_cmp_s(const mpdm_t v1, const wchar_t *v2)
 447 {
 448         int r = 1;
 449
 450         if (MPDM_IS_STRING(v1))
 451                 r = wcscoll((wchar_t *) v1->data, v2);
 452
 453         return r;
 454 }
 455
 456
 457 /**
 458  * mpdm_splice - Creates a new string value from another.
 459  * @v: the original value
 460  * @i: the value to be inserted
 461  * @offset: offset where the substring is to be inserted
 462  * @del: number of characters to delete
 463  *
 464  * Creates a new string value from @v, deleting @del chars at @offset
 465  * and substituting them by @i. If @del is 0, no deletion is done.
 466  * both @offset and @del can be negative; if this is the case, it's
 467  * assumed as counting from the end of @v. If @v is NULL, @i will become
 468  * the new string, and both @offset and @del will be ignored. If @v is
 469  * not NULL and @i is, no insertion process is done (only deletion, if
 470  * applicable).
 471  *
 472  * Returns a two element array, with the new string in the first
 473  * element and the deleted string in the second (with a NULL value
 474  * if @del is 0).
 475  * [Strings]
 476  */
 477 mpdm_t mpdm_splice(const mpdm_t v, const mpdm_t i, int offset, int del)
 478 {
 479         mpdm_t w;
 480         mpdm_t n = NULL;
 481         mpdm_t d = NULL;
 482         int os, ns, r;
 483         int ins = 0;
 484         wchar_t *ptr;
 485
 486         if (v != NULL) {
 487                 os = mpdm_size(v);
 488
 489                 /* negative offsets start from the end */
 490                 if (offset < 0)
 491                         offset = os + 1 - offset;
 492
 493                 /* never add further the end */
 494                 if (offset > os)
 495                         offset = os;
 496
 497                 /* negative del counts as 'characters left' */
 498                 if (del < 0)
 499                         del = os + 1 - offset + del;
 500
 501                 /* something to delete? */
 502                 if (del > 0) {
 503                         /* never delete further the end */
 504                         if (offset + del > os)
 505                                 del = os - offset;
 506
 507                         /* deleted string */
 508                         d = MPDM_NS(((wchar_t *) v->data) + offset, del);
 509                 }
 510                 else
 511                         del = 0;
 512
 513                 /* something to insert? */
 514                 ins = mpdm_size(i);
 515
 516                 /* new size and remainder */
 517                 ns = os + ins - del;
 518                 r = offset + del;
 519
 520                 if ((n = MPDM_NS(NULL, ns)) == NULL)
 521                         return NULL;
 522
 523                 ptr = (wchar_t *)n->data;
 524
 525                 /* copy the beginning */
 526                 if (offset > 0) {
 527                         wcsncpy(ptr, v->data, offset);
 528                         ptr += offset;
 529                 }
 530
 531                 /* copy the text to be inserted */
 532                 if (ins > 0) {
 533                         wcsncpy(ptr, i->data, ins);
 534                         ptr += ins;
 535                 }
 536
 537                 /* copy the remaining */
 538                 os -= r;
 539                 if (os > 0) {
 540                         wcsncpy(ptr, ((wchar_t *) v->data) + r, os);
 541                         ptr += os;
 542                 }
 543
 544                 /* null terminate */
 545                 *ptr = L'\0';
 546         }
 547         else
 548                 n = i;
 549
 550         /* creates the output array */
 551         w = MPDM_A(2);
 552
 553         mpdm_aset(w, n, 0);
 554         mpdm_aset(w, d, 1);
 555
 556         return w;
 557 }
 558
 559
 560 /**
 561  * mpdm_strcat_sn - Concatenates two strings (string with size version).
 562  * @s1: the first string
 563  * @s2: the second string
 564  * @size: the size of the second string
 565  *
 566  * Returns a new string formed by the concatenation of @s1 and @s2.
 567  * [Strings]
 568  */
 569 mpdm_t mpdm_strcat_sn(const mpdm_t s1, const wchar_t *s2, int size)
 570 {
 571         wchar_t *ptr = NULL;
 572         int s = 0;
 573
 574         if (s1 == NULL && s2 == NULL)
 575                 return NULL;
 576
 577         ptr = mpdm_pokev(ptr, &s, s1);
 578         ptr = mpdm_pokewsn(ptr, &s, s2, size);
 579
 580         /* if no characters were added, returns an empty string */
 581         if (ptr == NULL)
 582                 return MPDM_LS(L"");
 583
 584         ptr = mpdm_poke(ptr, &s, L"", 1, sizeof(wchar_t));
 585         return MPDM_ENS(ptr, s - 1);
 586 }
 587
 588
 589 /**
 590  * mpdm_strcat_s - Concatenates two strings (string version).
 591  * @s1: the first string
 592  * @s2: the second string
 593  *
 594  * Returns a new string formed by the concatenation of @s1 and @s2.
 595  * [Strings]
 596  */
 597 mpdm_t mpdm_strcat_s(const mpdm_t s1, const wchar_t *s2)
 598 {
 599         return mpdm_strcat_sn(s1, s2, s2 ? wcslen(s2) : 0);
 600 }
 601
 602
 603 /**
 604  * mpdm_strcat - Concatenates two strings.
 605  * @s1: the first string
 606  * @s2: the second string
 607  *
 608  * Returns a new string formed by the concatenation of @s1 and @s2.
 609  * [Strings]
 610  */
 611 mpdm_t mpdm_strcat(const mpdm_t s1, const mpdm_t s2)
 612 {
 613         return mpdm_strcat_s(s1, s2 ? mpdm_string(s2) : NULL);
 614 }
 615
 616
 617 /**
 618  * mpdm_ival - Returns a value's data as an integer.
 619  * @v: the value
 620  *
 621  * Returns a value's data as an integer. If the value is a string,
 622  * it's converted via sscanf and returned; non-string values have all
 623  * an ival of 0. The converted integer is cached, so costly string
 624  * conversions are only done once. Values created with the MPDM_IVAL
 625  * flag set have its ival cached from the beginning.
 626  * [Strings]
 627  * [Value Management]
 628  */
 629 int mpdm_ival(mpdm_t v)
 630 {
 631         if (v == NULL)
 632                 return 0;
 633
 634         /* if there is no cached integer, calculate it */
 635         if (!(v->flags & MPDM_IVAL)) {
 636                 int i = 0;
 637
 638                 /* if it's a string, calculate it; other
 639                    values will have an ival of 0 */
 640                 if (v->flags & MPDM_STRING) {
 641                         char tmp[32];
 642                         char *fmt = "%i";
 643
 644                         wcstombs(tmp, (wchar_t *) v->data, sizeof(tmp));
 645                         tmp[sizeof(tmp) - 1] = '\0';
 646
 647                         /* workaround for mingw32: as it doesn't
 648                            correctly parse octal and hexadecimal
 649                            numbers, they are tried as special cases */
 650                         if (tmp[0] == '0') {
 651                                 if (tmp[1] == 'b' || tmp[1] == 'B') {
 652                                         /* binary number */
 653                                         fmt = NULL;
 654                                         char *ptr = &tmp[2];
 655
 656                                         while (*ptr == '0' || *ptr == '1') {
 657                                                 i <<= 1;
 658
 659                                                 if (*ptr == '1')
 660                                                         i |= 1;
 661
 662                                                 ptr++;
 663                                         }
 664                                 }
 665                                 else
 666                                 if (tmp[1] == 'x' || tmp[1] == 'X')
 667                                         fmt = "%x";
 668                                 else
 669                                         fmt = "%o";
 670                         }
 671
 672                         if (fmt != NULL)
 673                                 sscanf(tmp, fmt, &i);
 674                 }
 675
 676                 mpdm_set_ival(v, i);
 677         }
 678
 679         return v->ival;
 680 }
 681
 682
 683 /**
 684  * mpdm_rval - Returns a value's data as a real number (double).
 685  * @v: the value
 686  *
 687  * Returns a value's data as a real number (double float). If the value
 688  * is a string, it's converted via sscanf and returned; non-string values
 689  * have all an rval of 0. The converted double is cached, so costly string
 690  * conversions are only done once. Values created with the MPDM_RVAL
 691  * flag set have its rval cached from the beginning.
 692  * [Strings]
 693  * [Value Management]
 694  */
 695 double mpdm_rval(mpdm_t v)
 696 {
 697         if (v == NULL)
 698                 return 0;
 699
 700         /* if there is no cached double, calculate it */
 701         if (!(v->flags & MPDM_RVAL)) {
 702                 double r = 0.0;
 703
 704                 /* if it's a string, calculate it; other
 705                    values will have an rval of 0.0 */
 706                 if (v->flags & MPDM_STRING) {
 707                         char tmp[128];
 708                         char *prev_locale;
 709
 710                         wcstombs(tmp, (wchar_t *) v->data, sizeof(tmp));
 711                         tmp[sizeof(tmp) - 1] = '\0';
 712
 713                         /* if the number starts with 0, it's
 714                            an octal or hexadecimal number; just
 715                            take the integer value and cast it */
 716                         if (tmp[0] == '0' && tmp[1] != '.')
 717                                 r = (double) mpdm_ival(v);
 718                         else {
 719                                 /* set locale to C for non locale-dependent
 720                                    floating point conversion */
 721                                 prev_locale = setlocale(LC_NUMERIC, "C");
 722
 723                                 /* read */
 724                                 sscanf(tmp, "%lf", &r);
 725
 726                                 /* set previous locale */
 727                                 setlocale(LC_NUMERIC, prev_locale);
 728                         }
 729                 }
 730
 731                 mpdm_set_rval(v, r);
 732         }
 733
 734         return v->rval;
 735 }
 736
 737
 738 /**
 739  * mpdm_gettext - Translates a string to the current language.
 740  * @str: the string
 741  *
 742  * Translates the @str string to the current language.
 743  *
 744  * This function can still be used even if there is no real gettext
 745  * support() by manually filling the __I18N__ hash.
 746  *
 747  * If the string is found in the current table, the translation is
 748  * returned; otherwise, the same @str value is returned.
 749  * [Strings]
 750  * [Localization]
 751  */
 752 mpdm_t mpdm_gettext(const mpdm_t str)
 753 {
 754         mpdm_t v;
 755         mpdm_t i18n = NULL;
 756
 757         /* gets the cache, if any */
 758         if ((i18n = mpdm_hget_s(mpdm_root(), L"__I18N__")) == NULL)
 759                 return str;
 760
 761         /* try first the cache */
 762         if ((v = mpdm_hget(i18n, str)) == NULL) {
 763 #ifdef CONFOPT_GETTEXT
 764                 char *s;
 765                 mpdm_t t;
 766
 767                 /* convert to mbs */
 768                 t = mpdm_ref(MPDM_2MBS(str->data));
 769
 770                 /* ask gettext for it */
 771                 s = gettext((char *) t->data);
 772
 773                 /* create new value only if it's different */
 774                 if (s != t->data) {
 775                         v = MPDM_MBS(s);
 776
 777                         /* store in the cache */
 778                         mpdm_hset(i18n, str, v);
 779                 }
 780                 else
 781                         v = str;
 782
 783                 mpdm_unref(t);
 784
 785 #else                           /* CONFOPT_GETTEXT */
 786
 787                 v = str;
 788
 789 #endif                          /* CONFOPT_GETTEXT */
 790         }
 791
 792         return v;
 793 }
 794
 795
 796 /**
 797  * mpdm_gettext_domain - Sets domain and data directory for translations.
 798  * @dom: the domain (application name)
 799  * @data: directory contaning the .mo files
 800  *
 801  * Sets the domain (application name) and translation data for translating
 802  * strings that will be returned by mpdm_gettext().@data must point to a
 803  * directory containing the .mo (compiled .po) files.
 804  *
 805  * If there is no gettext support, returns 0, or 1 otherwise.
 806  * [Strings]
 807  * [Localization]
 808  */
 809 int mpdm_gettext_domain(const mpdm_t dom, const mpdm_t data)
 810 {
 811         int ret = 0;
 812
 813 #ifdef CONFOPT_GETTEXT
 814
 815         mpdm_t dm;
 816         mpdm_t dt;
 817
 818         /* convert both to mbs,s */
 819         dm = mpdm_ref(MPDM_2MBS(dom->data));
 820         dt = mpdm_ref(MPDM_2MBS(data->data));
 821
 822         /* bind and set domain */
 823         bindtextdomain((char *) dm->data, (char *) dt->data);
 824         textdomain((char *) dm->data);
 825
 826         mpdm_hset_s(mpdm_root(), L"__I18N__", MPDM_H(0));
 827
 828         mpdm_unref(dt);
 829         mpdm_unref(dm);
 830
 831         ret = 1;
 832
 833 #endif                          /* CONFOPT_GETTEXT */
 834
 835 #ifdef CONFOPT_WIN32
 836
 837         mpdm_t v;
 838
 839         if ((v = mpdm_hget_s(mpdm_root(), L"ENV")) != NULL &&
 840                 mpdm_hget_s(v, L"LANG") == NULL) {
 841                 wchar_t *wptr = L"en";
 842
 843                 /* MS Windows crappy language constants... */
 844
 845                 switch((GetSystemDefaultLangID() & 0x00ff)) {
 846                 case 0x01: wptr = L"ar"; break; /* arabic */
 847                 case 0x02: wptr = L"bg"; break; /* bulgarian */
 848                 case 0x03: wptr = L"ca"; break; /* catalan */
 849                 case 0x04: wptr = L"zh"; break; /* chinese */
 850                 case 0x05: wptr = L"cz"; break; /* czech */
 851                 case 0x06: wptr = L"da"; break; /* danish */
 852                 case 0x07: wptr = L"de"; break; /* german */
 853                 case 0x08: wptr = L"el"; break; /* greek */
 854                 case 0x09: wptr = L"en"; break; /* english */
 855                 case 0x0a: wptr = L"es"; break; /* spanish */
 856                 case 0x0b: wptr = L"fi"; break; /* finnish */
 857                 case 0x0c: wptr = L"fr"; break; /* french */
 858                 case 0x0d: wptr = L"he"; break; /* hebrew */
 859                 case 0x0e: wptr = L"hu"; break; /* hungarian */
 860                 case 0x0f: wptr = L"is"; break; /* icelandic */
 861                 case 0x10: wptr = L"it"; break; /* italian */
 862                 case 0x11: wptr = L"jp"; break; /* japanese */
 863                 case 0x12: wptr = L"ko"; break; /* korean */
 864                 case 0x13: wptr = L"nl"; break; /* dutch */
 865                 case 0x14: wptr = L"no"; break; /* norwegian */
 866                 case 0x15: wptr = L"po"; break; /* polish */
 867                 case 0x16: wptr = L"pt"; break; /* portuguese */
 868                 case 0x17: wptr = L"rm"; break; /* romansh (switzerland) */
 869                 case 0x18: wptr = L"ro"; break; /* romanian */
 870                 case 0x19: wptr = L"ru"; break; /* russian */
 871                 case 0x1a: wptr = L"sr"; break; /* serbian */
 872                 case 0x1b: wptr = L"sk"; break; /* slovak */
 873                 case 0x1c: wptr = L"sq"; break; /* albanian */
 874                 case 0x1d: wptr = L"sv"; break; /* swedish */
 875                 }
 876
 877                 mpdm_hset_s(v, L"LANG", MPDM_S(wptr));
 878         }
 879
 880 #endif                          /* CONFOPT_WIN32 */
 881
 882         return ret;
 883 }
 884
 885
 886 #ifdef CONFOPT_WCWIDTH
 887
 888 int wcwidth(wchar_t);
 889
 890 int mpdm_wcwidth(wchar_t c)
 891 {
 892         return wcwidth(c);
 893 }
 894
 895 #else                           /* CONFOPT_WCWIDTH */
 896
 897 #include "wcwidth.c"
 898
 899 int mpdm_wcwidth(wchar_t c)
 900 {
 901         return mk_wcwidth(c);
 902 }
 903
 904 #endif                          /* CONFOPT_WCWIDTH */
 905
 906
 907 /**
 908  * mpdm_sprintf - Formats a sprintf()-like string.
 909  * @fmt: the string format
 910  * @args: an array of values
 911  *
 912  * Formats a string using the sprintf() format taking the values from @args.
 913  * [Strings]
 914  */
 915 mpdm_t mpdm_sprintf(const mpdm_t fmt, const mpdm_t args)
 916 {
 917         const wchar_t *i = fmt->data;
 918         wchar_t *o = NULL;
 919         int l = 0, n = 0;
 920         wchar_t c;
 921
 922         /* loop all characters */
 923         while ((c = *i++) != L'\0') {
 924                 int m = 0;
 925                 wchar_t *tptr = NULL;
 926                 wchar_t *wptr = NULL;
 927
 928                 if (c == L'%') {
 929                         /* format directive */
 930                         char t_fmt[128];
 931                         char tmp[1024];
 932                         mpdm_t v;
 933                         char *ptr = NULL;
 934
 935                         /* transfer the % */
 936                         t_fmt[m++] = '%';
 937
 938                         /* transform the format to mbs */
 939                         while (*i != L'\0' &&
 940                                 m < (int)(sizeof(t_fmt) - MB_CUR_MAX - 1) &&
 941                                 wcschr(L"-.0123456789", *i) != NULL)
 942                                 m += wctomb(&t_fmt[m], *i++);
 943
 944                         /* transfer the directive */
 945                         m += wctomb(&t_fmt[m], *i++);
 946
 947                         t_fmt[m] = '\0';
 948
 949                         /* by default, copies the format */
 950                         strcpy(tmp, t_fmt);
 951
 952                         /* pick next value */
 953                         v = mpdm_aget(args, n++);
 954
 955                         switch (t_fmt[m - 1]) {
 956                         case 'd':
 957                         case 'i':
 958                         case 'u':
 959                         case 'x':
 960                         case 'X':
 961                         case 'o':
 962
 963                                 /* integer value */
 964                                 snprintf(tmp, sizeof(tmp) - 1,
 965                                         t_fmt, mpdm_ival(v));
 966                                 break;
 967
 968                         case 'f':
 969
 970                                 /* float (real) value */
 971                                 snprintf(tmp, sizeof(tmp) - 1,
 972                                         t_fmt, mpdm_rval(v));
 973                                 break;
 974
 975                         case 's':
 976
 977                                 /* string value */
 978                                 ptr = mpdm_wcstombs(mpdm_string(v), NULL);
 979                                 snprintf(tmp, sizeof(tmp) - 1, t_fmt, ptr);
 980                                 free(ptr);
 981
 982                                 break;
 983
 984                         case 'c':
 985
 986                                 /* char */
 987                                 m = 1;
 988                                 wptr = &c;
 989                                 c = mpdm_ival(v);
 990                                 break;
 991
 992                         case 'b':
 993
 994                                 ptr = tmp;
 995                                 unsigned int mask;
 996                                 int p = 0;
 997
 998                                 mask = 1 << ((sizeof(int) * 8) - 1);
 999                                 while (mask) {
1000                                         if (mask & (unsigned int) mpdm_ival(v)) {
1001                                                 *ptr++ = '1';
1002                                                 p = 1;
1003                                         }
1004                                         else
1005                                         if (p)
1006                                                 *ptr++ = '0';
1007
1008                                         mask >>= 1;
1009                                 }
1010
1011                                 if (ptr == tmp)
1012                                         *ptr++ = '0';
1013
1014                                 *ptr = '\0';
1015                                 break;
1016
1017                         case '%':
1018
1019                                 /* percent sign */
1020                                 m = 1;
1021                                 wptr = &c;
1022                                 break;
1023                         }
1024
1025                         /* transfer */
1026                         if (wptr == NULL)
1027                                 wptr = tptr = mpdm_mbstowcs(tmp, &m, -1);
1028                 }
1029                 else {
1030                         /* raw character */
1031                         m = 1;
1032                         wptr = &c;
1033                 }
1034
1035                 /* transfer */
1036                 o = mpdm_poke(o, &l, wptr, m, sizeof(wchar_t));
1037
1038                 /* free the temporary buffer, if any */
1039                 if (tptr != NULL)
1040                         free(tptr);
1041         }
1042
1043         if (o == NULL)
1044                 return NULL;
1045
1046         /* null-terminate */
1047         o = mpdm_poke(o, &l, L"", 1, sizeof(wchar_t));
1048
1049         return MPDM_ENS(o, l - 1);
1050 }
1051
1052
1053 /**
1054  * mpdm_ulc - Converts a string to uppercase or lowecase.
1055  * @s: the string
1056  * @u: convert to uppercase (1) or to lowercase (0).
1057  *
1058  * Converts @s to uppercase (for @u == 1) or to lowercase (@u == 0).
1059  * [Strings]
1060  */
1061 mpdm_t mpdm_ulc(const mpdm_t s, int u)
1062 {
1063         mpdm_t r = NULL;
1064         wchar_t *optr;
1065         int i = mpdm_size(s);
1066
1067         if ((optr = malloc((i + 1) * sizeof(wchar_t))) != NULL) {
1068                 wchar_t *iptr = mpdm_string(s);
1069                 int n;
1070
1071                 for (n = 0; n < i; n++)
1072                         optr[n] = u ? towupper(iptr[n]) : towlower(iptr[n]);
1073
1074                 optr[n] = L'\0';
1075                 r = MPDM_ENS(optr, i);
1076         }
1077
1078         return r;
1079 }
1080
1081
1082 /* scanf working buffers */
1083 #define SCANF_BUF_SIZE 1024
1084 static wchar_t scanf_yset[SCANF_BUF_SIZE];
1085 static wchar_t scanf_nset[SCANF_BUF_SIZE];
1086 static wchar_t scanf_mark[SCANF_BUF_SIZE];
1087
1088 struct {
1089         wchar_t cmd;
1090         wchar_t *yset;
1091         wchar_t *nset;
1092 } scanf_sets[] = {
1093         { L's',         L"",                            L" \t" },
1094         { L'u',         L"0123456789",                  L"" },
1095         { L'd',         L"-0123456789",                 L"" },
1096         { L'i',         L"-0123456789",                 L"" },
1097         { L'f',         L"-0123456789.",                L"" },
1098         { L'x',         L"-0123456789xabcdefABCDEF",    L"" },
1099         { L'\0',        NULL,                           NULL },
1100 };
1101
1102 /**
1103  * mpdm_sscanf - Extracts data like sscanf().
1104  * @fmt: the string format
1105  * @str: the string to be parsed
1106  * @offset: the character offset to start scanning
1107  *
1108  * Extracts data from a string using a special format pattern, very
1109  * much like the scanf() series of functions in the C library. Apart
1110  * from the standard percent-sign-commands (s, u, d, i, f, x,
1111  * n, [, with optional size and * to ignore), it implements S,
1112  * to match a string of characters upto what follows in the format
1113  * string. Also, the [ set of characters can include other % formats.
1114  *
1115  * Returns an array with the extracted values. If %n is used, the
1116  * position in the scanned string is returned as the value.
1117  * [Strings]
1118  */
1119 mpdm_t mpdm_sscanf(const mpdm_t fmt, const mpdm_t str, int offset)
1120 {
1121         wchar_t *i = (wchar_t *)str->data;
1122         wchar_t *f = (wchar_t *)fmt->data;
1123         mpdm_t r;
1124
1125         i += offset;
1126         r = MPDM_A(0);
1127
1128         while (*f) {
1129                 if (*f == L'%') {
1130                         wchar_t *ptr = NULL;
1131                         int size = 0;
1132                         wchar_t cmd;
1133                         int vsize = 0;
1134                         int ignore = 0;
1135                         int msize = 0;
1136
1137                         /* empty all buffers */
1138                         scanf_yset[0] = scanf_nset[0] = scanf_mark[0] = L'\0';
1139
1140                         f++;
1141
1142                         /* an asterisk? don't return next value */
1143                         if (*f == L'*') {
1144                                 ignore = 1;
1145                                 f++;
1146                         }
1147
1148                         /* does it have a size? */
1149                         while (wcschr(L"0123456789", *f)) {
1150                                 vsize *= 10;
1151                                 vsize += *f - L'0';
1152                                 f++;
1153                         }
1154
1155                         /* if no size, set it to an arbitrary big limit */
1156                         if (!vsize)
1157                                 vsize = 0xfffffff;
1158
1159                         /* now *f should contain a command */
1160                         cmd = *f;
1161                         f++;
1162
1163                         /* is it a verbatim percent sign? */
1164                         if (cmd == L'%') {
1165                                 vsize = 1;
1166                                 ignore = 1;
1167                                 wcscpy(scanf_yset, L"%");
1168                         }
1169                         else
1170                         /* a position? */
1171                         if (cmd == L'n') {
1172                                 vsize = 0;
1173                                 ignore = 1;
1174                                 mpdm_push(r, MPDM_I(i - (wchar_t *)str->data));
1175                         }
1176                         else
1177                         /* string upto a mark */
1178                         if (cmd == L'S') {
1179                                 wchar_t *tmp = f;
1180
1181                                 /* fill the mark upto another command */
1182                                 while (*tmp) {
1183                                         if (*tmp == L'%') {
1184                                                 tmp++;
1185
1186                                                 /* is it an 'n'? ignore and go on */
1187                                                 if (*tmp == L'n') {
1188                                                         tmp++;
1189                                                         continue;
1190                                                 }
1191                                                 else
1192                                                 if (*tmp == L'%')
1193                                                         scanf_mark[msize++] = *tmp;
1194                                                 else
1195                                                         break;
1196                                         }
1197                                         else
1198                                                 scanf_mark[msize++] = *tmp;
1199
1200                                         tmp++;
1201                                 }
1202
1203                                 scanf_mark[msize] = L'\0';
1204                         }
1205                         else
1206                         /* raw set */
1207                         if (cmd == L'[') {
1208                                 int n = 0;
1209                                 wchar_t *set = scanf_yset;
1210
1211                                 /* is it an inverse set? */
1212                                 if (*f == L'^') {
1213                                         set = scanf_nset;
1214                                         f++;
1215                                 }
1216
1217                                 /* first one is a ]? add it */
1218                                 if (*f == L']') {
1219                                         set[n++] = *f;
1220                                         f++;
1221                                 }
1222
1223                                 /* now build the set */
1224                                 for (; n < SCANF_BUF_SIZE - 1 && *f && *f != L']'; f++) {
1225                                         /* is it a range? */
1226                                         if (*f == L'-') {
1227                                                 f++;
1228
1229                                                 /* start or end? hyphen itself */
1230                                                 if (n == 0 || *f == L']')
1231                                                         set[n++] = L'-';
1232                                                 else {
1233                                                         /* pick previous char */
1234                                                         wchar_t c = set[n - 1];
1235
1236                                                         /* fill */
1237                                                         while (n < SCANF_BUF_SIZE - 1 && c < *f)
1238                                                                 set[n++] = ++c;
1239                                                 }
1240                                         }
1241                                         else
1242                                         /* is it another command? */
1243                                         if (*f == L'%') {
1244                                                 int i;
1245
1246                                                 f++;
1247                                                 for (i = 0; scanf_sets[i].cmd; i++) {
1248                                                         if (*f == scanf_sets[i].cmd) {
1249                                                                 set[n] = L'\0';
1250                                                                 wcscat(set, scanf_sets[i].yset);
1251                                                                 n += wcslen(scanf_sets[i].yset);
1252                                                                 break;
1253                                                         }
1254                                                 }
1255                                         }
1256                                         else
1257                                                 set[n++] = *f;
1258                                 }
1259
1260                                 /* skip the ] */
1261                                 f++;
1262
1263                                 set[n] = L'\0';
1264                         }
1265                         else
1266                         /* a standard set? */
1267                         {
1268                                 int n;
1269
1270                                 for (n = 0; scanf_sets[n].cmd != L'\0'; n++) {
1271                                         if (cmd == scanf_sets[n].cmd) {
1272                                                 wcscpy(scanf_yset, scanf_sets[n].yset);
1273                                                 wcscpy(scanf_nset, scanf_sets[n].nset);
1274                                                 break;
1275                                         }
1276                                 }
1277                         }
1278
1279                         /* now fill the dynamic string */
1280                         while (vsize &&
1281                                !wcschr(scanf_nset, *i) &&
1282                                (scanf_yset[0] == L'\0' || wcschr(scanf_yset, *i)) &&
1283                                (msize == 0 || wcsncmp(i, scanf_mark, msize) != 0)) {
1284
1285                                 /* only add if not being ignored */
1286                                 if (!ignore)
1287                                         ptr = mpdm_poke(ptr, &size, i, 1, sizeof(wchar_t));
1288
1289                                 i++;
1290                                 vsize--;
1291                         }
1292
1293                         if (!ignore && size) {
1294                                 /* null terminate and push */
1295                                 ptr = mpdm_poke(ptr, &size, L"", 1, sizeof(wchar_t));
1296                                 mpdm_push(r, MPDM_ENS(ptr, size));
1297                         }
1298                 }
1299                 else
1300                 if (*f == L' ' || *f == L'\t') {
1301                         /* if it's a blank, sync to next non-blank */
1302                         f++;
1303
1304                         while (*i == L' ' || *i == L'\t')
1305                                 i++;
1306                 }
1307                 else
1308                 /* test for literals in the format string */
1309                 if (*i == *f) {
1310                         i++;
1311                         f++;
1312                 }
1313                 else
1314                         break;
1315         }
1316
1317         return r;
1318 }