parted/strlist.c

   1 /*
   2     parted - a frontend to libparted
   3     Copyright (C) 1999, 2000, 2001, 2007 Free Software Foundation, Inc.
   4
   5     This program is free software; you can redistribute it and/or modify
   6     it under the terms of the GNU General Public License as published by
   7     the Free Software Foundation; either version 3 of the License, or
   8     (at your option) any later version.
   9
  10     This program is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13     GNU General Public License for more details.
  14
  15     You should have received a copy of the GNU General Public License
  16     along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17 */
  18
  19 #include <config.h>
  20
  21 #include <parted/debug.h>
  22
  23 #include <ctype.h>
  24 #include <errno.h>
  25 #include <stdarg.h>
  26 #include <stdio.h>
  27 #include <stdlib.h>
  28 #include <string.h>
  29 #include <limits.h>
  30 #include "xalloc.h"
  31
  32 #ifdef ENABLE_NLS
  33
  34 #undef __USE_GNU
  35 #define __USE_GNU
  36
  37 #include <wchar.h>
  38 #include <wctype.h>
  39
  40 #else /* ENABLE_NLS */
  41
  42 #ifdef wchar_t
  43 #undef wchar_t
  44 #endif
  45
  46 #define wchar_t char
  47
  48 #endif /* !ENABLE_NLS */
  49
  50 #include "strlist.h"
  51
  52 #define MIN(a,b)        ( (a<b)?  a : b )
  53
  54 int
  55 wchar_strlen (const wchar_t* str)
  56 {
  57 #ifdef ENABLE_NLS
  58         return wcslen (str);
  59 #else
  60         return strlen (str);
  61 #endif
  62 }
  63
  64 wchar_t*
  65 wchar_strchr (const wchar_t* str, char ch)
  66 {
  67 #ifdef ENABLE_NLS
  68         return wcschr (str, ch);
  69 #else
  70         return strchr (str, ch);
  71 #endif
  72 }
  73
  74 int
  75 wchar_strcasecmp (const wchar_t* a, const wchar_t* b)
  76 {
  77 #ifdef ENABLE_NLS
  78         return wcscasecmp (a, b);
  79 #else
  80         return strcasecmp (a, b);
  81 #endif
  82 }
  83
  84 int
  85 wchar_strncasecmp (const wchar_t* a, const wchar_t* b, size_t n)
  86 {
  87 #ifdef ENABLE_NLS
  88         return wcsncasecmp (a, b, n);
  89 #else
  90         return strncasecmp (a, b, n);
  91 #endif
  92 }
  93
  94 wchar_t*
  95 wchar_strdup (const wchar_t* str)
  96 {
  97 #ifdef ENABLE_NLS
  98         return wcsdup (str);
  99 #else
 100         return xstrdup (str);
 101 #endif
 102 }
 103
 104 /* converts a string from the encoding in the gettext catalogues to wide
 105  * character strings (of type wchar_t*).
 106  */
 107 #ifdef ENABLE_NLS
 108 static wchar_t*
 109 gettext_to_wchar (const char* str)
 110 {
 111         int             count;
 112         wchar_t*        result;
 113         size_t          status;
 114         mbstate_t       ps;
 115
 116         count = strlen (str) + 1;
 117         result = malloc (count * sizeof (wchar_t));
 118         if (!result)
 119                 goto error;
 120
 121         memset(&ps, 0, sizeof (ps));
 122         status = mbsrtowcs(result, &str, count, &ps);
 123         if (status == (size_t) -1)
 124                 goto error;
 125
 126         result = realloc (result, (wcslen (result) + 1) * sizeof (wchar_t));
 127         return result;
 128
 129 error:
 130         printf ("Error during translation: %s\n", strerror (errno));
 131         exit (1);
 132 }
 133
 134 #else /* ENABLE_NLS */
 135
 136 static wchar_t*
 137 gettext_to_wchar (const char* str)
 138 {
 139         return xstrdup (str);
 140 }
 141
 142 #endif /* !ENABLE_NLS */
 143
 144
 145 #ifdef ENABLE_NLS
 146 static char*
 147 wchar_to_str (const wchar_t* str, size_t count)
 148 {
 149         char*           result;
 150         char*           out_buf;
 151         size_t          status;
 152         mbstate_t       ps;
 153         size_t          i;
 154
 155         if (count == 0 || wcslen(str) < count)
 156                 count = wcslen (str);
 157
 158         out_buf = result = malloc ((count + 1) *  MB_LEN_MAX);
 159         if (!result)
 160                 goto error;
 161
 162         memset(&ps, 0, sizeof(ps));
 163
 164         for (i = 0; i < count; i++) {
 165                 status = wcrtomb (out_buf, str[i], &ps);
 166                 if (status == (size_t) -1)
 167                         goto error;
 168                 out_buf += status;
 169         }
 170
 171         status = wcrtomb (out_buf, 0, &ps);
 172         if (status == (size_t) -1)
 173                 goto error;
 174
 175         result = realloc (result, strlen (result) + 1);
 176         return result;
 177
 178 error:
 179         printf ("Error during translation: %s\n", strerror (errno));
 180         exit (1);
 181 }
 182
 183 #else /* ENABLE_NLS */
 184
 185 static char*
 186 wchar_to_str (const wchar_t* str, size_t count)
 187 {
 188         char*           result;
 189
 190         result = xstrdup (str);
 191         if (count && count < strlen (result))
 192                 result [count] = 0;
 193         return result;
 194 }
 195
 196 #endif /* !ENABLE_NLS */
 197
 198 static void
 199 print_wchar (const wchar_t* str, size_t count)
 200 {
 201         char*   tmp = wchar_to_str (str, count);
 202         printf ("%s", tmp);
 203         free (tmp);
 204 }
 205
 206 static StrList*
 207 str_list_alloc ()
 208 {
 209         StrList*        list;
 210
 211         list = xmalloc (sizeof (StrList));
 212         list->next = NULL;
 213
 214         return list;
 215 }
 216
 217 void
 218 str_list_destroy (StrList* list)
 219 {
 220         if (list) {
 221                 str_list_destroy (list->next);
 222                 str_list_destroy_node (list);
 223         }
 224 }
 225
 226 void
 227 str_list_destroy_node (StrList* list)
 228 {
 229         free ((wchar_t*) list->str);
 230         free (list);
 231 }
 232
 233 StrList*
 234 str_list_duplicate_node (const StrList* node)
 235 {
 236         StrList*        result = str_list_alloc ();
 237         result->str = wchar_strdup (node->str);
 238         return result;
 239 }
 240
 241 StrList*
 242 str_list_duplicate (const StrList* list)
 243 {
 244         if (list)
 245                 return str_list_join (str_list_duplicate_node (list),
 246                                       str_list_duplicate (list->next));
 247         else
 248                 return NULL;
 249 }
 250
 251 StrList*
 252 str_list_join (StrList* a, StrList* b)
 253 {
 254         StrList*        walk;
 255
 256         for (walk = a; walk && walk->next; walk = walk->next);
 257
 258         if (walk) {
 259                 walk->next = b;
 260                 return a;
 261         } else {
 262                 return b;
 263         }
 264 }
 265
 266 static StrList*
 267 _str_list_append (StrList* list, const wchar_t* str)
 268 {
 269         StrList*        walk;
 270
 271         if (list) {
 272                 for (walk = list; walk->next; walk = walk->next);
 273                 walk->next = str_list_alloc ();
 274                 walk = walk->next;
 275         } else {
 276                 walk = list = str_list_alloc ();
 277         }
 278         walk->str = str;
 279
 280         return list;
 281 }
 282
 283 StrList*
 284 str_list_append (StrList* list, const char* str)
 285 {
 286         return _str_list_append (list, gettext_to_wchar (str));
 287 }
 288
 289 StrList*
 290 str_list_append_unique (StrList* list, const char* str)
 291 {
 292         StrList*        walk;
 293         wchar_t*        new_str = gettext_to_wchar (str);
 294
 295         for (walk=list; walk; walk=walk->next) {
 296                 if (walk->str) {
 297                         if (wchar_strcasecmp (new_str, walk->str) == 0) {
 298                                 free (new_str);
 299                                 return list;
 300                         }
 301                 }
 302         }
 303
 304         return _str_list_append (list, new_str);
 305 }
 306
 307 StrList*
 308 str_list_insert (StrList* list, const char* str)
 309 {
 310         return str_list_join (str_list_create (str, NULL), list);
 311 }
 312
 313 StrList*
 314 str_list_create (const char* first, ...)
 315 {
 316         va_list         args;
 317         char*           str;
 318         StrList*        list;
 319
 320         list = str_list_append (NULL, first);
 321
 322         if (first) {
 323                 va_start (args, first);
 324                 while ( (str = va_arg (args, char*)) )
 325                         str_list_append (list, str);
 326                 va_end (args);
 327         }
 328
 329         return list;
 330 }
 331
 332 StrList*
 333 str_list_create_unique (const char* first, ...)
 334 {
 335         va_list         args;
 336         char*           str;
 337         StrList*        list;
 338
 339         list = str_list_append (NULL, first);
 340
 341         if (first) {
 342                 va_start (args, first);
 343                 while ( (str = va_arg (args, char*)) )
 344                         str_list_append_unique (list, str);
 345                 va_end (args);
 346         }
 347
 348         return list;
 349 }
 350
 351 char*
 352 str_list_convert_node (const StrList* list)
 353 {
 354         return wchar_to_str (list->str, 0);
 355 }
 356
 357 char*
 358 str_list_convert (const StrList* list)
 359 {
 360         const StrList*  walk;
 361         int             pos = 0;
 362         int             length = 1;
 363         char*           str = xstrdup ("");
 364
 365         for (walk = list; walk; walk = walk->next) {
 366                 if (walk->str) {
 367                         char*   tmp = wchar_to_str (walk->str, 0);
 368
 369                         length += strlen (tmp);
 370
 371                         str = realloc (str, length);
 372                         strcpy (str + pos, tmp);
 373
 374                         pos = length - 1;
 375                         free (tmp);
 376                 }
 377         }
 378
 379         return str;
 380 }
 381
 382 void
 383 str_list_print (const StrList* list)
 384 {
 385         const StrList*  walk;
 386
 387         for (walk=list; walk; walk=walk->next) {
 388                 if (walk->str)
 389                         print_wchar (walk->str, 0);
 390         }
 391 }
 392
 393 static int
 394 str_search (const wchar_t* str, int n, wchar_t c)
 395 {
 396         int     i;
 397
 398         for (i=0; i<n; i++)
 399                 if (str [i] == c)
 400                         return i;
 401         return -1;
 402 }
 403
 404
 405 /* Japanese don't leave spaces between words, so ALL Japanese characters
 406  * are treated as delimiters.  Note: since the translations should already
 407  * be properly formatted (eg: spaces after commas), there should be no
 408  * need to include them.  Best not to avoid side effects, like 3.
 409 14159 :-)
 410  * FIXME: how do we exclude "." and "(" ?
 411  * FIXME: glibc doesn't like umlaute.  i.e. \"o (TeX notation), which should
 412  * look like: ö
 413  */
 414
 415 static int
 416 is_break_point (wchar_t c)
 417 {
 418 #ifdef ENABLE_NLS
 419         return !iswalnum (c) && !iswpunct (c);
 420 #else
 421         return !isalnum (c) && !ispunct (c);
 422 #endif
 423 }
 424
 425 /* NOTE: this should not return '\n' as a space, because explicit '\n' may
 426  * be placed inside strings.
 427  */
 428 static int
 429 is_space (wchar_t c)
 430 {
 431 #ifdef ENABLE_NLS
 432         return c == (wchar_t) btowc(' ');
 433 #else
 434         return c == ' ';
 435 #endif
 436 }
 437
 438 void
 439 str_list_print_wrap (const StrList* list, int line_length, int offset,
 440                      int indent)
 441 {
 442         const StrList*  walk;
 443         const wchar_t*  str;
 444         int             str_len;
 445         int             cut_right;
 446         int             cut_left;
 447         int             line_left;
 448         int             search_result;
 449         int             line_break;
 450
 451         PED_ASSERT (line_length - indent > 10, return);
 452
 453         line_left = line_length - offset;
 454
 455         for (walk=list; walk; walk=walk->next) {
 456                 if (!walk->str)
 457                         continue;
 458                 str = walk->str;
 459                 str_len = wchar_strlen (str);
 460
 461                 while (line_left < str_len || wchar_strchr (str, '\n')) {
 462                         line_break = 0;
 463
 464                         cut_left = MIN (line_left - 1, str_len - 1);
 465
 466                         /* we can have a space "over", but not a comma */
 467                         if (cut_left < str_len
 468                                         && is_space (str [cut_left + 1]))
 469                                 cut_left++;
 470
 471                         while (cut_left && !is_break_point (str [cut_left]))
 472                                 cut_left--;
 473                         while (cut_left && is_space (str [cut_left]))
 474                                 cut_left--;
 475
 476                 /* str [cut_left] is either the end of a word, or a
 477                  * Japanese character, or the start of a blank line.
 478                  */
 479
 480                         search_result = str_search (str, cut_left + 1, '\n');
 481                         if (search_result != -1) {
 482                                 cut_left = search_result - 1;
 483                                 line_break = 1;
 484                         }
 485
 486                         for (cut_right = cut_left + (line_break ? 2 : 1);
 487                              cut_right < str_len && is_space (str [cut_right]);
 488                              cut_right++);
 489
 490                         if (cut_left > 0)
 491                                 print_wchar (str, cut_left + 1);
 492
 493                         str += cut_right;
 494                         str_len -= cut_right;
 495                         line_left = line_length - indent;
 496
 497                         if (walk->next || *str)
 498                                 printf ("\n%*s", indent, "");
 499                         else if (line_break)
 500                                 putchar ('\n');
 501                 }
 502
 503                 print_wchar (str, 0);
 504                 line_left -= wchar_strlen (str);
 505         }
 506 }
 507
 508 static int
 509 _str_list_match_node (const StrList* list, const wchar_t* str)
 510 {
 511         if (wchar_strcasecmp (list->str, str) == 0)
 512                 return 2;
 513         if (wchar_strncasecmp (list->str, str, wchar_strlen (str)) == 0)
 514                 return 1;
 515         return 0;
 516 }
 517
 518 int
 519 str_list_match_node (const StrList* list, const char* str)
 520 {
 521         wchar_t*        wc_str = gettext_to_wchar (str);        /* FIXME */
 522         int             status;
 523
 524         status = _str_list_match_node (list, wc_str);
 525         free (wc_str);
 526
 527         return status;
 528 }
 529
 530 /* returns:  2 for full match
 531              1 for partial match
 532              0 for no match
 533  */
 534 int
 535 str_list_match_any (const StrList* list, const char* str)
 536 {
 537         const StrList*  walk;
 538         int             best_status = 0;
 539         wchar_t*        wc_str = gettext_to_wchar (str);
 540
 541         for (walk = list; walk; walk = walk->next) {
 542                 int     this_status = _str_list_match_node (walk, wc_str);
 543                 if (this_status > best_status)
 544                         best_status = this_status;
 545         }
 546
 547         free (wc_str);
 548         return best_status;
 549 }
 550
 551 StrList*
 552 str_list_match (const StrList* list, const char* str)
 553 {
 554         const StrList*  walk;
 555         const StrList*  partial_match = NULL;
 556         int             ambiguous = 0;
 557         wchar_t*        wc_str = gettext_to_wchar (str);
 558
 559         for (walk = list; walk; walk = walk->next) {
 560                 switch (_str_list_match_node (walk, wc_str)) {
 561                         case 2:
 562                                 free (wc_str);
 563                                 return (StrList*) walk;
 564
 565                         case 1:
 566                                 if (partial_match)
 567                                         ambiguous = 1;
 568                                 partial_match = walk;
 569                 }
 570         }
 571
 572         free (wc_str);
 573         return ambiguous ? NULL : (StrList*) partial_match;
 574 }
 575
 576 int
 577 str_list_length (const StrList* list)
 578 {
 579         int             length = 0;
 580         const StrList*  walk;
 581
 582         for (walk = list; walk; walk = walk->next)
 583                 length++;
 584
 585         return length;
 586 }