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                 mpdm_ref(v);
 103                 dst = mpdm_pokews(dst, dsize, ptr);
 104                 mpdm_unref(v);
 105         }
 106
 107         return dst;
 108 }
 109
 110
 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 */
 114 {
 115         wchar_t *ptr = NULL;
 116         char tmp[64];           /* really MB_CUR_MAX + 1 */
 117         wchar_t wc;
 118         int n, i, c, t = 0;
 119         char *cstr;
 120
 121         /* allow NULL values for s */
 122         if (s == NULL)
 123                 s = &t;
 124
 125         /* if there is a limit, duplicate and break the string */
 126         if (l >= 0) {
 127                 cstr = strdup(str);
 128                 cstr[l] = '\0';
 129         }
 130         else
 131                 cstr = (char *) str;
 132
 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);
 138                         ptr[*s] = L'\0';
 139                 }
 140         }
 141         else {
 142                 /* zero everything */
 143                 *s = n = i = 0;
 144
 145                 for (;;) {
 146                         /* no more characters to process? */
 147                         if ((c = cstr[n + i]) == '\0' && i == 0)
 148                                 break;
 149
 150                         tmp[i++] = c;
 151                         tmp[i] = '\0';
 152
 153                         /* try to convert */
 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)
 157                                         continue;
 158                                 else {
 159                                         /* too many failing bytes; skip 1 byte */
 160                                         wc = L'?';
 161                                         i = 1;
 162                                 }
 163                         }
 164
 165                         /* skip used bytes and back again */
 166                         n += i;
 167                         i = 0;
 168
 169                         /* store new char */
 170                         if ((ptr = mpdm_poke(ptr, s, &wc, 1, sizeof(wchar_t))) == NULL)
 171                                 break;
 172                 }
 173
 174                 /* null terminate and count one less */
 175                 if (ptr != NULL) {
 176                         ptr = mpdm_poke(ptr, s, L"", 1, sizeof(wchar_t));
 177                         (*s)--;
 178                 }
 179         }
 180
 181         /* free the duplicate */
 182         if (cstr != str)
 183                 free(cstr);
 184
 185         return ptr;
 186 }
 187
 188
 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 */
 192 {
 193         char *ptr = NULL;
 194         char tmp[64];           /* really MB_CUR_MAX + 1 */
 195         int l, t = 0;
 196
 197         /* allow NULL values for s */
 198         if (s == NULL)
 199                 s = &t;
 200
 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);
 206                         ptr[*s] = '\0';
 207                 }
 208
 209                 return ptr;
 210         }
 211
 212         /* invalid encoding? convert characters one by one */
 213         *s = 0;
 214
 215         while (*str) {
 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'?');
 220                 }
 221
 222                 tmp[l] = '\0';
 223                 if ((ptr = mpdm_poke(ptr, s, tmp, l, 1)) == NULL)
 224                         break;
 225
 226                 str++;
 227         }
 228
 229         /* null terminate and count one less */
 230         if (ptr != NULL) {
 231                 ptr = mpdm_poke(ptr, s, "", 1, 1);
 232                 (*s)--;
 233         }
 234
 235         return ptr;
 236 }
 237
 238
 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 */
 241 {
 242         wchar_t *ptr;
 243
 244         /* a size of -1 means 'calculate it' */
 245         if (size == -1 && str != NULL)
 246                 size = wcslen(str);
 247
 248         /* create a copy? */
 249         if (cpy) {
 250                 /* free() on destruction */
 251                 flags |= MPDM_FREE;
 252
 253                 /* allocs */
 254                 if ((ptr = malloc((size + 1) * sizeof(wchar_t))) == NULL)
 255                         return NULL;
 256
 257                 /* if no source, reset to zeroes; otherwise, copy */
 258                 if (str == NULL)
 259                         memset(ptr, '\0', size * sizeof(wchar_t));
 260                 else {
 261                         wcsncpy(ptr, str, size);
 262                         ptr[size] = L'\0';
 263                 }
 264         }
 265         else
 266                 ptr = (wchar_t *)str;
 267
 268         /* it's a string */
 269         flags |= MPDM_STRING;
 270
 271         return mpdm_new(flags, ptr, size);
 272 }
 273
 274
 275 mpdm_t mpdm_new_mbstowcs(int flags, const char *str, int l)
 276 /* creates a new string value from an mbs */
 277 {
 278         wchar_t *ptr;
 279         int size;
 280
 281         if ((ptr = mpdm_mbstowcs(str, &size, l)) == NULL)
 282                 return NULL;
 283
 284         /* it's a string */
 285         flags |= (MPDM_STRING | MPDM_FREE);
 286
 287         return mpdm_new(flags, ptr, size);
 288 }
 289
 290
 291 mpdm_t mpdm_new_wcstombs(int flags, const wchar_t * str)
 292 /* creates a new mbs value from a wbs */
 293 {
 294         char *ptr;
 295         int size;
 296
 297         ptr = mpdm_wcstombs(str, &size);
 298
 299         flags |= MPDM_FREE;
 300
 301         /* unset the string flag; mbs,s are not 'strings' */
 302         flags &= ~MPDM_STRING;
 303
 304         return mpdm_new(flags, ptr, size);
 305 }
 306
 307
 308 mpdm_t mpdm_new_i(int ival)
 309 /* creates a new string value from an integer */
 310 {
 311         mpdm_t v;
 312         char tmp[32];
 313
 314         /* creates the visual representation */
 315         snprintf(tmp, sizeof(tmp), "%d", ival);
 316
 317         v = MPDM_MBS(tmp);
 318
 319         return mpdm_set_ival(v, ival);
 320 }
 321
 322
 323 mpdm_t mpdm_new_r(double rval)
 324 /* creates a new string value from a real number */
 325 {
 326         mpdm_t v;
 327         char tmp[128];
 328
 329         /* creates the visual representation */
 330         snprintf(tmp, sizeof(tmp), "%lf", rval);
 331
 332         /* manually strip useless zeroes */
 333         if (strchr(tmp, '.') != NULL) {
 334                 char *ptr;
 335
 336                 for (ptr = tmp + strlen(tmp) - 1; *ptr == '0'; ptr--);
 337
 338                 /* if it's over the ., strip it also */
 339                 if (*ptr != '.')
 340                         ptr++;
 341
 342                 *ptr = '\0';
 343         }
 344
 345         v = MPDM_MBS(tmp);
 346
 347         return mpdm_set_rval(v, rval);
 348 }
 349
 350
 351 /* interface */
 352
 353 /**
 354  * mpdm_string - Returns a printable representation of a value.
 355  * @v: the value
 356  *
 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.
 361  * [Strings]
 362  */
 363 wchar_t *mpdm_string(const mpdm_t v)
 364 {
 365         static wchar_t wtmp[32];
 366         char tmp[32];
 367         static wchar_t *ret;
 368
 369         /* if it's NULL, return a constant */
 370         if (v == NULL)
 371                 ret = L"[NULL]";
 372         else
 373         /* if it's a string, return it */
 374         if (v->flags & MPDM_STRING)
 375                 ret = (wchar_t *) v->data;
 376         else {
 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';
 381
 382                 ret = wtmp;
 383         }
 384
 385         return ret;
 386 }
 387
 388
 389 /**
 390  * mpdm_cmp - Compares two values.
 391  * @v1: the first value
 392  * @v2: the second value
 393  *
 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.
 399  * [Strings]
 400  */
 401 int mpdm_cmp(const mpdm_t v1, const mpdm_t v2)
 402 {
 403         int r;
 404
 405         /* same values? */
 406         if (v1 == v2)
 407                 r = 0;
 408         else
 409         /* is any value NULL? */
 410         if (v1 == NULL)
 411                 r = -1;
 412         else
 413         if (v2 == NULL)
 414                 r = 1;
 415         else
 416         /* different values, but same content? (unlikely) */
 417         if (v1->data == v2->data)
 418                 r = 0;
 419         else
 420         if (MPDM_IS_STRING(v1) && MPDM_IS_STRING(v2))
 421                 r = wcscoll((wchar_t *) v1->data, (wchar_t *) v2->data);
 422         else
 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) {
 426                         int n;
 427
 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)
 433                                         break;
 434                         }
 435                 }
 436         }
 437         else
 438                 /* in any other case, compare just pointers */
 439                 r = (int) ((char *)v1->data - (char *)v2->data);
 440
 441         return r;
 442 }
 443
 444
 445 /**
 446  * mpdm_cmp_s - Compares two values (string version).
 447  * @v1: the first value
 448  * @v2: the second value
 449  *
 450  * Compares two values. Compares both values using wcscoll()
 451  * if the first one is a string, or returns 1 otherwise.
 452  */
 453 int mpdm_cmp_s(const mpdm_t v1, const wchar_t *v2)
 454 {
 455         int r;
 456
 457     mpdm_ref(v1);
 458
 459         if (MPDM_IS_STRING(v1))
 460                 r = wcscoll((wchar_t *) v1->data, v2);
 461         else
 462                 r = (int) ((wchar_t *)v1->data - v2);
 463
 464     mpdm_unref(v1);
 465
 466         return r;
 467 }
 468
 469
 470 /**
 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
 476  *
 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
 483  * applicable).
 484  *
 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
 487  * if @del is 0).
 488  * [Strings]
 489  */
 490 mpdm_t mpdm_splice(const mpdm_t v, const mpdm_t i, int offset, int del)
 491 {
 492         mpdm_t w;
 493         mpdm_t n = NULL;
 494         mpdm_t d = NULL;
 495         int os, ns, r;
 496         int ins = 0;
 497         wchar_t *ptr;
 498
 499         mpdm_ref(v);
 500         mpdm_ref(i);
 501
 502         if (v != NULL) {
 503                 os = mpdm_size(v);
 504
 505                 /* negative offsets start from the end */
 506                 if (offset < 0)
 507                         offset = os + 1 - offset;
 508
 509                 /* never add further the end */
 510                 if (offset > os)
 511                         offset = os;
 512
 513                 /* negative del counts as 'characters left' */
 514                 if (del < 0)
 515                         del = os + 1 - offset + del;
 516
 517                 /* something to delete? */
 518                 if (del > 0) {
 519                         /* never delete further the end */
 520                         if (offset + del > os)
 521                                 del = os - offset;
 522
 523                         /* deleted string */
 524                         d = MPDM_NS(((wchar_t *) v->data) + offset, del);
 525                 }
 526                 else
 527                         del = 0;
 528
 529                 /* something to insert? */
 530                 ins = mpdm_size(i);
 531
 532                 /* new size and remainder */
 533                 ns = os + ins - del;
 534                 r = offset + del;
 535
 536                 n = MPDM_NS(NULL, ns);
 537
 538                 ptr = (wchar_t *)n->data;
 539
 540                 /* copy the beginning */
 541                 if (offset > 0) {
 542                         wcsncpy(ptr, v->data, offset);
 543                         ptr += offset;
 544                 }
 545
 546                 /* copy the text to be inserted */
 547                 if (ins > 0) {
 548                         wcsncpy(ptr, i->data, ins);
 549                         ptr += ins;
 550                 }
 551
 552                 /* copy the remaining */
 553                 os -= r;
 554                 if (os > 0) {
 555                         wcsncpy(ptr, ((wchar_t *) v->data) + r, os);
 556                         ptr += os;
 557                 }
 558
 559                 /* null terminate */
 560                 *ptr = L'\0';
 561         }
 562         else
 563                 n = i;
 564
 565         /* creates the output array */
 566         w = MPDM_A(2);
 567
 568     mpdm_ref(w);
 569         mpdm_aset(w, n, 0);
 570         mpdm_aset(w, d, 1);
 571     mpdm_unrefnd(w);
 572
 573         mpdm_unref(i);
 574         mpdm_unref(v);
 575
 576         return w;
 577 }
 578
 579
 580 /**
 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
 585  *
 586  * Returns a new string formed by the concatenation of @s1 and @s2.
 587  * [Strings]
 588  */
 589 mpdm_t mpdm_strcat_sn(const mpdm_t s1, const wchar_t *s2, int size)
 590 {
 591         wchar_t *ptr = NULL;
 592         int s = 0;
 593         mpdm_t r;
 594
 595         if (s1 == NULL && s2 == NULL)
 596                 r = NULL;
 597         else {
 598                 ptr = mpdm_pokev(ptr, &s, s1);
 599                 ptr = mpdm_pokewsn(ptr, &s, s2, size);
 600
 601                 ptr = mpdm_poke(ptr, &s, L"", 1, sizeof(wchar_t));
 602                 r = MPDM_ENS(ptr, s - 1);
 603         }
 604
 605         return r;
 606 }
 607
 608
 609 /**
 610  * mpdm_strcat_s - Concatenates two strings (string version).
 611  * @s1: the first string
 612  * @s2: the second string
 613  *
 614  * Returns a new string formed by the concatenation of @s1 and @s2.
 615  * [Strings]
 616  */
 617 mpdm_t mpdm_strcat_s(const mpdm_t s1, const wchar_t *s2)
 618 {
 619         return mpdm_strcat_sn(s1, s2, s2 ? wcslen(s2) : 0);
 620 }
 621
 622
 623 /**
 624  * mpdm_strcat - Concatenates two strings.
 625  * @s1: the first string
 626  * @s2: the second string
 627  *
 628  * Returns a new string formed by the concatenation of @s1 and @s2.
 629  * [Strings]
 630  */
 631 mpdm_t mpdm_strcat(const mpdm_t s1, const mpdm_t s2)
 632 {
 633         mpdm_t r;
 634
 635         mpdm_ref(s2);
 636         r = mpdm_strcat_s(s1, s2 ? mpdm_string(s2) : NULL);
 637         mpdm_unref(s2);
 638
 639         return r;
 640 }
 641
 642
 643 /**
 644  * mpdm_ival - Returns a value's data as an integer.
 645  * @v: the value
 646  *
 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.
 652  * [Strings]
 653  * [Value Management]
 654  */
 655 int mpdm_ival(mpdm_t v)
 656 {
 657         int i = 0;
 658
 659     mpdm_ref(v);
 660
 661         if (v != NULL) {
 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) {
 667                                 char tmp[32];
 668                                 char *fmt = "%i";
 669
 670                                 wcstombs(tmp, (wchar_t *) v->data, sizeof(tmp));
 671                                 tmp[sizeof(tmp) - 1] = '\0';
 672
 673                                 /* workaround for mingw32: as it doesn't
 674                                    correctly parse octal and hexadecimal
 675                                    numbers, they are tried as special cases */
 676                                 if (tmp[0] == '0') {
 677                                         if (tmp[1] == 'b' || tmp[1] == 'B') {
 678                                                 /* binary number */
 679                                                 fmt = NULL;
 680                                                 char *ptr = &tmp[2];
 681
 682                                                 while (*ptr == '0' || *ptr == '1') {
 683                                                         i <<= 1;
 684
 685                                                         if (*ptr == '1')
 686                                                                 i |= 1;
 687
 688                                                         ptr++;
 689                                                 }
 690                                         }
 691                                         else
 692                                         if (tmp[1] == 'x' || tmp[1] == 'X')
 693                                                 fmt = "%x";
 694                                         else
 695                                                 fmt = "%o";
 696                                 }
 697
 698                                 if (fmt != NULL)
 699                                         sscanf(tmp, fmt, &i);
 700                         }
 701
 702                         mpdm_set_ival(v, i);
 703                 }
 704
 705                 i = v->ival;
 706         }
 707
 708     mpdm_unref(v);
 709
 710         return i;
 711 }
 712
 713
 714 /**
 715  * mpdm_rval - Returns a value's data as a real number (double).
 716  * @v: the value
 717  *
 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.
 723  * [Strings]
 724  * [Value Management]
 725  */
 726 double mpdm_rval(mpdm_t v)
 727 {
 728         double r = 0.0;
 729
 730     mpdm_ref(v);
 731
 732         if (v != NULL) {
 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) {
 738                                 char tmp[128];
 739                                 char *prev_locale;
 740
 741                                 wcstombs(tmp, (wchar_t *) v->data, sizeof(tmp));
 742                                 tmp[sizeof(tmp) - 1] = '\0';
 743
 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);
 749                                 else {
 750                                         /* set locale to C for non locale-dependent
 751                                            floating point conversion */
 752                                         prev_locale = setlocale(LC_NUMERIC, "C");
 753
 754                                         /* read */
 755                                         sscanf(tmp, "%lf", &r);
 756
 757                                         /* set previous locale */
 758                                         setlocale(LC_NUMERIC, prev_locale);
 759                                 }
 760                         }
 761
 762                         mpdm_set_rval(v, r);
 763                 }
 764
 765                 r = v->rval;
 766         }
 767
 768     mpdm_unref(v);
 769
 770         return r;
 771 }
 772
 773
 774 /**
 775  * mpdm_gettext - Translates a string to the current language.
 776  * @str: the string
 777  *
 778  * Translates the @str string to the current language.
 779  *
 780  * This function can still be used even if there is no real gettext
 781  * support() by manually filling the __I18N__ hash.
 782  *
 783  * If the string is found in the current table, the translation is
 784  * returned; otherwise, the same @str value is returned.
 785  * [Strings]
 786  * [Localization]
 787  */
 788 mpdm_t mpdm_gettext(const mpdm_t str)
 789 {
 790         mpdm_t v;
 791         mpdm_t i18n = NULL;
 792
 793         /* gets the cache */
 794         if ((i18n = mpdm_hget_s(mpdm_root(), L"__I18N__")) == NULL)
 795                 i18n = mpdm_hset_s(mpdm_root(), L"__I18N__", MPDM_H(0));
 796
 797         mpdm_ref(str);
 798
 799         /* try first the cache */
 800         if ((v = mpdm_hget(i18n, str)) == NULL) {
 801 #ifdef CONFOPT_GETTEXT
 802                 char *s;
 803                 mpdm_t t;
 804
 805                 /* convert to mbs */
 806                 t = mpdm_ref(MPDM_2MBS(str->data));
 807
 808                 /* ask gettext for it */
 809                 s = gettext((char *) t->data);
 810
 811                 if (s != t->data)
 812                         v = MPDM_MBS(s);
 813                 else
 814                         v = str;
 815
 816                 mpdm_unref(t);
 817
 818 #else                           /* CONFOPT_GETTEXT */
 819
 820                 v = str;
 821
 822 #endif                          /* CONFOPT_GETTEXT */
 823
 824                 /* store in the cache */
 825                 mpdm_hset(i18n, str, v);
 826         }
 827
 828         mpdm_unref(str);
 829
 830         return v;
 831 }
 832
 833
 834 /**
 835  * mpdm_gettext_domain - Sets domain and data directory for translations.
 836  * @dom: the domain (application name)
 837  * @data: directory contaning the .mo files
 838  *
 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.
 842  *
 843  * If there is no gettext support, returns 0, or 1 otherwise.
 844  * [Strings]
 845  * [Localization]
 846  */
 847 int mpdm_gettext_domain(const mpdm_t dom, const mpdm_t data)
 848 {
 849         int ret = 0;
 850
 851         mpdm_ref(dom);
 852         mpdm_ref(data);
 853
 854 #ifdef CONFOPT_GETTEXT
 855
 856         mpdm_t dm;
 857         mpdm_t dt;
 858
 859         /* convert both to mbs,s */
 860         dm = mpdm_ref(MPDM_2MBS(dom->data));
 861         dt = mpdm_ref(MPDM_2MBS(data->data));
 862
 863         /* bind and set domain */
 864         bindtextdomain((char *) dm->data, (char *) dt->data);
 865         textdomain((char *) dm->data);
 866
 867         mpdm_hset_s(mpdm_root(), L"__I18N__", MPDM_H(0));
 868
 869         mpdm_unref(dt);
 870         mpdm_unref(dm);
 871
 872         ret = 1;
 873
 874 #endif                          /* CONFOPT_GETTEXT */
 875
 876 #ifdef CONFOPT_WIN32
 877
 878         mpdm_t v;
 879
 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";
 883
 884                 /* MS Windows crappy language constants... */
 885
 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 */
 916                 }
 917
 918                 mpdm_hset_s(v, L"LANG", MPDM_S(wptr));
 919         }
 920
 921 #endif                          /* CONFOPT_WIN32 */
 922
 923         mpdm_unref(data);
 924         mpdm_unref(dom);
 925
 926         return ret;
 927 }
 928
 929
 930 #ifdef CONFOPT_WCWIDTH
 931
 932 int wcwidth(wchar_t);
 933
 934 int mpdm_wcwidth(wchar_t c)
 935 {
 936         return wcwidth(c);
 937 }
 938
 939 #else                           /* CONFOPT_WCWIDTH */
 940
 941 #include "wcwidth.c"
 942
 943 int mpdm_wcwidth(wchar_t c)
 944 {
 945         return mk_wcwidth(c);
 946 }
 947
 948 #endif                          /* CONFOPT_WCWIDTH */
 949
 950
 951 /**
 952  * mpdm_sprintf - Formats a sprintf()-like string.
 953  * @fmt: the string format
 954  * @args: an array of values
 955  *
 956  * Formats a string using the sprintf() format taking the values from @args.
 957  * [Strings]
 958  */
 959 mpdm_t mpdm_sprintf(const mpdm_t fmt, const mpdm_t args)
 960 {
 961         const wchar_t *i = fmt->data;
 962         wchar_t *o = NULL;
 963         int l = 0, n = 0;
 964         wchar_t c;
 965
 966         mpdm_ref(fmt);
 967         mpdm_ref(args);
 968
 969         /* loop all characters */
 970         while ((c = *i++) != L'\0') {
 971                 int m = 0;
 972                 wchar_t *tptr = NULL;
 973                 wchar_t *wptr = NULL;
 974
 975                 if (c == L'%') {
 976                         /* format directive */
 977                         char t_fmt[128];
 978                         char tmp[1024];
 979                         mpdm_t v;
 980                         char *ptr = NULL;
 981
 982                         /* transfer the % */
 983                         t_fmt[m++] = '%';
 984
 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++);
 990
 991                         /* transfer the directive */
 992                         m += wctomb(&t_fmt[m], *i++);
 993
 994                         t_fmt[m] = '\0';
 995
 996                         /* by default, copies the format */
 997                         strcpy(tmp, t_fmt);
 998
 999                         /* pick next value */
1000                         v = mpdm_aget(args, n++);
1001
1002                         switch (t_fmt[m - 1]) {
1003                         case 'd':
1004                         case 'i':
1005                         case 'u':
1006                         case 'x':
1007                         case 'X':
1008                         case 'o':
1009
1010                                 /* integer value */
1011                                 snprintf(tmp, sizeof(tmp) - 1,
1012                                         t_fmt, mpdm_ival(v));
1013                                 break;
1014
1015                         case 'f':
1016
1017                                 /* float (real) value */
1018                                 snprintf(tmp, sizeof(tmp) - 1,
1019                                         t_fmt, mpdm_rval(v));
1020                                 break;
1021
1022                         case 's':
1023
1024                                 /* string value */
1025                                 ptr = mpdm_wcstombs(mpdm_string(v), NULL);
1026                                 snprintf(tmp, sizeof(tmp) - 1, t_fmt, ptr);
1027                                 free(ptr);
1028
1029                                 break;
1030
1031                         case 'c':
1032
1033                                 /* char */
1034                                 m = 1;
1035                                 wptr = &c;
1036                                 c = mpdm_ival(v);
1037                                 break;
1038
1039                         case 'b':
1040
1041                                 ptr = tmp;
1042                                 unsigned int mask;
1043                                 int p = 0;
1044
1045                                 mask = 1 << ((sizeof(int) * 8) - 1);
1046                                 while (mask) {
1047                                         if (mask & (unsigned int) mpdm_ival(v)) {
1048                                                 *ptr++ = '1';
1049                                                 p = 1;
1050                                         }
1051                                         else
1052                                         if (p)
1053                                                 *ptr++ = '0';
1054
1055                                         mask >>= 1;
1056                                 }
1057
1058                                 if (ptr == tmp)
1059                                         *ptr++ = '0';
1060
1061                                 *ptr = '\0';
1062                                 break;
1063
1064                         case '%':
1065
1066                                 /* percent sign */
1067                                 m = 1;
1068                                 wptr = &c;
1069                                 break;
1070                         }
1071
1072                         /* transfer */
1073                         if (wptr == NULL)
1074                                 wptr = tptr = mpdm_mbstowcs(tmp, &m, -1);
1075                 }
1076                 else {
1077                         /* raw character */
1078                         m = 1;
1079                         wptr = &c;
1080                 }
1081
1082                 /* transfer */
1083                 o = mpdm_poke(o, &l, wptr, m, sizeof(wchar_t));
1084
1085                 /* free the temporary buffer, if any */
1086                 if (tptr != NULL)
1087                         free(tptr);
1088         }
1089
1090         if (o == NULL)
1091                 return NULL;
1092
1093         /* null-terminate */
1094         o = mpdm_poke(o, &l, L"", 1, sizeof(wchar_t));
1095
1096         mpdm_unref(args);
1097         mpdm_unref(fmt);
1098
1099         return MPDM_ENS(o, l - 1);
1100 }
1101
1102
1103 /**
1104  * mpdm_ulc - Converts a string to uppercase or lowecase.
1105  * @s: the string
1106  * @u: convert to uppercase (1) or to lowercase (0).
1107  *
1108  * Converts @s to uppercase (for @u == 1) or to lowercase (@u == 0).
1109  * [Strings]
1110  */
1111 mpdm_t mpdm_ulc(const mpdm_t s, int u)
1112 {
1113         mpdm_t r = NULL;
1114         wchar_t *optr;
1115         int i;
1116
1117         mpdm_ref(s);
1118
1119         i = mpdm_size(s);
1120
1121         if ((optr = malloc((i + 1) * sizeof(wchar_t))) != NULL) {
1122                 wchar_t *iptr = mpdm_string(s);
1123                 int n;
1124
1125                 for (n = 0; n < i; n++)
1126                         optr[n] = u ? towupper(iptr[n]) : towlower(iptr[n]);
1127
1128                 optr[n] = L'\0';
1129                 r = MPDM_ENS(optr, i);
1130         }
1131
1132         mpdm_unref(s);
1133
1134         return r;
1135 }
1136
1137
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];
1143
1144 struct {
1145         wchar_t cmd;
1146         wchar_t *yset;
1147         wchar_t *nset;
1148 } scanf_sets[] = {
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 },
1156 };
1157
1158 /**
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
1163  *
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.
1170  *
1171  * Returns an array with the extracted values. If %n is used, the
1172  * position in the scanned string is returned as the value.
1173  * [Strings]
1174  */
1175 mpdm_t mpdm_sscanf(const mpdm_t fmt, const mpdm_t str, int offset)
1176 {
1177         wchar_t *i = (wchar_t *)str->data;
1178         wchar_t *f = (wchar_t *)fmt->data;
1179         mpdm_t r;
1180
1181         mpdm_ref(fmt);
1182         mpdm_ref(str);
1183
1184         i += offset;
1185         r = MPDM_A(0);
1186     mpdm_ref(r);
1187
1188         while (*f) {
1189                 if (*f == L'%') {
1190                         wchar_t *ptr = NULL;
1191                         int size = 0;
1192                         wchar_t cmd;
1193                         int vsize = 0;
1194                         int ignore = 0;
1195                         int msize = 0;
1196
1197                         /* empty all buffers */
1198                         scanf_yset[0] = scanf_nset[0] = scanf_mark[0] = L'\0';
1199
1200                         f++;
1201
1202                         /* an asterisk? don't return next value */
1203                         if (*f == L'*') {
1204                                 ignore = 1;
1205                                 f++;
1206                         }
1207
1208                         /* does it have a size? */
1209                         while (wcschr(L"0123456789", *f)) {
1210                                 vsize *= 10;
1211                                 vsize += *f - L'0';
1212                                 f++;
1213                         }
1214
1215                         /* if no size, set it to an arbitrary big limit */
1216                         if (!vsize)
1217                                 vsize = 0xfffffff;
1218
1219                         /* now *f should contain a command */
1220                         cmd = *f;
1221                         f++;
1222
1223                         /* is it a verbatim percent sign? */
1224                         if (cmd == L'%') {
1225                                 vsize = 1;
1226                                 ignore = 1;
1227                                 wcscpy(scanf_yset, L"%");
1228                         }
1229                         else
1230                         /* a position? */
1231                         if (cmd == L'n') {
1232                                 vsize = 0;
1233                                 ignore = 1;
1234                                 mpdm_push(r, MPDM_I(i - (wchar_t *)str->data));
1235                         }
1236                         else
1237                         /* string upto a mark */
1238                         if (cmd == L'S') {
1239                                 wchar_t *tmp = f;
1240
1241                                 /* fill the mark upto another command */
1242                                 while (*tmp) {
1243                                         if (*tmp == L'%') {
1244                                                 tmp++;
1245
1246                                                 /* is it an 'n'? ignore and go on */
1247                                                 if (*tmp == L'n') {
1248                                                         tmp++;
1249                                                         continue;
1250                                                 }
1251                                                 else
1252                                                 if (*tmp == L'%')
1253                                                         scanf_mark[msize++] = *tmp;
1254                                                 else
1255                                                         break;
1256                                         }
1257                                         else
1258                                                 scanf_mark[msize++] = *tmp;
1259
1260                                         tmp++;
1261                                 }
1262
1263                                 scanf_mark[msize] = L'\0';
1264                         }
1265                         else
1266                         /* raw set */
1267                         if (cmd == L'[') {
1268                                 int n = 0;
1269                                 wchar_t *set = scanf_yset;
1270
1271                                 /* is it an inverse set? */
1272                                 if (*f == L'^') {
1273                                         set = scanf_nset;
1274                                         f++;
1275                                 }
1276
1277                                 /* first one is a ]? add it */
1278                                 if (*f == L']') {
1279                                         set[n++] = *f;
1280                                         f++;
1281                                 }
1282
1283                                 /* now build the set */
1284                                 for (; n < SCANF_BUF_SIZE - 1 && *f && *f != L']'; f++) {
1285                                         /* is it a range? */
1286                                         if (*f == L'-') {
1287                                                 f++;
1288
1289                                                 /* start or end? hyphen itself */
1290                                                 if (n == 0 || *f == L']')
1291                                                         set[n++] = L'-';
1292                                                 else {
1293                                                         /* pick previous char */
1294                                                         wchar_t c = set[n - 1];
1295
1296                                                         /* fill */
1297                                                         while (n < SCANF_BUF_SIZE - 1 && c < *f)
1298                                                                 set[n++] = ++c;
1299                                                 }
1300                                         }
1301                                         else
1302                                         /* is it another command? */
1303                                         if (*f == L'%') {
1304                                                 int i;
1305
1306                                                 f++;
1307                                                 for (i = 0; scanf_sets[i].cmd; i++) {
1308                                                         if (*f == scanf_sets[i].cmd) {
1309                                                                 set[n] = L'\0';
1310                                                                 wcscat(set, scanf_sets[i].yset);
1311                                                                 n += wcslen(scanf_sets[i].yset);
1312                                                                 break;
1313                                                         }
1314                                                 }
1315                                         }
1316                                         else
1317                                                 set[n++] = *f;
1318                                 }
1319
1320                                 /* skip the ] */
1321                                 f++;
1322
1323                                 set[n] = L'\0';
1324                         }
1325                         else
1326                         /* a standard set? */
1327                         {
1328                                 int n;
1329
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);
1334                                                 break;
1335                                         }
1336                                 }
1337                         }
1338
1339                         /* now fill the dynamic string */
1340                         while (vsize &&
1341                                !wcschr(scanf_nset, *i) &&
1342                                (scanf_yset[0] == L'\0' || wcschr(scanf_yset, *i)) &&
1343                                (msize == 0 || wcsncmp(i, scanf_mark, msize) != 0)) {
1344
1345                                 /* only add if not being ignored */
1346                                 if (!ignore)
1347                                         ptr = mpdm_poke(ptr, &size, i, 1, sizeof(wchar_t));
1348
1349                                 i++;
1350                                 vsize--;
1351                         }
1352
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));
1357                         }
1358                 }
1359                 else
1360                 if (*f == L' ' || *f == L'\t') {
1361                         /* if it's a blank, sync to next non-blank */
1362                         f++;
1363
1364                         while (*i == L' ' || *i == L'\t')
1365                                 i++;
1366                 }
1367                 else
1368                 /* test for literals in the format string */
1369                 if (*i == *f) {
1370                         i++;
1371                         f++;
1372                 }
1373                 else
1374                         break;
1375         }
1376
1377         mpdm_unref(str);
1378         mpdm_unref(fmt);
1379
1380     mpdm_unrefnd(r);
1381
1382         return r;
1383 }