tools/flexcat/src/utils.c

   1 /*
   2  * $Id$
   3  *
   4  * Copyright (C) 1993-1999 by Jochen Wiedmann and Marcin Orlowski
   5  * Copyright (C) 2002-2010 by the FlexCat Open Source Team
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or (at
  10  * your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20  *
  21  */
  22
  23 #if defined(AMIGA)
  24   #include <proto/codesets.h>
  25 #else
  26   #include <iconv.h>
  27 #endif
  28
  29 #include "flexcat.h"
  30 #include "readprefs.h"
  31 #include "swapfuncs.h"
  32 #include "showfuncs.h"
  33 #include "scancd.h"
  34 #include "scanct.h"
  35 #include "createcat.h"
  36 #include "globals.h"
  37 #include "utils.h"
  38 #include "openlibs.h"
  39 #include "SDI_compiler.h"
  40
  41 const char VString[] = VERS " [" SYSTEMSHORT "/" CPU "] (" EXE_DATE ")\n" EXE_COPYRIGHT;
  42 const char EString[] = "Contact: http://sf.net/p/flexcat/";
  43
  44 /// MyExit
  45
  46 void MyExit(int Code)
  47 {
  48 #ifdef AMIGA
  49   if((NumberOfWarnings > 0 || Code != 0) && !NoBeep)
  50     DisplayBeep(NULL);
  51 #endif
  52   CloseFlexCatCatalog();
  53   CloseLibs();
  54 #ifdef NOERRORONWARN
  55   if (Code < 10)
  56     Code = 0;
  57 #endif
  58   exit(Code);
  59 }
  60
  61 ///
  62
  63 #ifndef AMIGA
  64
  65 /*
  66  * This array is designed for mapping upper and lower case letters
  67  * together for a case independent comparison.  The mappings are
  68  * based upon ascii character sequences.
  69  */
  70
  71 typedef unsigned char uc;
  72 static const unsigned char charmap[] =
  73 {
  74   (uc)'\000', (uc)'\001', (uc)'\002', (uc)'\003', (uc)'\004', (uc)'\005', (uc)'\006', (uc)'\007',
  75   (uc)'\010', (uc)'\011', (uc)'\012', (uc)'\013', (uc)'\014', (uc)'\015', (uc)'\016', (uc)'\017',
  76   (uc)'\020', (uc)'\021', (uc)'\022', (uc)'\023', (uc)'\024', (uc)'\025', (uc)'\026', (uc)'\027',
  77   (uc)'\030', (uc)'\031', (uc)'\032', (uc)'\033', (uc)'\034', (uc)'\035', (uc)'\036', (uc)'\037',
  78   (uc)'\040', (uc)'\041', (uc)'\042', (uc)'\043', (uc)'\044', (uc)'\045', (uc)'\046', (uc)'\047',
  79   (uc)'\050', (uc)'\051', (uc)'\052', (uc)'\053', (uc)'\054', (uc)'\055', (uc)'\056', (uc)'\057',
  80   (uc)'\060', (uc)'\061', (uc)'\062', (uc)'\063', (uc)'\064', (uc)'\065', (uc)'\066', (uc)'\067',
  81   (uc)'\070', (uc)'\071', (uc)'\072', (uc)'\073', (uc)'\074', (uc)'\075', (uc)'\076', (uc)'\077',
  82   (uc)'\100', (uc)'\141', (uc)'\142', (uc)'\143', (uc)'\144', (uc)'\145', (uc)'\146', (uc)'\147',
  83   (uc)'\150', (uc)'\151', (uc)'\152', (uc)'\153', (uc)'\154', (uc)'\155', (uc)'\156', (uc)'\157',
  84   (uc)'\160', (uc)'\161', (uc)'\162', (uc)'\163', (uc)'\164', (uc)'\165', (uc)'\166', (uc)'\167',
  85   (uc)'\170', (uc)'\171', (uc)'\172', (uc)'\133', (uc)'\134', (uc)'\135', (uc)'\136', (uc)'\137',
  86   (uc)'\140', (uc)'\141', (uc)'\142', (uc)'\143', (uc)'\144', (uc)'\145', (uc)'\146', (uc)'\147',
  87   (uc)'\150', (uc)'\151', (uc)'\152', (uc)'\153', (uc)'\154', (uc)'\155', (uc)'\156', (uc)'\157',
  88   (uc)'\160', (uc)'\161', (uc)'\162', (uc)'\163', (uc)'\164', (uc)'\165', (uc)'\166', (uc)'\167',
  89   (uc)'\170', (uc)'\171', (uc)'\172', (uc)'\173', (uc)'\174', (uc)'\175', (uc)'\176', (uc)'\177',
  90   (uc)'\200', (uc)'\201', (uc)'\202', (uc)'\203', (uc)'\204', (uc)'\205', (uc)'\206', (uc)'\207',
  91   (uc)'\210', (uc)'\211', (uc)'\212', (uc)'\213', (uc)'\214', (uc)'\215', (uc)'\216', (uc)'\217',
  92   (uc)'\220', (uc)'\221', (uc)'\222', (uc)'\223', (uc)'\224', (uc)'\225', (uc)'\226', (uc)'\227',
  93   (uc)'\230', (uc)'\231', (uc)'\232', (uc)'\233', (uc)'\234', (uc)'\235', (uc)'\236', (uc)'\237',
  94   (uc)'\240', (uc)'\241', (uc)'\242', (uc)'\243', (uc)'\244', (uc)'\245', (uc)'\246', (uc)'\247',
  95   (uc)'\250', (uc)'\251', (uc)'\252', (uc)'\253', (uc)'\254', (uc)'\255', (uc)'\256', (uc)'\257',
  96   (uc)'\260', (uc)'\261', (uc)'\262', (uc)'\263', (uc)'\264', (uc)'\265', (uc)'\266', (uc)'\267',
  97   (uc)'\270', (uc)'\271', (uc)'\272', (uc)'\273', (uc)'\274', (uc)'\275', (uc)'\276', (uc)'\277',
  98   (uc)'\300', (uc)'\341', (uc)'\342', (uc)'\343', (uc)'\344', (uc)'\345', (uc)'\346', (uc)'\347',
  99   (uc)'\350', (uc)'\351', (uc)'\352', (uc)'\353', (uc)'\354', (uc)'\355', (uc)'\356', (uc)'\357',
 100   (uc)'\360', (uc)'\361', (uc)'\362', (uc)'\363', (uc)'\364', (uc)'\365', (uc)'\366', (uc)'\367',
 101   (uc)'\370', (uc)'\371', (uc)'\372', (uc)'\333', (uc)'\334', (uc)'\335', (uc)'\336', (uc)'\337',
 102   (uc)'\340', (uc)'\341', (uc)'\342', (uc)'\343', (uc)'\344', (uc)'\345', (uc)'\346', (uc)'\347',
 103   (uc)'\350', (uc)'\351', (uc)'\352', (uc)'\353', (uc)'\354', (uc)'\355', (uc)'\356', (uc)'\357',
 104   (uc)'\360', (uc)'\361', (uc)'\362', (uc)'\363', (uc)'\364', (uc)'\365', (uc)'\366', (uc)'\367',
 105   (uc)'\370', (uc)'\371', (uc)'\372', (uc)'\373', (uc)'\374', (uc)'\375', (uc)'\376', (uc)'\377',
 106 };
 107
 108 /// Stricmp
 109
 110 int Stricmp(const char *str1, const char *str2)
 111 {
 112   unsigned char u1, u2;
 113
 114   for(;;)
 115   {
 116     u1 = (unsigned char)*str1++;
 117     u2 = (unsigned char)*str2++;
 118
 119     if(charmap[u1] != charmap[u2])
 120       return charmap[u1] - charmap[u2];
 121
 122     if(u1 == '\0')
 123       return 0;
 124   }
 125 }
 126
 127 ///
 128 /// Strnicmp
 129
 130 int Strnicmp(const char *str1, const char *str2, int len)
 131 {
 132   unsigned char u1, u2;
 133
 134   for(; len != 0; --len)
 135   {
 136     u1 = (unsigned char)*str1++;
 137     u2 = (unsigned char)*str2++;
 138     if(charmap[u1] != charmap[u2])
 139       return charmap[u1] - charmap[u2];
 140
 141     if(u1 == '\0')
 142       return 0;
 143   }
 144
 145   return 0;
 146 }
 147 #endif
 148 ///
 149 /// AllocString
 150
 151 /* This allocates a string */
 152
 153 char *AllocString(const char *str)
 154 {
 155   char *ptr;
 156
 157   if((ptr = malloc(strlen(str) + 1)) == NULL)
 158     MemError();
 159
 160   strcpy(ptr, str);
 161
 162   return ptr;
 163 }
 164
 165 ///
 166 /// Add a string to an already allocated one
 167
 168 char *AddString(char *str, const char *astr)
 169 {
 170   char *ptr;
 171
 172   if((ptr = malloc(strlen(str) + strlen(astr) + 1)) == NULL)
 173     MemError();
 174
 175   strcpy(ptr, str);
 176   strcat(ptr, astr);
 177
 178   free(str);
 179
 180   return ptr;
 181 }
 182
 183 ///
 184 /// Convert a string from one charset to another
 185
 186 #ifdef AMIGA
 187 char *ConvertString(char *str, const char *from_charset, const char *to_charset)
 188 {
 189   char *result = NULL;
 190   BOOL fromIsUTF8 = (Stricmp(from_charset, "UTF-8") == 0 || Stricmp(from_charset, "UTF8") == 0);
 191   BOOL toIsUTF8 = (Stricmp(to_charset, "UTF-8") == 0 || Stricmp(to_charset, "UTF8") == 0);
 192
 193   if(fromIsUTF8 == TRUE && toIsUTF8 == TRUE)
 194   {
 195     // no need to convert from UTF8 to UTF8
 196     // just return a plain copy of the string
 197     result = strdup(str);
 198   }
 199   else
 200   {
 201     struct codeset *dstCodeset;
 202
 203     dstCodeset = CodesetsFind((STRPTR)to_charset,
 204                               CSA_FallbackToDefault, FALSE,
 205                               TAG_DONE);
 206     if(dstCodeset != NULL)
 207     {
 208       ULONG dstLen = 0;
 209       char *dstText = NULL;
 210
 211       if(fromIsUTF8 == TRUE)
 212       {
 213         dstText = CodesetsUTF8ToStr(CSA_Source,      str,
 214                                     CSA_DestCodeset, dstCodeset,
 215                                     CSA_DestLenPtr,  &dstLen,
 216                                     TAG_DONE);
 217       }
 218       else
 219       {
 220         struct codeset *srcCodeset;
 221
 222         srcCodeset = CodesetsFind((STRPTR)from_charset,
 223                                   CSA_FallbackToDefault, FALSE,
 224                                   TAG_DONE);
 225
 226         if(srcCodeset != NULL)
 227         {
 228           dstText = CodesetsConvertStr(CSA_Source,        str,
 229                                        CSA_SourceCodeset, srcCodeset,
 230                                        CSA_DestCodeset,   dstCodeset,
 231                                        CSA_DestLenPtr,    &dstLen,
 232                                        TAG_DONE);
 233         }
 234       }
 235
 236       if(dstText != NULL && dstLen != 0)
 237       {
 238         char *buf;
 239
 240         // copy the converted string into a separate allocated string
 241         if((buf = malloc(dstLen+1)) != NULL)
 242         {
 243           memcpy(buf, dstText, dstLen);
 244           buf[dstLen] = '\0';
 245           result = buf;
 246         }
 247
 248         CodesetsFreeA(dstText, NULL);
 249       }
 250     }
 251   }
 252
 253   return result;
 254 }
 255 #else
 256 char *ConvertString(char *str, const char *from_charset, const char *to_charset)
 257 {
 258   char *result = NULL;
 259   iconv_t ict;
 260
 261   if((ict = iconv_open(to_charset, from_charset)) != (iconv_t)-1)
 262   {
 263     size_t inleft = strlen(str);
 264     char *buf;
 265
 266     if((buf = malloc((inleft+1)*sizeof(char))) != NULL)
 267     {
 268       size_t outleft = inleft;
 269       char *outbuf = buf;
 270
 271       if(iconv(ict, &str, &inleft, &outbuf, &outleft) != (size_t)-1)
 272       {
 273         *outbuf = '\0';
 274         result = buf;
 275       }
 276       else
 277       {
 278         printf("ERROR: iconv()\n");
 279         free(buf);
 280       }
 281     }
 282     else
 283       MemError();
 284
 285     iconv_close(ict);
 286   }
 287   else
 288     printf("ERROR: iconv_open()\n");
 289
 290   return result;
 291 }
 292 #endif
 293
 294 ///
 295 /// Add catalog chunk
 296
 297 /* This adds a new catalog chunk to the list of catalog
 298    chunks. */
 299
 300 char *AddCatalogChunk(char *ID, const char *string)
 301 {
 302   struct CatalogChunk *cc, **ccptr;
 303
 304   if((cc = malloc(sizeof(*cc))) == NULL)
 305     MemError();
 306
 307   cc->Next = NULL;
 308   cc->ID = *((ULONG *)ID);
 309   cc->ChunkStr = AllocString(string);
 310
 311   /* Put the new chunk at the end of the chunk list. */
 312
 313   for(ccptr = &FirstChunk; *ccptr != NULL; ccptr = &(*ccptr)->Next)
 314   {
 315   }
 316   *ccptr = cc;
 317
 318   return cc->ChunkStr;
 319 }
 320
 321 ///
 322 /// gethex
 323
 324 /* This translates an hex character. */
 325
 326 int gethex(int c)
 327 {
 328   if(c >= '0' && c <= '9')
 329     return c - '0';
 330   else if(c >= 'a' && c <= 'f')
 331     return c - 'a' + 10;
 332   else if(c >= 'A' && c <= 'F')
 333     return c - 'A' + 10;
 334
 335   ShowError(MSG_ERR_EXPECTEDHEX);
 336
 337   return 0;
 338 }
 339
 340 ///
 341 /// getoctal
 342
 343 /* This translates an octal digit. */
 344
 345 int getoctal(int c)
 346 {
 347   if(c >= '0' && c <= '7')
 348     return c - '0';
 349
 350   ShowError(MSG_ERR_EXPECTEDOCTAL);
 351
 352   return 0;
 353 }
 354
 355 ///
 356 /// ReadLine
 357
 358 /* Reading a line is somewhat complicated in order to allow lines of any
 359    length.
 360
 361    Inputs: fp - the file, where the input comes from
 362        AllowComment - TRUE if a leading semicolon should force the
 363               line to be interpreted as a comment */
 364
 365 char *ReadLine(FILE *fp, UNUSED int AllowComment)
 366 {
 367   char *NewLine = NULL;
 368   int c = '\0';
 369   int Len = 0, LineLen = 0;
 370   int FirstChar = TRUE;
 371   int BackslashSeen = FALSE;
 372   int BackslashSeenOn = 0;    /* Position where the last backslash was seen. */
 373   int CommentLine = FALSE;    /* If TRUE, we should ignore any trailing \'s */
 374
 375   while(c != EOF)
 376   {
 377     if(Len + 10 > LineLen)
 378     {
 379       NewLine = realloc(NewLine, LineLen + BUFSIZE);
 380       LineLen += BUFSIZE;
 381     }
 382
 383     c = getc(fp);
 384
 385     if(FirstChar)
 386     {
 387       if(c == EOF)
 388       {
 389         if(NewLine != NULL)
 390           free(NewLine);
 391         return NULL;
 392       }
 393
 394       if(c == ';')
 395       {
 396         CommentLine = TRUE;
 397       }
 398
 399       FirstChar = FALSE;
 400     }
 401
 402     switch(c)
 403     {
 404       case '\r':
 405         break;
 406
 407       case '\n':
 408         ++ScanLine;
 409         if(BackslashSeen)
 410         {
 411           NewLine[Len++] = c;
 412           BackslashSeen = FALSE;
 413           break;
 414         }
 415         c = EOF;
 416
 417       case EOF:
 418         break;
 419
 420       /* Check for trailing \\ */
 421       case '\\':
 422         {
 423           if(!CommentLine)
 424           {
 425             if(BackslashSeen)
 426             {
 427               if(BackslashSeenOn ==(Len - 1))
 428               {
 429                 BackslashSeen = FALSE;
 430                 NewLine[Len++] = c;
 431                 break;
 432               }
 433             }
 434
 435             BackslashSeen = TRUE;
 436             BackslashSeenOn = Len;
 437           }
 438
 439           NewLine[Len++] = c;
 440           break;
 441         }
 442
 443
 444       default:
 445         BackslashSeen = FALSE;
 446         NewLine[Len++] = c;
 447     }
 448   }
 449
 450   NewLine[Len] = '\0';
 451
 452   return NewLine;
 453
 454 }
 455
 456 ///
 457 /// OverSpace
 458
 459 /* This removes trailing blanks. */
 460
 461 void OverSpace(char **strptr)
 462 {
 463   int c;
 464
 465   while((c = **strptr) == ' ' || c == '\t')
 466   {
 467      (*strptr)++;
 468   }
 469 }
 470
 471 ///
 472 /// Expunge
 473
 474 void Expunge(void)
 475 {
 476 #ifdef AMIGA
 477   if(DoExpunge)
 478   {
 479     struct Library *localeBase;
 480
 481     // this may look utterly wrong since we are trying to RemLibrary() a library
 482     // which we just opened. But this is the most convenient way to invoke the
 483     // Expunge() function of locale.library, which will just remove any still
 484     // opened but unused catalog file from memory without removing locale.library
 485     // itself.
 486     if((localeBase = OpenLibrary( "locale.library", 0)) != NULL)
 487     {
 488       RemLibrary(localeBase);
 489       CloseLibrary(localeBase);
 490     }
 491   }
 492 #endif // AMIGA
 493 }
 494
 495 ///
 496 /// ReadChar
 497
 498 /* ReadChar scans an input line and translates the backslash characters.
 499    Inputs: char *  - a pointer to a string pointer; the latter points
 500            to the next character to be read and points behind
 501            the read bytes after executing ReadChar
 502        dest  - a pointer to a buffer, where the read bytes should be
 503            stored
 504    Result: number of bytes that are written to dest (between 0 and 2) */
 505
 506 int ReadChar(char **strptr, char *dest)
 507 {
 508   char c;
 509   int i;
 510
 511   switch(c = *((*strptr)++))
 512   {
 513     case '\\':
 514     {
 515       switch(c = tolower((int)*((*strptr)++)))
 516       {
 517         case '\n':
 518           return(0);
 519         break;
 520
 521         case 'b':
 522           *dest = '\b';
 523         break;
 524
 525         case 'c':
 526           *dest = '\233';
 527         break;
 528
 529         case 'e':
 530           *dest = '\033';
 531         break;
 532
 533         case 'f':
 534           *dest = '\f';
 535         break;
 536
 537         case 'g':
 538           *dest = '\007';
 539         break;
 540
 541         case 'n':
 542           *dest = '\n';
 543         break;
 544
 545         case 'r':
 546           *dest = '\r';
 547         break;
 548
 549         case 't':
 550           *dest = '\t';
 551         break;
 552
 553         case 'v':
 554           *dest = '\013';
 555         break;
 556
 557         case 'x':
 558         {
 559           *dest = gethex((int)**strptr);
 560           (*strptr)++;
 561           c = **strptr;
 562           if((c >= '0' && c <= '9') ||
 563              (c >= 'a' && c <= 'f') ||
 564              (c >= 'A' && c <= 'F'))
 565           {
 566             *dest =(*dest << 4) + gethex((int)c);
 567             (*strptr)++;
 568           }
 569         }
 570         break;
 571
 572         case '0':
 573         case '1':
 574         case '2':
 575         case '3':
 576         case '4':
 577         case '5':
 578         case '6':
 579         case '7':
 580         {
 581           *dest = getoctal((int)c);
 582
 583           for(i = 0; i < 2; i++)
 584           {
 585             c = **strptr;
 586             if(c >= '0' && c <= '7')
 587             {
 588               *dest =(*dest << 3) + getoctal((int)c);
 589               (*strptr)++;
 590             }
 591           }
 592         }
 593         break;
 594
 595         case ')':
 596         case '\\':
 597           *(dest++) = '\\';
 598           *dest = c;
 599           return(2);
 600         break;
 601
 602         default:
 603           *dest = c;
 604         break;
 605       }
 606     }
 607     break;
 608
 609     default:
 610     {
 611       *dest = c;
 612     }
 613     break;
 614   }
 615   return(1);
 616 }
 617
 618 ///
 619 /// AllocFileName
 620
 621 /* This function creates a copy of a filename, and optionally
 622    removes an ending and pathname components, if desired.
 623    Inputs: filename  - the filename to copy
 624        howto   - a set of bits
 625              bit 0: 1 = remove ending, 0 = leave it
 626              bit 1: 1 = remove pathname, 0 = leave it
 627    Result: the copy of the filename
 628 */
 629
 630 char *AllocFileName(char *filename, int howto)
 631 {
 632   char *tempstr, *ptr;
 633
 634   if((tempstr = strdup(filename)) == NULL)
 635   {
 636     MemError();
 637     MyExit(10);
 638   }
 639
 640   /* Remove pathname components, if desired. */
 641
 642   if(howto & 2)
 643   {
 644     if((ptr = strchr(tempstr, ':')) != NULL)
 645     {
 646       tempstr = ptr + 1;
 647     }
 648     if((ptr = strrchr(tempstr, '/')) != NULL)
 649     {
 650       tempstr = ptr + 1;
 651     }
 652   }
 653
 654   /* Remove ending, if desired. */
 655
 656   if(howto & 1)
 657   {
 658     if((ptr = strrchr(tempstr, '.')) != NULL)
 659     {
 660       *ptr = '\0';
 661     }
 662   }
 663
 664   return(tempstr);
 665 }
 666
 667 ///
 668 /// AddFileName
 669
 670 /* This function adds a pathname and a filename to a full
 671    filename.
 672    Inputs: pathname - the leading pathname
 673        filename - the filename
 674    Result: The new filename */
 675
 676 char *AddFileName(char *pathname, char *filename)
 677 {
 678   char *buffer;
 679
 680 #ifdef AMIGA
 681   int size = strlen(pathname) + strlen(filename) + 2;
 682
 683   if((buffer = malloc(size)) == NULL)
 684   {
 685     MemError();
 686     MyExit(10);
 687   }
 688
 689   strcpy(buffer, pathname);
 690   AddPart((char *)buffer, (char *)filename, size);
 691 #else
 692   if(asprintf(&buffer, "%s/%s", pathname, filename) < 0)
 693   {
 694     MemError();
 695     MyExit(10);
 696   }
 697 #endif
 698
 699   return buffer;
 700 }
 701
 702 ///
 703 /// Usage
 704
 705 /* The Usage function describes the program's calling syntax. */
 706
 707 void Usage(void)
 708 {
 709   fprintf(stderr, "%s\n", VString);
 710   fprintf(stderr, "%s\n", EString);
 711   fprintf(stderr,
 712       "\n" \
 713       "%s\n" \
 714       "     FlexCat CDFILE/A,CTFILE,POFILE,CATALOG/K,NEWCTFILE/K,SOURCES/M,\n" \
 715       "             WARNCTGAPS/S,NOOPTIM/S,FILL/S,FLUSH/S,NOBEEP/S,\n" \
 716       "             QUIET/S,NOLANGTOLOWER/S,NOBUFFEREDIO/S,MODIFIED/S,\n" \
 717       "             CODESET/K,COPYMSGNEW/S,OLDMSGNEW/K\n" \
 718       "\n", MSG_USAGE_HEAD);
 719   fprintf(stderr, "%s\n", MSG_USAGE);
 720   MyExit(5);
 721 }
 722
 723 ///
 724 /// wbmain
 725
 726 /* Dice's entry point for workbench programs */
 727
 728 #if defined(AMIGA)  &&  defined(_DCC)
 729 void wbmain(struct WBStartup *wbmsg)
 730 {
 731   fprintf(stderr, "FlexCat can't be run from Workbench!\n\n");
 732   fprintf(stderr, "Open a shell session and type FlexCat\n");
 733   fprintf(stderr, "for syntax and more information.\n");
 734
 735   exit(5);
 736 }
 737 #endif
 738 ///
 739