mpdm_s.c

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