src/icu_I18N.c

   1 /* $Id: icu_I18N.c,v 1.6 2007-05-07 12:18:34 marc Exp $
   2    Copyright (c) 2006-2007, Index Data.
   3
   4 This file is part of Pazpar2.
   5
   6 Pazpar2 is free software; you can redistribute it and/or modify it under
   7 the terms of the GNU General Public License as published by the Free
   8 Software Foundation; either version 2, or (at your option) any later
   9 version.
  10
  11 Pazpar2 is distributed in the hope that it will be useful, but WITHOUT ANY
  12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14 for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with Pazpar2; see the file LICENSE.  If not, write to the
  18 Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  19 02111-1307, USA.
  20  */
  21
  22 #if HAVE_CONFIG_H
  23 #include "cconfig.h"
  24 #endif
  25
  26 #define USE_TIMING 0
  27 #if USE_TIMING
  28 #include <yaz/timing.h>
  29 #endif
  30
  31
  32 #ifdef HAVE_ICU
  33 #include "icu_I18N.h"
  34
  35 #include <yaz/log.h>
  36
  37 #include <string.h>
  38 #include <stdlib.h>
  39 #include <stdio.h>
  40
  41 #include <unicode/ustring.h>  /* some more string fcns*/
  42 #include <unicode/uchar.h>    /* char names           */
  43
  44
  45 //#include <unicode/ustdio.h>
  46 //#include <unicode/utypes.h>   /* Basic ICU data types */
  47 #include <unicode/ucol.h>
  48 //#include <unicode/ucnv.h>     /* C   Converter API    */
  49 //#include <unicode/uloc.h>
  50 //#include <unicode/ubrk.h>
  51 /* #include <unicode/unistr.h> */
  52
  53
  54
  55
  56 int icu_check_status (UErrorCode status)
  57 {
  58     //if(U_FAILURE(status))
  59     if(!U_SUCCESS(status))
  60       yaz_log(YLOG_WARN,
  61               "ICU: %d %s\n", status, u_errorName(status));
  62   return status;
  63 }
  64
  65
  66
  67 struct icu_buf_utf16 * icu_buf_utf16_create(size_t capacity)
  68 {
  69   struct icu_buf_utf16 * buf16
  70     = (struct icu_buf_utf16 *) malloc(sizeof(struct icu_buf_utf16));
  71
  72   buf16->utf16 = 0;
  73   buf16->utf16_len = 0;
  74   buf16->utf16_cap = 0;
  75
  76   if (capacity > 0){
  77     buf16->utf16 = (UChar *) malloc(sizeof(UChar) * capacity);
  78     buf16->utf16[0] = (UChar) 0;
  79     buf16->utf16_cap = capacity;
  80   }
  81   return buf16;
  82 };
  83
  84
  85 struct icu_buf_utf16 * icu_buf_utf16_resize(struct icu_buf_utf16 * buf16,
  86                                             size_t capacity)
  87 {
  88   if (buf16){
  89     if (capacity >  0){
  90       if (0 == buf16->utf16)
  91         buf16->utf16 = (UChar *) malloc(sizeof(UChar) * capacity);
  92       else
  93         buf16->utf16
  94           = (UChar *) realloc(buf16->utf16, sizeof(UChar) * capacity);
  95       buf16->utf16[0] = (UChar) 0;
  96       buf16->utf16_len = 0;
  97       buf16->utf16_cap = capacity;
  98     }
  99     else {
 100       if (buf16->utf16)
 101         free(buf16->utf16);
 102       buf16->utf16 = 0;
 103       buf16->utf16_len = 0;
 104       buf16->utf16_cap = 0;
 105     }
 106   }
 107
 108   return buf16;
 109 };
 110
 111
 112 void icu_buf_utf16_destroy(struct icu_buf_utf16 * buf16)
 113 {
 114   if (buf16){
 115     if (buf16->utf16)
 116       free(buf16->utf16);
 117     free(buf16);
 118   }
 119 };
 120
 121
 122
 123
 124
 125
 126 struct icu_buf_utf8 * icu_buf_utf8_create(size_t capacity)
 127 {
 128   struct icu_buf_utf8 * buf8
 129     = (struct icu_buf_utf8 *) malloc(sizeof(struct icu_buf_utf8));
 130
 131   buf8->utf8 = 0;
 132   buf8->utf8_len = 0;
 133   buf8->utf8_cap = 0;
 134
 135   if (capacity > 0){
 136     buf8->utf8 = (uint8_t *) malloc(sizeof(uint8_t) * capacity);
 137     buf8->utf8[0] = (uint8_t) 0;
 138     buf8->utf8_cap = capacity;
 139   }
 140   return buf8;
 141 };
 142
 143
 144
 145 struct icu_buf_utf8 * icu_buf_utf8_resize(struct icu_buf_utf8 * buf8,
 146                                           size_t capacity)
 147 {
 148   if (buf8){
 149     if (capacity >  0){
 150       if (0 == buf8->utf8)
 151         buf8->utf8 = (uint8_t *) malloc(sizeof(uint8_t) * capacity);
 152       else
 153         buf8->utf8
 154           = (uint8_t *) realloc(buf8->utf8, sizeof(uint8_t) * capacity);
 155       buf8->utf8[0] = (uint8_t) 0;
 156       buf8->utf8_len = 0;
 157       buf8->utf8_cap = capacity;
 158     }
 159     else {
 160       if (buf8->utf8)
 161         free(buf8->utf8);
 162       buf8->utf8 = 0;
 163       buf8->utf8_len = 0;
 164       buf8->utf8_cap = 0;
 165     }
 166   }
 167
 168   return buf8;
 169 };
 170
 171
 172
 173 void icu_buf_utf8_destroy(struct icu_buf_utf8 * buf8)
 174 {
 175   if (buf8){
 176     if (buf8->utf8)
 177       free(buf8->utf8);
 178     free(buf8);
 179   }
 180 };
 181
 182
 183
 184 UErrorCode icu_utf16_from_utf8(struct icu_buf_utf16 * dest16,
 185                                struct icu_buf_utf8 * src8,
 186                                UErrorCode * status)
 187 {
 188   int32_t utf16_len = 0;
 189
 190   u_strFromUTF8(dest16->utf16, dest16->utf16_cap,
 191                 &utf16_len,
 192                 (const char *) src8->utf8, src8->utf8_len, status);
 193
 194   // check for buffer overflow, resize and retry
 195   if (*status == U_BUFFER_OVERFLOW_ERROR
 196       //|| dest16->utf16_len > dest16->utf16_cap
 197       ){
 198     icu_buf_utf16_resize(dest16, utf16_len * 2);
 199     *status = U_ZERO_ERROR;
 200     u_strFromUTF8(dest16->utf16, dest16->utf16_cap,
 201                   &utf16_len,
 202                   (const char *) src8->utf8, src8->utf8_len, status);
 203   }
 204
 205     //if (*status != U_BUFFER_OVERFLOW_ERROR
 206   if (U_SUCCESS(*status)
 207       && utf16_len < dest16->utf16_cap)
 208     dest16->utf16_len = utf16_len;
 209   else {
 210     dest16->utf16[0] = (UChar) 0;
 211     dest16->utf16_len = 0;
 212   }
 213
 214   return *status;
 215 };
 216
 217
 218
 219 UErrorCode icu_utf16_from_utf8_cstr(struct icu_buf_utf16 * dest16,
 220                                     const char * src8cstr,
 221                                     UErrorCode * status)
 222 {
 223   size_t src8cstr_len = 0;
 224   int32_t utf16_len = 0;
 225
 226   src8cstr_len = strlen(src8cstr);
 227
 228   u_strFromUTF8(dest16->utf16, dest16->utf16_cap,
 229                 &utf16_len,
 230                 src8cstr, src8cstr_len, status);
 231
 232   // check for buffer overflow, resize and retry
 233   if (*status == U_BUFFER_OVERFLOW_ERROR
 234       //|| dest16->utf16_len > dest16->utf16_cap
 235       ){
 236     icu_buf_utf16_resize(dest16, utf16_len * 2);
 237     *status = U_ZERO_ERROR;
 238     u_strFromUTF8(dest16->utf16, dest16->utf16_cap,
 239                   &utf16_len,
 240                   src8cstr, src8cstr_len, status);
 241   }
 242
 243   //  if (*status != U_BUFFER_OVERFLOW_ERROR
 244   if (U_SUCCESS(*status)
 245       && utf16_len < dest16->utf16_cap)
 246     dest16->utf16_len = utf16_len;
 247   else {
 248     dest16->utf16[0] = (UChar) 0;
 249     dest16->utf16_len = 0;
 250   }
 251
 252   return *status;
 253 };
 254
 255
 256
 257
 258 UErrorCode icu_utf16_to_utf8(struct icu_buf_utf8 * dest8,
 259                                struct icu_buf_utf16 * src16,
 260                                UErrorCode * status)
 261 {
 262   int32_t utf8_len = 0;
 263
 264   u_strToUTF8((char *) dest8->utf8, dest8->utf8_cap,
 265                 &utf8_len,
 266                  src16->utf16, src16->utf16_len, status);
 267
 268   // check for buffer overflow, resize and retry
 269   if (*status == U_BUFFER_OVERFLOW_ERROR
 270       //|| dest8->utf8_len > dest8->utf8_cap
 271       ){
 272     icu_buf_utf8_resize(dest8, utf8_len * 2);
 273     *status = U_ZERO_ERROR;
 274     u_strToUTF8((char *) dest8->utf8, dest8->utf8_cap,
 275                 &utf8_len,
 276                 src16->utf16, src16->utf16_len, status);
 277
 278   }
 279
 280   //if (*status != U_BUFFER_OVERFLOW_ERROR
 281   if (U_SUCCESS(*status)
 282       && utf8_len < dest8->utf8_cap)
 283       dest8->utf8_len = utf8_len;
 284   else {
 285       dest8->utf8[0] = (uint8_t) 0;
 286       dest8->utf8_len = 0;
 287   }
 288
 289   return *status;
 290 };
 291
 292
 293
 294
 295 UErrorCode icu_sortkey8_from_utf16(UCollator *coll,
 296                                    struct icu_buf_utf8 * dest8,
 297                                    struct icu_buf_utf16 * src16,
 298                                    UErrorCode * status)
 299 {
 300
 301   int32_t sortkey_len = 0;
 302
 303   sortkey_len = ucol_getSortKey(coll, src16->utf16, src16->utf16_len,
 304                                 dest8->utf8, dest8->utf8_cap);
 305
 306   // check for buffer overflow, resize and retry
 307   if (sortkey_len > dest8->utf8_cap) {
 308     icu_buf_utf8_resize(dest8, sortkey_len * 2);
 309     sortkey_len = ucol_getSortKey(coll, src16->utf16, src16->utf16_len,
 310                                   dest8->utf8, dest8->utf8_cap);
 311   }
 312
 313   if (U_SUCCESS(*status)
 314       && sortkey_len > 0)
 315     dest8->utf8_len = sortkey_len;
 316   else {
 317     dest8->utf8[0] = (UChar) 0;
 318     dest8->utf8_len = 0;
 319   }
 320
 321   return *status;
 322 };
 323
 324
 325
 326
 327
 328 /// CRAP FOLLOWING HERE ...
 329
 330 #if 0
 331
 332 // forward declarations for helper functions
 333
 334 int icu_check_status (UErrorCode status);
 335
 336 UChar* icu_utf16_from_utf8(UChar *utf16,
 337                            int32_t utf16_cap,
 338                            int32_t *utf16_len,
 339                            const char *utf8);
 340
 341 UChar* icu_utf16_from_utf8n(UChar *utf16,
 342                             int32_t utf16_cap,
 343                             int32_t *utf16_len,
 344                             const char *utf8,
 345                             size_t utf8_len);
 346
 347
 348 char* icu_utf16_to_utf8(char *utf8,
 349                         size_t utf8_cap,
 350                         size_t *utf8_len,
 351                         const UChar *utf16,
 352                         int32_t utf16_len);
 353
 354
 355 int32_t icu_utf16_casemap(UChar *dest16, int32_t dest16_cap,
 356                           const UChar *src16, int32_t src16_len,
 357                           const char *locale, char action);
 358
 359
 360 // source code of all functions
 361
 362 int icu_check_status (UErrorCode status)
 363 {
 364     //if(U_FAILURE(status))
 365     if(!U_SUCCESS(status))
 366       yaz_log(YLOG_WARN,
 367               "ICU: %d %s\n", status, u_errorName(status));
 368   return status;
 369 }
 370
 371
 372 UChar* icu_utf16_from_utf8(UChar *utf16,
 373                            int32_t utf16_cap,
 374                            int32_t *utf16_len,
 375                            const char *utf8)
 376 {
 377     size_t utf8_len = strlen(utf8);
 378     return icu_utf16_from_utf8n(utf16, utf16_cap, utf16_len,
 379                                   utf8, utf8_len);
 380 }
 381
 382
 383 UChar* icu_utf16_from_utf8n(UChar *utf16,
 384                             int32_t utf16_cap,
 385                             int32_t *utf16_len,
 386                             const char *utf8,
 387                             size_t utf8_len)
 388 {
 389     UErrorCode status = U_ZERO_ERROR;
 390     u_strFromUTF8(utf16, utf16_cap, utf16_len, utf8, (int32_t) utf8_len,
 391                   &status);
 392     if (U_ZERO_ERROR != icu_check_status(status))
 393         return 0;
 394     else
 395         return utf16;
 396 }
 397
 398
 399 char* icu_utf16_to_utf8(char *utf8,
 400                         size_t utf8_cap,
 401                         size_t *utf8_len,
 402                         const UChar *utf16,
 403                         int32_t utf16_len)
 404 {
 405     UErrorCode status = U_ZERO_ERROR;
 406     u_strToUTF8(utf8, (int32_t) utf8_cap, (int32_t *)utf8_len,
 407                 utf16, utf16_len, &status);
 408     if (U_ZERO_ERROR != icu_check_status(status))
 409         return 0;
 410     else
 411         return utf8;
 412 }
 413
 414
 415 int32_t icu_utf16_casemap(UChar *dest16, int32_t dest16_cap,
 416                           const UChar *src16, int32_t src16_len,
 417                           const char *locale, char action)
 418 {
 419     UErrorCode status = U_ZERO_ERROR;
 420     int32_t dest16_len = 0;
 421
 422     switch(action) {
 423     case 'l':
 424         dest16_len = u_strToLower(dest16, dest16_cap, src16, src16_len,
 425                                   locale, &status);
 426         break;
 427     case 'u':
 428         dest16_len = u_strToUpper(dest16, dest16_cap, src16, src16_len,
 429                                   locale, &status);
 430         break;
 431     case 't':
 432         dest16_len = u_strToTitle(dest16, dest16_cap, src16, src16_len,
 433                                   0, locale, &status);
 434         break;
 435     case 'f':
 436         dest16_len = u_strFoldCase(dest16, dest16_cap, src16, src16_len,
 437                                    U_FOLD_CASE_DEFAULT, &status);
 438         break;
 439
 440     default:
 441         return 0;
 442         break;
 443     }
 444
 445     if (U_ZERO_ERROR != icu_check_status(status))
 446         return 0;
 447     else
 448         return dest16_len;
 449 }
 450
 451
 452 char * icu_casemap(NMEM nmem, char *buf, size_t buf_cap,
 453                    size_t *dest8_len,  const char *src8,
 454                    const char *locale, char action)
 455 {
 456     size_t src8_len = strlen(src8);
 457     int32_t buf_len = 0;
 458     char * dest8 = 0;
 459
 460     if (dest8_len)
 461         *dest8_len = 0;
 462
 463     if (!buf || !(buf_cap > 0) || !src8_len)
 464         return 0;
 465
 466     // converting buf to utf16
 467     buf = (char *)icu_utf16_from_utf8n((UChar *) buf,
 468                                        (int32_t) buf_cap, &buf_len,
 469                                        src8, src8_len);
 470
 471     // case mapping
 472     buf_len = (size_t) icu_utf16_casemap((UChar *)buf, (int32_t) buf_cap,
 473                                          (const UChar *)buf, (int32_t) buf_len,
 474                                          locale, action);
 475
 476     // converting buf to utf8
 477     buf = icu_utf16_to_utf8(buf, buf_cap, (size_t *) &buf_len,
 478                             (const UChar *) buf, (int32_t) buf_len);
 479
 480
 481     // copying out to nmem
 482     buf[buf_len] = '\0';
 483
 484     if(dest8_len)
 485         *dest8_len = buf_len;
 486
 487     dest8 =  nmem_strdup(nmem, buf);
 488     return dest8;
 489 }
 490
 491
 492 struct icu_termmap * icu_termmap_create(NMEM nmem)
 493 {
 494     struct icu_termmap *itmp =  nmem_malloc(nmem, sizeof(*itmp));
 495     itmp->sort_key = 0;
 496     itmp->norm_term = 0;
 497     itmp->disp_term = 0;
 498     return itmp;
 499 };
 500
 501 int icu_termmap_cmp(const void *vp1, const void *vp2)
 502 {
 503     struct icu_termmap *itmp1 = *(struct icu_termmap **) vp1;
 504     struct icu_termmap *itmp2 = *(struct icu_termmap **) vp2;
 505
 506     return strcmp(itmp1->sort_key, itmp2->sort_key);
 507 }
 508
 509
 510
 511 char * icu_sortmap(NMEM nmem, char *buf, size_t buf_cap,
 512                    size_t *dest8_len,  const char *src8,
 513                    const char *locale)
 514 {
 515     size_t src8_len = strlen(src8);
 516     int32_t buf_len = 0;
 517     char * dest8 = 0;
 518
 519     if (dest8_len)
 520         *dest8_len = 0;
 521
 522     if (!buf || !(buf_cap > 0) || !src8_len)
 523         return 0;
 524
 525     // converting buf to utf16
 526     buf = (char *)icu_utf16_from_utf8n((UChar *) buf,
 527                                        (int32_t) buf_cap, &buf_len,
 528                                        src8, src8_len);
 529
 530     // sort mapping
 531     //buf_len = (size_t) icu_utf16_casemap((UChar *)buf, (int32_t) buf_cap,
 532     //                                     (const UChar *)buf, (int32_t) buf_len,
 533     //                                      locale, action);
 534
 535
 536     {
 537         UErrorCode status = U_ZERO_ERROR;
 538
 539         UCollator * coll = ucol_open (locale, &status);
 540         if (U_ZERO_ERROR != icu_check_status(status))
 541             buf_len = 0;
 542
 543         ucol_getSortKey(coll, (const UChar *) buf, (int32_t) buf_len,
 544                         (uint8_t *) buf, (int32_t) buf_cap);
 545
 546         ucol_close(coll);
 547     }
 548
 549
 550     // copying out to nmem
 551     buf[buf_len] = '\0';
 552
 553     if(dest8_len)
 554         *dest8_len = buf_len;
 555
 556     dest8 =  nmem_strdup(nmem, buf);
 557     return dest8;
 558 }
 559
 560 #endif
 561
 562
 563
 564 #endif // HAVE_ICU
 565
 566
 567
 568
 569 /*
 570  * Local variables:
 571  * c-basic-offset: 4
 572  * indent-tabs-mode: nil
 573  * End:
 574  * vim: shiftwidth=4 tabstop=8 expandtab
 575  */