tools/FlexCat/flexcat.c

   1
   2 /*****************************************************************
   3 **                                                              **
   4 ** If you use GoldED or any other text editor featuring folding **
   5 ** you may want to set up "///" as fold opening phrase, and     **
   6 ** "//|" as closing one, as this source is using it.            **
   7 **                                                              **
   8 **                                                Marcin        **
   9 **                                                              **
  10 *****************************************************************/
  11
  12 /* $Id$ */
  13
  14
  15 //#define __amigados
  16
  17 /// README
  18 /*
  19
  20     FlexCat.c:  The flexible catalog creator
  21
  22     This program is distributed in the hope that it will be useful,
  23     but WITHOUT ANY WARRANTY; without even the implied warranty of
  24     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  25
  26     Ok, this is nothing special. It grabs a catalog translation and a
  27     catalog description file and produces catalogs and the source to
  28     handle them. What is it else than lots of other programs?
  29
  30     The difference is, that YOU determine what source FlexCat produces.
  31     Another file is scanned by FlexCat to produce code. This file contains
  32     some c-string like special characters (%v for version for example)
  33     You can edit this file and modify it as you want. So FlexCat can produce
  34     C source as well as Assembler, Oberon, Modula 2, E, ...
  35
  36 */
  37 //|
  38
  39 #define VERSION 2
  40 #define REVISION 4
  41 #define VERS       "FlexCat 2.4"
  42
  43 #ifdef __amigados
  44
  45  #ifdef _M68060
  46    #define _CPU "[68060]"
  47  #else
  48    #ifdef _M68040
  49      #define _CPU "[68040]"
  50    #else
  51      #ifdef _M68030
  52        #define _CPU "[68030]"
  53      #else
  54        #ifdef _M68020
  55          #define _CPU "[68020]"
  56        #else
  57          #ifdef _M68010
  58            #define _CPU "[68010]"
  59          #else
  60            #define _CPU "[680x0]"
  61          #endif
  62        #endif
  63      #endif
  64    #endif
  65  #endif
  66
  67 #define VSTRING  VERS " " _CPU " " __AMIGADATE__
  68 #else
  69 #define VSTRING  VERS
  70 #endif
  71
  72 #define VERSTAG  "$VER: " VSTRING
  73
  74 /// Includes and defines
  75
  76 #include <stdlib.h>
  77 #include <stdio.h>
  78 #include <string.h>
  79 #include <ctype.h>
  80 #include <time.h>
  81 #include <stdarg.h>
  82 #ifdef __amigados
  83         #include <dos.h>
  84 #endif
  85 #include "flexcat_cat.h"
  86
  87 #if ((defined(_DCC) && defined(AMIGA))       ||     \
  88      (defined(__SASC) && defined(_AMIGA)))      &&  \
  89     !defined(__amigados)
  90 #define __amigados
  91 #endif
  92
  93 #if defined(__amigados)
  94 #include <exec/types.h>
  95 #if defined(_DCC) || defined(__SASC) || defined(__GNUC__)
  96 #include <proto/exec.h>
  97 #include <proto/dos.h>
  98 #include <proto/intuition.h>
  99 #include <proto/utility.h>
 100 #else
 101 #include <clib/exec_protos.h>
 102 #include <clib/dos_protos.h>
 103 #include <clib/utility_protos.h>
 104 #endif
 105
 106 #ifdef tolower
 107 #undef tolower
 108 #endif
 109 #define tolower         ToLower
 110 #define stricmp(s,t)    Stricmp((char *) (s), (char *) (t))
 111 #define strnicmp(s,t,l) Strnicmp((char *) (s), (char *) (t), l)
 112
 113 #endif
 114
 115
 116 #ifndef FALSE
 117 #define FALSE 0
 118 #endif
 119 #ifndef TRUE
 120 #define TRUE (!FALSE)
 121 #endif
 122
 123
 124 #define MAXPATHLEN 512
 125 #define FLEXCAT_SDDIR "FLEXCAT_SDDIR"
 126 #if defined(__amigados)
 127 #define DEFAULT_FLEXCAT_SDDIR "PROGDIR:lib"
 128 #else
 129 #define DEFAULT_FLEXCAT_SDDIR "lib"
 130 #endif
 131
 132 #if defined(__amigados)
 133 #define MAX_PREFS_LEN 512
 134 #define FLEXCAT_PREFS "flexcat.prefs"
 135 char    prefs_sddir[MAXPATHLEN] = "\0";
 136 #endif
 137
 138
 139 #ifndef MAKE_ID
 140 #define MAKE_ID(a,b,c,d)        \
 141         ((ULONG) (a)<<24 | (ULONG) (b)<<16 | (ULONG) (c)<<8 | (ULONG) (d))
 142 #endif
 143
 144 #ifndef ULONG
 145 #define ULONG unsigned int
 146 #endif
 147
 148 //|
 149 /// Structs
 150
 151 enum StringTypes {
 152     TYPE_C,         /*  Produce C strings                   */
 153     TYPE_ASSEMBLER, /*  Produce Assembler strings           */
 154     TYPE_OBERON,    /*  Produce Oberon strings              */
 155     TYPE_E,         /*  Produce E strings. (Oops, thought   */
 156                     /*  it allows only 32 bit integers? ;-) */
 157     TYPE_NONE       /*  Simple strings                      */
 158 };
 159
 160
 161 enum OutputModes {
 162     OutputMode_None,    /*  Nothing written yet                 */
 163     OutputMode_Bin,     /*  Last character written was binary   */
 164     OutputMode_Ascii    /*  Last character written was Ascii    */
 165 };
 166
 167 struct CatString
 168 { struct CatString *Next;
 169   char *CD_Str;
 170   char *CT_Str;
 171   char *ID_Str;
 172   int MinLen, MaxLen, ID, Nr;
 173   int NotInCT;          /* If string is not present we write NEW    */
 174                         /* while updating CT file, for easier work. */
 175
 176 };
 177
 178 struct CDLine
 179 { struct CDLine *Next;
 180   char *Line;
 181 };
 182
 183 struct CatalogChunk
 184 { struct CatalogChunk *Next;            /* struct CatalogChunk *Next */
 185   ULONG ID;
 186   char *ChunkStr;
 187 };
 188
 189 struct CatString *FirstCatString = NULL;  /*  First catalog string            */
 190 struct CDLine *FirstCDLine = NULL;        /*  First catalog description line  */
 191 struct CatalogChunk *FirstChunk = NULL;   /*  List of catalog chunks          */
 192
 193 char *BaseName   = "";              /*  Basename of catalog description */
 194 char *Language   = "english";       /*  Language of catalog description */
 195 int  CatVersion  = 0;               /*  Version of catalog to be opened */
 196 int  LengthBytes = 0;               /*  Number of bytes to preceed a    */
 197                                     /*  created string and containing   */
 198                                     /*  its length.                     */
 199 char *CatLanguage      = NULL;      /*  Language of catalog translation */
 200 char *CatVersionString = NULL;      /*  version string of catalog       */
 201                                     /*  translation (## version)        */
 202 char *CatRcsId = NULL;              /*  rcs ID of catalog translation   */
 203                                     /*  (## rcsid)                      */
 204 char *CatName = NULL;               /*  name of catalog translation     */
 205 int  CodeSet = 0;                   /*  Codeset of catalog translation  */
 206 int  NumStrings = 0;                /*  Number of catalog strings       */
 207 int  LongStrings = TRUE;            /*  Generate long or short strings  */
 208
 209 char *ScanFile;                     /*  File currently scanned          */
 210 int  ScanLine;                      /*  Line currently scanned          */
 211
 212 int  GlobalReturnCode = 0;          /*  Will be 5, if warnings appear    */
 213 int  WarnCTGaps = FALSE;            /*  Warn missing symbols in CT       */
 214                                     /*  file.                            */
 215 int  NoOptim = FALSE;               /*  Put string into catalog even     */
 216                                     /*  if translation is equal to       */
 217                                     /*  description.                     */
 218 int  Fill    = FALSE;               /*  It translation of given string   */
 219                                     /*  is missing or it's empty, write  */
 220                                     /*  string descriptor from #?.cd     */
 221                                     /*  file instead.                    */
 222 int  DoExpunge = FALSE;             /*  If TRUE FlexCat will do AVAIL    */
 223                                     /*  FLUSH alike after catalog save   */
 224 int  NoBeep = FALSE;                /*  if TRUE, FlexCat won't call      */
 225                                     /*  DisplayBeep() any longer         */
 226 int  Quiet   = FALSE;               /*  Forces FlexCat to shut up        */
 227
 228 int  NumberOfWarnings = 0;          /* We count warnings to be smart     */
 229                                     /* and not to do Beep bombing, but   */
 230                                     /* call DisplayBeep() only once      */
 231 int  CT_Scanned = FALSE;            /* If TRUE, and we are going to      */
 232                                     /* write new #?.ct file, then user   */
 233                                     /* surely updates own #?.ct file     */
 234                                     /* so we should write ***NEW***      */
 235                                     /* whenever necessary.               */
 236 int  LANGToLower = TRUE;            /* Shall we do ToLower() on lang's   */
 237                                     /* name? Some #?.language seems to   */
 238                                     /* be broken, so we allow workaround */
 239 int  NoBufferedIO = FALSE;          /* Shall we do buffered IO           */
 240 int  buffer_size = 2048;            /* Size of the IO buffer             */
 241 int  Modified = FALSE;              /* Shall we write the catalog ONLY   */
 242                                     /* if #?.catalog is younger than     */
 243                                     /* #?.c(d|t) files?                  */
 244
 245 #define MAX_NEW_STR_LEN 25
 246 char Msg_New[MAX_NEW_STR_LEN]    = "***NEW***";
 247                                     /*  new strings in updated #?.ct    */
 248
 249 int  CopyNEWs = FALSE;
 250 char Old_Msg_New[MAX_NEW_STR_LEN] = "; ***NEW***";
 251
 252                                     /*  old newstring (above) used in old   */
 253                                     /* CT file. Now we look if it's present */
 254                                     /* and copy it into new CT if user does */
 255                                     /* upgrade (flexcat CD CT newctfile CT  */
 256
 257 int  NoSpace = FALSE;               /* do want to strip the space usually  */
 258                                     /* placed between ';' and original     */
 259                                     /* string?                             */
 260
 261
 262 char VersTag[] = VERSTAG;
 263 char VString[] = VSTRING " by Jochen Wiedmann and Marcin Orlowski";
 264 char EString[] = "E-mail: carlos@amiga.com.pl  WWW: http://amiga.com.pl/flexcat/";
 265 //|
 266
 267 /// FUNC: ReadPrefs
 268 #if defined(__amigados)
 269
 270 char ReadPrefs(void)
 271 {
 272 enum{ SDDIR,
 273       MSG_NEW,
 274       WARNCTGAPS,
 275       NOOPTIM,
 276       FILL,
 277       FLUSH,
 278       NOBEEP,
 279       QUIET,
 280       NOLANGTOLOWER,
 281       NOBUFFEREDIO,
 282       MODIFIED,
 283       COPYMSGNEW,
 284       OLDMSGNEW,
 285       NOSPACE,
 286
 287       ARGS_COUNT
 288     };
 289
 290 char   template[] = "SDDIR/K,MSG_NEW/K,WARNCTGAPS/S,NOOPTIM/S,FILL/S,FLUSH/S,NOBEEP/S,QUIET/S,NOLANGTOLOWER/S,NOBUFFEREDIO/S,MODIFIED/S,COPYMSGNEW/S,OLDMSGNEW/K,NOSPACE/S";
 291 LONG   Results[ARGS_COUNT] = {0};
 292 char   result = FALSE;
 293 char   *prefs;
 294 struct RDArgs *rda;
 295 struct RDArgs *rdargs;
 296
 297   if(prefs = getenv(FLEXCAT_PREFS))
 298     {
 299     prefs = realloc(prefs, strlen(prefs)+1);
 300     strcat(prefs, "\n");
 301
 302     if(rda = AllocDosObject(DOS_RDARGS, TAG_DONE))
 303        {
 304        rda->RDA_Source.CS_Buffer = prefs;
 305        rda->RDA_Source.CS_Length = strlen(prefs);
 306        rda->RDA_Source.CS_CurChr = 0;
 307        rda->RDA_Flags |= RDAF_NOPROMPT;
 308
 309        if(rdargs = ReadArgs(template, Results, rda))
 310          {
 311          if(Results[SDDIR])
 312            strncpy(prefs_sddir, (char *)Results[SDDIR], MAXPATHLEN);
 313
 314          if(Results[MSG_NEW])
 315            strncpy(Msg_New, (char *)Results[MSG_NEW], MAX_NEW_STR_LEN);
 316
 317          WarnCTGaps   = Results[WARNCTGAPS];
 318          NoOptim      = Results[NOOPTIM];
 319          Fill         = Results[FILL];
 320          DoExpunge    = Results[FLUSH];
 321          NoBeep       = Results[NOBEEP];
 322          Quiet        = Results[QUIET];
 323          LANGToLower  = Results[NOLANGTOLOWER];
 324          Modified     = Results[MODIFIED];
 325          NoBufferedIO = Results[NOBUFFEREDIO];
 326          CopyNEWs     = Results[COPYMSGNEW];
 327          NoSpace      = Results[NOSPACE];
 328          if(Results[OLDMSGNEW])
 329            sprintf(Old_Msg_New, "; %s", (char *)Results[OLDMSGNEW]);
 330
 331          FreeArgs(rdargs);
 332
 333          result = TRUE;
 334          }
 335        else
 336          {
 337          fputs((char *)msgPrefsError, stderr);
 338          fputs((char *)template, stderr);
 339          fputs((char *)"\n", stderr);
 340          DisplayBeep(NULL);
 341          }
 342
 343        FreeDosObject(DOS_RDARGS, rda);
 344        }
 345      else
 346        {
 347        fputs("Error processing prefs.\nCan't AllocDosObject()\n", stderr);
 348        }
 349
 350     free(prefs);
 351     }
 352
 353   return(result);
 354 }
 355
 356 #endif
 357 //|
 358
 359 /// FUNC: MyExit
 360 void MyExit (int Code)
 361 {
 362
 363 #if defined(__amigados)
 364
 365   if(((NumberOfWarnings > 0) ||(Code !=0)) && (!NoBeep))
 366      DisplayBeep(NULL);
 367
 368 #endif
 369
 370
 371 #if defined(_DCC)
 372   //STATIC __autoexit VOID _STDCloseFlexCatCatalog(VOID)
 373 #elif defined(__SASC)
 374   //VOID _STDCloseFlexCatCatalog(VOID)
 375 #elif defined(__GNUC__)
 376   //STATIC VOID _STDCloseFlexCatCatalog(VOID)
 377 #elif defined(__INTEL_COMPILER)
 378   //STATIC VOID _STDCloseFlexCatCatalog(VOID)
 379 #else
 380   CloseFlexCatCatalog();      /* we need to close something... */
 381 #endif
 382
 383
 384     exit(Code);
 385 }
 386 //|
 387
 388 /// FUNC: stricmp
 389
 390 // quick stricmp
 391
 392 #if !defined(__amigados) && !defined(__CYGWIN32__)
 393 #    define stricmp strcasecmp
 394 #endif
 395
 396 #if 0
 397 int stricmp( const char *str1, const char *str2 )
 398 {
 399 int i;
 400
 401     for(i = 0;; i++)
 402        {
 403        int a = tolower( (int)*str1 );
 404        int b = tolower( (int)*str2 );
 405
 406        if( !a || !b )
 407            break;
 408
 409        if( a != b )
 410            return( 1 );
 411
 412        str1++;
 413        str2++;
 414        }
 415
 416     return( 0 );
 417 }
 418 #endif
 419
 420 //|
 421 /// FUNC: strnicmp
 422
 423 // quick strnicmp
 424
 425 #if !defined(__amigados) && !defined(__CYGWIN32__)
 426 int strnicmp( const char *str1, const char *str2, size_t len )
 427 {
 428 size_t i;
 429
 430     for(i = 0; i < len; i++)
 431        {
 432        int a = tolower( (int)*str1 );
 433        int b = tolower( (int)*str2 );
 434
 435        if( !a || !b )
 436            return( 1 );
 437
 438        if( a != b )
 439            return( 1 );
 440
 441        str1++;
 442        str2++;
 443        }
 444
 445     return( 0 );
 446 }
 447 #endif
 448
 449 //|
 450
 451 /// FUNC: Swappers...
 452
 453
 454 unsigned short (*SwapWord)(unsigned short r) = NULL;
 455 unsigned long  (*SwapLong)(unsigned long r)  = NULL;
 456
 457
 458 unsigned short SwapWord21(unsigned short r)
 459 {
 460     return (unsigned short)((r>>8) + (r<<8));
 461 }
 462 unsigned short SwapWord12(unsigned short r)
 463 {
 464     return r;
 465 }
 466 unsigned long SwapLong4321(unsigned long r)
 467 {
 468     return  ((r>>24) & 0xFF) + (r<<24) + ((r>>8) & 0xFF00) + ((r<<8) & 0xFF0000);
 469 }
 470 unsigned long SwapLong1234(unsigned long r)
 471 {
 472     return r;
 473 }
 474
 475 //|
 476 /// FUNC: SwapChoose
 477 int SwapChoose(void)
 478 {
 479 unsigned short w;
 480 unsigned int d;
 481
 482   strncpy((char *)&w, "\1\2", 2);
 483   strncpy((char *)&d, "\1\2\3\4", 4);
 484
 485   if (w == 0x0201)
 486     SwapWord = SwapWord21;
 487   else if (w == 0x0102)
 488     SwapWord = SwapWord12;
 489   else
 490     return 0;
 491
 492   if (d == 0x04030201)
 493     SwapLong = SwapLong4321;
 494   else if (d == 0x01020304)
 495     SwapLong = SwapLong1234;
 496   else
 497     return 0;
 498
 499   return 1;
 500 }
 501 //|
 502
 503 /// FUNC: ShowError
 504
 505 /*
 506     This shows an error message and terminates
 507 */
 508 void ShowError(const char *msg, ...)
 509 {
 510   va_list ptr;
 511   va_start(ptr, msg);
 512
 513 //  if(!Quiet)
 514     {
 515     vfprintf(stderr, msg, ptr);
 516     putc('\n', stderr);
 517     }
 518
 519   va_end(ptr);
 520 #if defined(__amigados)
 521   NumberOfWarnings++;
 522 #endif
 523
 524   MyExit(10);
 525 }
 526 //|
 527 /// FUNC: MemError
 528
 529 /*
 530     This shows the message: Memory error.
 531 */
 532 void MemError(void)
 533
 534 {
 535   ShowError(msgMemoryError, NULL);
 536 }
 537 //|
 538 /// FUNC: ShowWarn
 539
 540 /*
 541     This shows a warning
 542 */
 543 void ShowWarn(const char *msg, ...)
 544
 545 { va_list ptr;
 546   va_start(ptr, msg);
 547
 548   if(!Quiet)
 549     {
 550     fprintf(stderr, (char *) msgWarning, ScanFile, ScanLine);
 551 #warning the following line produces segfault on x86_64
 552     vfprintf(stderr, msg, ptr);
 553     putc('\n', stderr);
 554     }
 555   va_end(ptr);
 556
 557   NumberOfWarnings++;
 558   GlobalReturnCode = 5;
 559 }
 560 //|
 561 /// FUNC: AllocString
 562
 563 /*
 564     This allocates a string
 565 */
 566 char *AllocString(const char *str)
 567
 568 { char *ptr;
 569
 570   if (!(ptr = malloc(strlen(str)+1)))
 571   { MemError();
 572   }
 573   strcpy(ptr, str);
 574   return(ptr);
 575 }
 576 //|
 577 /// FUNC: Add catalog chunk
 578
 579 /*
 580     This adds a new catalog chunk to the list of catalog
 581     chunks.
 582 */
 583 char *AddCatalogChunk(char *ID, const char *string)
 584 {
 585   struct CatalogChunk *cc, **ccptr;
 586
 587   if (!(cc = malloc(sizeof(*cc))))
 588   { MemError();
 589   }
 590   cc->Next = NULL;
 591   cc->ID = *((ULONG *) ID);
 592   cc->ChunkStr = AllocString(string);
 593
 594   /*
 595       Put the new chunk to the end of the chunk list.
 596   */
 597   for (ccptr = &FirstChunk;  *ccptr != NULL;  ccptr = &(*ccptr)->Next)
 598   {
 599   }
 600   *ccptr = cc;
 601   return(cc->ChunkStr);
 602 }
 603 //|
 604 /// FUNC: gethex
 605 /*
 606     This translates a hex character.
 607 */
 608 int gethex(int c)
 609 {
 610   if (c >= '0'  &&  c <= '9')
 611   { return(c - '0');
 612   }
 613   else if (c >= 'a'  &&  c <= 'f')
 614   { return(c - 'a' + 10);
 615   }
 616   else if (c >= 'A'  &&  c <= 'F')
 617   { return(c - 'A' + 10);
 618   }
 619   ShowWarn(msgExpectedHex);
 620   return(0);
 621 }
 622 //|
 623 /// FUNC: getoctal
 624
 625 /*
 626     This translates an octal digit.
 627 */
 628 int getoctal(int c)
 629 {
 630
 631   if (c >= '0'  &&  c <= '7')
 632     {
 633     return(c - '0');
 634     }
 635
 636   ShowWarn(msgExpectedOctal);
 637   return(0);
 638
 639 }
 640 //|
 641 /// FUNC: ReadLine
 642
 643 /*
 644     Reading a line is somewhat complicated in order to allow lines of any
 645     length.
 646
 647     Inputs: fp           - the file, where the input comes from
 648             AllowComment - TRUE, if a leading semicolon should force to
 649                            interpret the line as a comment line
 650 */
 651 #define BUFSIZE 4096
 652 char *ReadLine(FILE *fp, int AllowComment)
 653 {
 654
 655   char *OldLine, *NewLine = NULL;
 656   int c = '\0';
 657   int Len = 0, LineLen = 0;
 658   int FirstChar = TRUE;
 659   int BackslashSeen   = FALSE;
 660   int BackslashSeenOn = 0;     /* position the last backslash was seen on */
 661   int CommentLine = FALSE;     /* if TRUE we should ignore normally treat trailing \'s */
 662
 663   while(c != EOF)
 664     {
 665     if(Len+10 > LineLen)
 666       {
 667       OldLine = NewLine;
 668       if(!(NewLine = malloc(LineLen+BUFSIZE)))
 669         MemError();
 670
 671       strncpy(NewLine, OldLine, LineLen);
 672       if(OldLine)
 673         free(OldLine);
 674
 675       LineLen += BUFSIZE;
 676       }
 677
 678     c = getc(fp);
 679
 680     if(FirstChar)
 681       {
 682       if(c == EOF)
 683         {
 684         free(NewLine);
 685         return(NULL);
 686         }
 687
 688       if(c == ';')
 689         {
 690         CommentLine = TRUE;
 691         }
 692
 693       FirstChar = FALSE;
 694       }
 695
 696     switch(c)
 697       {
 698       case '\r':
 699         break;
 700
 701       case '\n':
 702         ++ScanLine;
 703         if(BackslashSeen)
 704           {
 705           NewLine[Len++] = c;
 706           BackslashSeen = FALSE;
 707           break;
 708           }
 709         c = EOF;
 710
 711       case EOF:
 712         break;
 713
 714                                  /*  Let's check for trailing \\ */
 715       case '\\':
 716         {
 717         if(!CommentLine)
 718           {
 719           if(BackslashSeen)
 720             {
 721             if(BackslashSeenOn == (Len-1))
 722               {
 723               BackslashSeen = FALSE;
 724               NewLine[Len++] = c;
 725               break;
 726               }
 727             }
 728
 729           BackslashSeen = TRUE;
 730           BackslashSeenOn = Len;
 731           }
 732
 733         NewLine[Len++] = c;
 734         break;
 735         }
 736
 737
 738       default:
 739         BackslashSeen = FALSE;
 740         NewLine[Len++] = c;
 741       }
 742     }
 743
 744   NewLine[Len] = '\0';
 745
 746   return(NewLine);
 747
 748 }
 749 //|
 750 /// FUNC: OverSpace
 751
 752 /*
 753     This removes trailing blanks.
 754 */
 755 void OverSpace(char **strptr)
 756
 757 { int c;
 758
 759   while ((c = **strptr) == ' '  ||  c == '\t')
 760   { (*strptr)++;
 761   }
 762 }
 763 //|
 764
 765 /// FUNC: Expunge
 766
 767 void Expunge(void)
 768 {
 769 #if defined(__amigados)
 770
 771
 772   if(DoExpunge)
 773     {
 774 #ifdef __EXPUNGE_ALL__
 775     APTR Memory;
 776
 777     if(Memory = AllocMem(-1, NULL))
 778        FreeMem(Memory, -1);                // just in case ;-)
 779 #else
 780
 781 #pragma libcall LocaleBase localeExpunge 12 00
 782 VOID localeExpunge(VOID);
 783
 784     struct Library    *LocaleBase;
 785
 786     if(LocaleBase = OpenLibrary("locale.library", 0))
 787        {
 788        localeExpunge();
 789        CloseLibrary(LocaleBase);
 790        }
 791
 792 #endif
 793     }
 794 #endif
 795
 796 }
 797
 798 //|
 799
 800 /// FUNC: ReadChar
 801
 802 /*
 803     ReadChar scans an input line translating the backslash characters.
 804
 805     Inputs: char *  - a pointer to a stringpointer; the latter points to the
 806                       next character to be read and points behind the read
 807                       bytes after executing ReadChar
 808             dest    - a pointer to a buffer, where the read bytes should be
 809                       stored
 810
 811     Result: number of bytes that are written to dest (between 0 and 2)
 812 */
 813 int ReadChar(char **strptr, char *dest)
 814 {
 815   char c;
 816   int i;
 817
 818   switch(c = *((*strptr)++))
 819     {
 820     case '\\':
 821
 822       switch(c = tolower((int) *((*strptr)++)))
 823         {
 824         case '\n':
 825           return(0);
 826         case 'b':
 827           *dest = '\b';
 828           break;
 829         case 'c':
 830           *dest = '\233';
 831           break;
 832         case 'e':
 833           *dest = '\033';
 834           break;
 835         case 'f':
 836           *dest = '\f';
 837           break;
 838         case 'g':
 839           *dest = '\007';
 840           break;
 841         case 'n':
 842           *dest = '\n';
 843           break;
 844         case 'r':
 845           *dest = '\r';
 846           break;
 847         case 't':
 848           *dest = '\t';
 849           break;
 850         case 'v':
 851           *dest = '\013';
 852           break;
 853         case 'x':
 854           *dest = gethex((int) **strptr);
 855           (*strptr)++;
 856           if (((c = **strptr) >= '0'  &&  c <= '9')  ||
 857               (c >= 'a'  &&  c <= 'f')  ||  (c >= 'A'  &&  c <= 'F'))
 858           { *dest = (*dest << 4) + gethex((int) c);
 859             (*strptr)++;
 860           }
 861           break;
 862         case '0':
 863         case '1':
 864         case '2':
 865         case '3':
 866         case '4':
 867         case '5':
 868         case '6':
 869         case '7':
 870
 871           *dest = getoctal((int)c);
 872
 873           for(i = 0;  i < 2;  i++)
 874             {
 875             if((c = **strptr) >= '0'  &&  c <= '7')
 876               {
 877               *dest = (*dest << 3) + getoctal((int) c);
 878               (*strptr)++;
 879               }
 880             }
 881           break;
 882         case ')':
 883         case '\\':
 884           *(dest++) = '\\';
 885           *dest = c;
 886           return(2);
 887         default:
 888           *dest = c;
 889       }
 890       break;
 891
 892     default:
 893       *dest = c;
 894   }
 895   return(1);
 896 }
 897 //|
 898 /// FUNC: ScanCDFile
 899
 900 /*
 901     This scans the catalog description file.
 902
 903     Inputs: cdfile  - name of the catalog description file
 904
 905     Result: TRUE, if successful, FALSE otherwise
 906 */
 907 int ScanCDFile(char *cdfile)
 908 {
 909   FILE *fp;
 910   struct CDLine *cdline, **cdptr = &FirstCDLine;
 911   struct CatString *cs, **csptr = &FirstCatString;
 912   char *line, *newline;
 913   char *ptr;
 914   int NextID = 0, len;
 915   int Result = TRUE;
 916
 917   ScanFile = cdfile;
 918   ScanLine = 0;
 919
 920   if(!(fp = fopen(cdfile, "r")))
 921     {
 922     ShowError(msgNoCatalogDescription, cdfile);
 923     }
 924
 925   if(!NoBufferedIO)
 926     setvbuf(fp, NULL, _IOFBF, buffer_size);
 927
 928   /*
 929       Get the basename
 930   */
 931   if ((ptr = strchr(cdfile, ':')))
 932   { cdfile = ptr+1;
 933   }
 934   if ((ptr = strrchr(cdfile, '/')))
 935   { cdfile = ptr+1;
 936   }
 937   if ((ptr = strrchr(cdfile, '.')))
 938   { len = ptr-cdfile;
 939   }
 940   else
 941   { len = strlen(cdfile);
 942   }
 943   if (!(BaseName = malloc(len+1)))
 944   { MemError();
 945   }
 946   strncpy(BaseName, cdfile, len);
 947   BaseName[len] = '\0';
 948
 949   while(!feof(fp)  &&  (line = newline = ReadLine(fp, TRUE)))
 950   {
 951     if(!(cdline = malloc(sizeof(*cdline))))
 952       {
 953       MemError();
 954       }
 955
 956     *cdptr = cdline;
 957     cdptr = &cdline->Next;
 958     cdline->Next = NULL;
 959     cdline->Line = line = AllocString(newline);
 960     free(newline);
 961
 962     if (*line == ';')
 963       {
 964       continue;
 965       }
 966
 967     if(*line == '#')
 968       {
 969       int CheckExtra = TRUE;
 970
 971       if (strnicmp(line+1, "language", 8) == 0)
 972         {
 973         char *ptr;
 974
 975         line += 9;
 976         OverSpace(&line);
 977         Language = AllocString(line);
 978
 979         if(LANGToLower)
 980            {
 981            for (ptr = Language;  *ptr;  ptr++)
 982              {
 983              *ptr = tolower((int) *ptr);
 984              }
 985            CheckExtra = FALSE;
 986            }
 987
 988         }
 989       else
 990         if(strnicmp(line+1, "version", 7) == 0)
 991           {
 992           CatVersion = strtol(line+8, &line, 0);
 993           }
 994         else
 995           {
 996           if(strnicmp(line+1, "basename", 8) == 0)
 997            {
 998            line += 9;
 999            OverSpace(&line);
1000            free(BaseName);
1001            BaseName = AllocString(line);
1002            CheckExtra = FALSE;
1003            }
1004           else
1005            {
1006            ShowWarn(msgUnknownCDCommand);
1007            Result = FALSE;
1008            CheckExtra = FALSE;
1009            }
1010          }
1011
1012       if(CheckExtra)
1013         {
1014         OverSpace(&line);
1015           if(*line)
1016             {
1017             ShowWarn(msgExtraCharacters);
1018             Result = FALSE;
1019             }
1020         }
1021       }
1022     else
1023       {
1024       char *idstr;
1025
1026       if(*line == ' '  ||  *line == '\t')
1027         {
1028         ShowWarn(msgUnexpectedBlanks);
1029         Result = FALSE;
1030         OverSpace(&line);
1031         }
1032
1033       idstr = line;
1034       while ((*line >= 'a'  &&  *line <= 'z')  ||
1035              (*line >= 'A'  &&  *line <= 'Z')  ||
1036              (*line >= '0'  &&  *line <= '9')  ||
1037              *line == '_')
1038         {
1039         ++line;
1040         }
1041
1042       if(idstr == line)
1043         {
1044         ShowWarn(msgNoIdentifier);
1045         Result = FALSE;
1046         }
1047       else
1048         {
1049         int found;
1050
1051         if(!(cs = malloc(sizeof(*cs))))
1052           {
1053           MemError();
1054           }
1055
1056         do
1057           {
1058           struct CatString *scs;
1059
1060           found = TRUE;
1061           for(scs = FirstCatString;  scs != NULL;  scs = scs->Next)
1062             {
1063             if(scs->ID == NextID)
1064               {
1065               found = FALSE;
1066               ++NextID;
1067               break;
1068               }
1069             }
1070           }
1071         while(!found);
1072
1073         cs->Next = NULL;
1074         cs->ID = NextID;
1075         cs->MinLen = 0;
1076         cs->MaxLen = -1;
1077         cs->CD_Str = "";
1078         cs->CT_Str = NULL;
1079         cs->NotInCT= TRUE;
1080
1081         if(!(cs->ID_Str = malloc((line-idstr)+1)))
1082           {
1083           MemError();
1084           }
1085         strncpy(cs->ID_Str, idstr, line-idstr);
1086         cs->ID_Str[line-idstr] = '\0';
1087
1088         OverSpace(&line);
1089
1090         if(*line != '(')
1091           {
1092           ShowWarn(msgNoLeadingBracket);
1093           Result = FALSE;
1094           }
1095         else
1096           {
1097           char *oldstr;
1098           struct CatString *scs;
1099           char bytes[10];
1100           int bytesread, reallen;
1101
1102           ++line;
1103           OverSpace(&line);
1104           if(*line != '/')
1105             {
1106             if(*line == '+')
1107               {
1108               NextID = cs->ID = NextID + strtol(line, &line, 0);
1109               }
1110             else
1111               {
1112               cs->ID = NextID = strtol(line, &line, 0);
1113               }
1114
1115             OverSpace(&line);
1116             }
1117
1118           for(scs = FirstCatString;  scs != NULL;  scs = scs->Next)
1119           { if (scs->ID == cs->ID)
1120             { ShowWarn(msgDoubleID);
1121               Result = FALSE;
1122             }
1123             if (strcmp(cs->ID_Str, scs->ID_Str)  ==  0)
1124             { ShowWarn(msgDoubleIdentifier);
1125               Result = FALSE;
1126             }
1127           }
1128
1129           if (*line != '/')
1130           { ShowWarn(msgNoMinLen);
1131             Result = FALSE;
1132           }
1133           else
1134           { ++line;
1135             OverSpace(&line);
1136             if (*line != '/')
1137             { cs->MinLen = strtol(line, &line, 0);
1138               OverSpace(&line);
1139             }
1140             if (*line != '/')
1141             { ShowWarn(msgNoMaxLen);
1142               Result = FALSE;
1143             }
1144             else
1145             { ++line;
1146               OverSpace(&line);
1147               if (*line != ')')
1148               { cs->MaxLen = strtol(line, &line, 0);
1149                 OverSpace(&line);
1150               }
1151               if (*line != ')')
1152               { ShowWarn(msgNoTrailingBracket);
1153                 Result = FALSE;
1154               }
1155               else
1156               { ++line;
1157                 OverSpace(&line);
1158                 if (*line)
1159                 { ShowWarn(msgExtraCharacters);
1160                 }
1161               }
1162             }
1163           }
1164         if (!(newline = ReadLine(fp, FALSE)))
1165         { ShowWarn(msgNoString);
1166           Result = FALSE;
1167           cs->CD_Str = "";
1168         }
1169         else
1170         { cs->CD_Str = AllocString(newline);
1171           free(newline);
1172         }
1173
1174         /*
1175             Get stringlen
1176         */
1177         oldstr = cs->CD_Str;
1178         reallen = 0;
1179         while (*oldstr)
1180         { bytesread = ReadChar(&oldstr, bytes);
1181           if (bytesread == 2)
1182           { bytesread--;
1183           }
1184           reallen += bytesread;
1185         }
1186
1187         if (cs->MinLen > 0  &&  reallen < cs->MinLen)
1188         { ShowWarn(msgShortString);
1189         }
1190         if (cs->MaxLen > 0  &&  reallen > cs->MaxLen)
1191         { ShowWarn(msgLongString);
1192         }
1193
1194         cs->Nr = NumStrings;
1195
1196         *csptr = cs;
1197         csptr = &cs->Next;
1198         ++NumStrings;
1199         }
1200       }
1201     }
1202   }
1203   fclose(fp);
1204   return(Result);
1205 }
1206 //|
1207 /// FUNC: ScanCTFile
1208
1209 /*
1210     This scans a catalog translation file.
1211
1212     Inputs: ctfile      - name of the translation file to scan.
1213
1214     Result: TRUE, if successful, FALSE otherwise.
1215 */
1216 int ScanCTFile(char *ctfile)
1217 {
1218   FILE *fp;
1219   char *newline, *line, *idstr, *newidstr, *newstr;
1220   struct CatString *cs=NULL;
1221   int Result = TRUE;
1222
1223   ScanFile = ctfile;
1224   ScanLine = 0;
1225
1226   if (!(fp = fopen(ctfile, "r")))
1227     {
1228     ShowError(msgNoCatalogTranslation, ctfile);
1229     }
1230
1231   if(!NoBufferedIO)
1232     setvbuf(fp, NULL, _IOFBF, buffer_size);
1233
1234
1235   while (!feof(fp)  &&  (line = newline = ReadLine(fp, TRUE)))
1236     {
1237     switch(*line)
1238       {
1239       case ';':
1240         if( CopyNEWs == TRUE )
1241            {
1242            if(strnicmp( line, Old_Msg_New, strlen(Old_Msg_New) ) == 0)
1243              {
1244              cs->NotInCT = TRUE;
1245              }
1246            }
1247       break;
1248
1249       case '#':
1250 ///       looking for command;
1251         if(*(++line) != '#')
1252           {
1253           ShowWarn(msgNoCTCommand);
1254           }
1255         ++line;
1256         OverSpace(&line);
1257         if (strnicmp(line, "version", 7) == 0)
1258         { if (CatVersionString || CatRcsId || CatName)
1259           { ShowWarn(msgDoubleCTVersion);
1260           }
1261           line += 7;
1262           OverSpace(&line);
1263           CatVersionString = AllocString(line);
1264         }
1265         else if (strnicmp(line, "codeset", 7) == 0)
1266         { line += 7;
1267           CodeSet = strtol(line, &line, 0);
1268           OverSpace(&line);
1269           if (*line)
1270           { ShowWarn(msgExtraCharacters);
1271           }
1272         }
1273         else if (strnicmp(line, "language", 8) == 0)
1274         { char *ptr;
1275
1276           if (CatLanguage)
1277           { ShowWarn(msgDoubleCTLanguage);
1278           }
1279           line += 8;
1280           OverSpace(&line);
1281           CatLanguage = AddCatalogChunk("LANG", line);
1282
1283           if(LANGToLower)
1284             for (ptr = CatLanguage;  *ptr;  ptr++)
1285               *ptr = tolower((int) *ptr);
1286         }
1287         else if (strnicmp(line, "chunk", 5) == 0)
1288         { char *ID;
1289
1290           line += 5;
1291           OverSpace(&line);
1292           ID = line;
1293           line += sizeof(ULONG);
1294           OverSpace(&line);
1295
1296           AddCatalogChunk(ID, AllocString(line));
1297         }
1298         else if (strnicmp(line, "rcsid", 5) == 0)
1299         { if (CatVersionString || CatRcsId)
1300           { ShowWarn(msgDoubleCTVersion);
1301           }
1302           line += 5;
1303           OverSpace(&line);
1304           CatRcsId = AllocString(line);
1305         }
1306         else if (strnicmp(line, "name", 5) == 0)
1307         { if (CatVersionString || CatName)
1308           { ShowWarn(msgDoubleCTVersion);
1309           }
1310           line += 4;
1311           OverSpace(&line);
1312           CatName = AllocString(line);
1313         }
1314         else if (strnicmp(line+1, "lengthbytes", 11) == 0)
1315         { line += 12;
1316           if ((LengthBytes = strtol(line, &line, 0))
1317                            > sizeof(long))
1318           { ShowWarn(msgNoLengthBytes, sizeof(long));
1319             LengthBytes = sizeof(long);
1320           }
1321         }
1322         else
1323         {
1324         ShowWarn(msgUnknownCTCommand);
1325         }
1326 //|
1327         break;
1328
1329       default:
1330         if(*line == ' '  ||  *line == '\t')
1331           {
1332           ShowWarn( msgUnexpectedBlanks );
1333           OverSpace( &line );
1334           }
1335         idstr = line;
1336
1337         while ((*line >= 'a'  &&  *line <= 'z')  ||
1338                (*line >= 'A'  &&  *line <= 'Z')  ||
1339                (*line >= '0'  &&  *line <= '9')  ||
1340                *line == '_')
1341         { ++line;
1342         }
1343         if (idstr == line)
1344           {
1345           ShowWarn(msgNoIdentifier);
1346           break;
1347           }
1348
1349         if(!(newidstr = malloc(line-idstr+1)))
1350           {
1351           MemError();
1352           }
1353
1354         strncpy(newidstr, idstr, line-idstr);
1355         newidstr[line-idstr] = '\0';
1356         OverSpace(&line);
1357
1358         if(*line)
1359           {
1360           ShowWarn(msgExtraCharacters);
1361           }
1362
1363         if((newstr = ReadLine(fp, FALSE)))
1364           {
1365           for(cs = FirstCatString;  cs != NULL;  cs = cs->Next)
1366             {
1367             if(strcmp(cs->ID_Str, newidstr) == 0)
1368               {
1369               break;
1370               }
1371             }
1372           if(cs == NULL)
1373             {
1374             ShowWarn(msgUnknownIdentifier, newidstr);
1375             }
1376           else
1377             {
1378             char *oldstr;
1379             char bytes[10];
1380             int bytesread, reallen;
1381
1382             if(cs->CT_Str)
1383               {
1384               ShowWarn(msgDoubleIdentifier);
1385               Result = FALSE;
1386               free(cs->CT_Str);
1387               }
1388             cs->CT_Str = AllocString(newstr);
1389             cs->NotInCT = FALSE;
1390
1391             /*
1392                 Get stringlen
1393             */
1394             oldstr = cs->CT_Str;
1395             reallen = 0;
1396             while(*oldstr)
1397               {
1398               bytesread = ReadChar(&oldstr, bytes);
1399               if(bytesread == 2)
1400                 {
1401                 bytesread--;
1402                 }
1403               reallen += bytesread;
1404               }
1405
1406             if(cs->MinLen > 0  &&  reallen < cs->MinLen)
1407               {
1408               ShowWarn(msgShortString);
1409               }
1410             if(cs->MaxLen > 0  &&  reallen > cs->MaxLen)
1411               {
1412               ShowWarn(msgLongString);
1413               }
1414
1415
1416             // checking for trailing ellipsis...
1417
1418             if( reallen >= 3 )
1419                {
1420                long cd_len = strlen( cs->CD_Str );
1421
1422                if( cd_len >= 3 )
1423                    {
1424                    if( strcmp( &cs->CD_Str[ cd_len - 2 ], "..." ) == 0 )
1425                        if( strcmp( &cs->CT_Str[ reallen - 2 ], "..." ) != 0 )
1426                          {
1427 //                         printf("ORG: '%s'\nNEW: '%s'\n", cs->CD_Str, cs->CT_Str);
1428                          ShowWarn(msgTrailingEllipsis);
1429                          }
1430                    }
1431                }
1432
1433
1434             // checking for trailing spaces
1435
1436             if( reallen >= 1 )
1437                {
1438                long cd_len = strlen( cs->CD_Str );
1439
1440                if( cd_len >= 1 )
1441                    {
1442                    if( strcmp( &cs->CD_Str[ cd_len - 1 ], " " ) == 0 )
1443                        if( strcmp( &cs->CT_Str[ reallen - 1 ], " " ) != 0 )
1444                          ShowWarn(msgTrailingSpaces);
1445                    }
1446                }
1447
1448
1449             }
1450           free(newstr);
1451           }
1452         else
1453           {
1454           ShowWarn(msgNoString);
1455           if(cs)
1456               cs->CT_Str = "";
1457           }
1458         free(newidstr);
1459     }
1460     free(newline);
1461   }
1462
1463   fclose(fp);
1464
1465   if (WarnCTGaps)
1466   { for (cs = FirstCatString;  cs != NULL;  cs = cs->Next)
1467     { if (cs->CT_Str == NULL)
1468       { ShowWarn(msgCTGap, cs->ID_Str);
1469       }
1470     }
1471   }
1472
1473   if(Result)
1474     CT_Scanned = TRUE;
1475
1476   return(Result);
1477 }
1478 //|
1479 /// FUNC: CatPuts
1480
1481
1482 /*
1483     CatPuts prints a string to a catalog. (The string is preceded by a
1484     long integer containing its length and probably padded up to word
1485     boundary or longword boundary, depending on the argument padbytes.)
1486     The arguments countnul should be TRUE if the NUL byte at the end of
1487     the string should be counted.
1488 */
1489 int CatPuts(FILE *fp, char *str, int padbytes, int countnul)
1490 {
1491   unsigned int reallen, virtuallen, chunklen, swapped_long;
1492   int bytesread;
1493   char *oldstr;
1494   char bytes[10];
1495
1496   /*      Get Length of string.
1497   */
1498
1499   oldstr = str;
1500   reallen = 0;
1501
1502   while(*oldstr)
1503     {
1504     bytesread = ReadChar(&oldstr, bytes);
1505     if(bytesread == 2)
1506       {
1507       bytesread--;
1508       }
1509     reallen += bytesread;
1510     }
1511
1512   virtuallen = chunklen = reallen + LengthBytes;
1513   if(countnul || chunklen % padbytes == 0)
1514     {
1515     virtuallen++;
1516     }
1517
1518   swapped_long = SwapLong( virtuallen );
1519
1520   fwrite(&swapped_long, sizeof(virtuallen), 1, fp);
1521   if(LengthBytes)
1522     {
1523     fwrite(((char *) &reallen)+sizeof(reallen)-LengthBytes, LengthBytes, 1, fp);
1524     }
1525
1526   while(*str)
1527     {
1528     bytesread = ReadChar(&str, bytes);
1529     if(bytesread)
1530       {
1531       fwrite(bytes+bytesread-1, 1, 1, fp);
1532       }
1533     }
1534
1535   do
1536     {
1537     putc('\0', fp);
1538     }
1539   while(++chunklen % padbytes);
1540
1541   return((int) chunklen+4);
1542 }
1543 //|
1544 /// FUNC: PutCatalogChunk
1545
1546 /*
1547     This puts a string chunk into the catalog
1548 */
1549 int PutCatalogChunk(FILE *fp, struct CatalogChunk *cc)
1550 {
1551   fwrite(&cc->ID, sizeof(cc->ID), 1, fp);
1552   return(4 + CatPuts(fp, cc->ChunkStr, 2, TRUE));
1553 }
1554 //|
1555 /// FUNC: CalcRealLength
1556 /*
1557     This function measures the real (binary) length of source
1558     string. It correctly process 'slash chars' (\n, \000 etc),
1559     and gives the real length such source string have.
1560
1561     Inputs: source - pointer to null terminated source string
1562
1563     Result: real length
1564 */
1565
1566 int CalcRealLength(char *source)
1567 {
1568 int  count = 0;
1569 char *src = source;
1570 char bytes[10];
1571
1572   while(*src)
1573     {
1574     count += ReadChar(&src, bytes);
1575     }
1576
1577 //  printf("%ld: '%s'\n", count, source);
1578
1579   return(count);
1580
1581 }
1582 //|
1583
1584 /// FUNC: CreateCatalog
1585
1586 /*
1587     This creates a catalog.
1588 */
1589 void CreateCat(char *CatFile)
1590 {
1591   FILE *fp;
1592   int CatLen, HeadLen;
1593   struct CatString *cs;
1594   struct CatalogChunk *cc;
1595   int i;
1596
1597   if(!CatVersionString && !CatRcsId)
1598     {
1599     ShowError(msgNoCTVersion);
1600     }
1601
1602   if(!CatLanguage)
1603     {
1604     ShowError(msgNoCTLanguage);
1605     }
1606
1607   if(strlen(CatLanguage) == 0)
1608     {
1609     ShowError(msgNoCTLanguage);
1610     }
1611
1612   if(!(fp = fopen(CatFile, "w")))
1613     {
1614     ShowError(msgNoCatalog, CatFile);
1615     }
1616
1617   if(!NoBufferedIO)
1618     setvbuf(fp, NULL, _IOFBF, buffer_size);
1619
1620
1621   fputs("FORM0000CTLG", fp);
1622   CatLen = 4;
1623
1624   if(CatVersionString)
1625     {
1626     struct CatalogChunk cc;
1627     char *verStr = NULL;
1628
1629     cc.ID = MAKE_ID('F','V','E','R');
1630
1631     if( strstr(CatVersionString, "$TODAY") )
1632        {
1633
1634        if(verStr = malloc(strlen(CatVersionString)+128))
1635            {
1636            char *found = strstr(CatVersionString, "$TODAY");
1637            char dateStr[10];
1638
1639            long tim;
1640            struct tm *t;
1641
1642            time(&tim);
1643            t = gmtime(&tim);
1644
1645            *found = 0;
1646            strftime(dateStr, sizeof(dateStr), "%d.%m.%y", t);
1647
1648            sprintf(verStr, "%s%s%s", CatVersionString, dateStr, found+strlen("$TODAY"));
1649            cc.ChunkStr = verStr;
1650            }
1651        else
1652           MemError();
1653
1654        }
1655     else
1656        {
1657        cc.ChunkStr = CatVersionString;
1658        }
1659
1660     cc.ID = SwapLong( cc.ID );
1661     CatLen += PutCatalogChunk(fp, &cc);
1662
1663     if( verStr )
1664        free(verStr);
1665     }
1666   else
1667     {
1668     struct CatalogChunk cc;
1669     char* verStr;
1670     int year = 0, month = 0, day = 0;
1671     int version = 0, revision = 0;
1672     char* name = NULL;
1673     char* ptr;
1674
1675     if(!CatRcsId)
1676       {
1677       ShowError(msgNoCTVersion);
1678       }
1679     else
1680       {
1681       if(!(ptr = strstr(CatRcsId, "$Date:"))
1682           || sscanf(ptr+6, " %d/%d/%d", &year, &month, &day) != 3
1683           || !(ptr = strstr(CatRcsId, "$Revision:"))
1684           || sscanf(ptr+10, " %d.%d", &version, &revision) != 2)
1685       {
1686       ShowError(msgWrongRcsId);
1687       }
1688       if ((ptr = strstr(CatRcsId, "$Id:")))
1689       { int len = 0;
1690         char* found;
1691
1692         ptr += 4;
1693         OverSpace(&ptr);
1694         found = ptr;
1695
1696         while(*ptr  &&  *ptr != '$'  &&  *ptr != ' '  &&  *ptr != '\t')
1697           {
1698           ++len;
1699           ++ptr;
1700           }
1701         if(!(name = malloc(len+1)))
1702           {
1703           MemError();
1704          }
1705         strncpy(name, found, len);
1706         name[len] = '\0';
1707       }
1708     }
1709     if (CatName)
1710     { name = CatName;
1711     }
1712     else if (!name)
1713       {
1714       ShowError(msgNoCTVersion);
1715       name = "";
1716       }
1717     if (!(verStr = malloc(strlen(name) + 256)))
1718       {
1719       MemError();
1720       }
1721
1722     sprintf(verStr, "$V");
1723     sprintf(verStr, "ER: %s %ld.%ld (%ld.%ld.%ld)", name, version, revision, day, month, year);
1724
1725     cc.ID = MAKE_ID('F','V','E','R');
1726     cc.ID = SwapLong( cc.ID );
1727     cc.ChunkStr = verStr;
1728     CatLen += PutCatalogChunk(fp, &cc);
1729   }
1730
1731
1732   for (cc = FirstChunk;  cc != NULL;  cc = cc->Next)
1733     {
1734     CatLen += PutCatalogChunk(fp, cc);
1735     }
1736
1737   i = 32;
1738   fputs("CSET", fp);
1739
1740   {
1741   int i_tmp = SwapLong( i );
1742
1743   fwrite(&i_tmp, sizeof(i_tmp), 1, fp);
1744   }
1745
1746   while(i-- > 0)
1747     {
1748     putc('\0', fp);
1749     }
1750
1751   CatLen += 48;
1752   fprintf(fp, "STRS0000");
1753   HeadLen = CatLen;
1754
1755
1756   for(cs = FirstCatString;  cs != NULL;  cs = cs->Next)
1757     {
1758     int FillUsed = FALSE;
1759     int tmp_ID = SwapLong( cs->ID );
1760
1761     if(Fill)
1762       {
1763
1764       if(cs->CT_Str)
1765         {
1766         if(strlen(cs->CT_Str) == 0)
1767           {
1768           fwrite(&tmp_ID, sizeof(tmp_ID), 1, fp);
1769           CatLen += 4 + CatPuts(fp, cs->CD_Str, 4, FALSE);
1770           FillUsed = TRUE;
1771           }
1772         }
1773       else
1774         {
1775         fwrite(&tmp_ID, sizeof(cs->ID), 1, fp);
1776         CatLen += 4 + CatPuts(fp, cs->CD_Str, 4, FALSE);
1777         FillUsed = TRUE;
1778         }
1779       }
1780
1781     if((!FillUsed) && cs->CT_Str  &&  (NoOptim ? TRUE : strcmp(cs->CT_Str, cs->CD_Str)))
1782       {
1783       fwrite(&tmp_ID, sizeof( tmp_ID ), 1, fp);
1784       CatLen += 4 + CatPuts(fp, cs->CT_Str, 4, FALSE);
1785       }
1786     }
1787
1788
1789   {
1790   int tmp_Len;
1791
1792   fseek(fp, 4, SEEK_SET);
1793
1794   tmp_Len = SwapLong( CatLen );
1795   fwrite(&tmp_Len, sizeof(tmp_Len), 1, fp);
1796   fseek(fp, HeadLen-4, SEEK_CUR);
1797
1798   CatLen -= HeadLen;
1799   tmp_Len = SwapLong( CatLen );
1800   fwrite(&tmp_Len, sizeof(CatLen), 1, fp);
1801   }
1802
1803   fclose(fp);
1804
1805   Expunge();
1806
1807 }
1808 //|
1809 /// FUNC: CreateCTFile
1810
1811 /*
1812     This creates a new catalog translation file.
1813 */
1814 void CreateCTFile(char *NewCTFile)
1815 {
1816   FILE   *fp;
1817   struct CDLine *cd;
1818   struct CatString *cs;
1819   struct CatalogChunk *cc;
1820   char   *line;
1821
1822   if(!CatVersionString && !CatRcsId)
1823     {
1824     ScanLine = 1;
1825     ShowWarn(msgNoCTVersion);
1826     }
1827
1828   if(!(fp = fopen(NewCTFile, "w")))
1829     {
1830     ShowError(msgNoNewCTFile);
1831     }
1832
1833
1834   if(!NoBufferedIO)
1835     setvbuf(fp, NULL, _IOFBF, buffer_size);
1836
1837
1838   if(CatRcsId)
1839     {
1840     fprintf(fp, "## rcsid %s\n",
1841           CatRcsId ? CatRcsId : "");
1842     if(CatName)
1843        fprintf(fp, "## name %s\n", CatName);
1844     }
1845   else
1846     {
1847     if(CatVersionString)
1848       fprintf(fp, "## version %s\n", CatVersionString);
1849     else
1850       {
1851       fprintf(fp, "## version $V");
1852       fprintf(fp, "%c", 50+19);  // E
1853       fprintf(fp, "R: XX.catalog XX.XX ($TODAY)\n");
1854       }
1855     }
1856
1857
1858   {
1859   char *lang = NULL;
1860
1861   if(CatLanguage == NULL)
1862     if(lang = getenv("ENV:language"))
1863       {
1864       int i;
1865
1866       for(i=0;i<strlen(lang); i++)
1867         if(lang[i] == '\n')
1868           {
1869           lang[i] = 0;
1870           break;
1871           }
1872
1873       CatLanguage = lang;
1874       }
1875
1876   fprintf(fp, "## language %s\n## codeset %d\n;\n",
1877        CatLanguage ? CatLanguage : "X", CodeSet);
1878
1879   if(lang)
1880     {
1881     free(lang);
1882     CatLanguage = NULL;
1883     }
1884   }
1885
1886
1887
1888   for (cc = FirstChunk;  cc != NULL;  cc = cc->Next)
1889     {
1890     if (cc->ChunkStr != CatLanguage)
1891       {
1892       fprintf(fp, "## chunk ");
1893       fwrite((char *) &cc->ID, sizeof(cc->ID), 1, fp);
1894       fprintf(fp, " %s\n", cc->ChunkStr);
1895       }
1896     }
1897
1898   for(cd = FirstCDLine, cs = FirstCatString;
1899       cd != NULL;
1900       cd = cd->Next)
1901      {
1902      switch(*cd->Line)
1903        {
1904        case '#':
1905           break;
1906
1907        case ';':
1908           fprintf(fp, "%s\n", cd->Line);
1909           break;
1910
1911        default:
1912           if(cs)
1913             {
1914 /*
1915             fprintf(fp, "%s\n", cs->ID_Str);
1916             fprintf(fp, "%s\n", cs->CT_Str ? cs->CT_Str : "");
1917             putc(';', fp);
1918             putc(' ', fp);
1919 */
1920             fprintf(fp, "%s\n%s\n;", cs->ID_Str, cs->CT_Str ? cs->CT_Str : "");
1921
1922             if( !NoSpace )
1923                 putc(' ', fp);
1924
1925
1926
1927             for (line = cs->CD_Str;  *line;  ++line)
1928               {
1929               putc((int) *line, fp);
1930               if(*line == '\n')
1931                 {
1932                 putc(';', fp);
1933                 if( !NoSpace )
1934                    putc(' ', fp);
1935                 }
1936               }
1937             putc('\n', fp);
1938
1939             if(cs->NotInCT && CT_Scanned)
1940               fprintf(fp, ";\n; %s\n", Msg_New);
1941
1942             cs = cs->Next;
1943             }
1944        }
1945      }
1946
1947   fclose(fp);
1948 }
1949 //|
1950
1951 /// FUNC: InitCatStringOutput
1952
1953 /*
1954     InitCatStringOutput gets called before writing a catalog string as
1955     source.
1956
1957     Inputs: fp   = file pointer to the output file
1958             type = one of   TYPE_C          create C strings
1959                             TYPE_ASSEMBLER  create Assembler strings
1960                             TYPE_OBERON     create Oberon strings
1961                             TYPE_E          create E strings
1962                             TYPE_NONE       create simple strings
1963 */
1964 int  OutputMode = OutputMode_None;
1965 int  OutputType = TYPE_C;
1966 FILE *OutputFile;
1967 int  OutputLen;
1968
1969 void InitCatStringOutput(FILE *fp)
1970 {
1971   OutputLen = 0;
1972   OutputFile = fp;
1973   OutputMode = OutputMode_None;
1974   switch(OutputType)
1975   { case TYPE_C:
1976     case TYPE_OBERON:
1977       putc('\"', fp);
1978       OutputMode = OutputMode_Ascii;
1979       break;
1980     case TYPE_E:
1981       putc('\'', fp);
1982     case TYPE_ASSEMBLER:
1983     case TYPE_NONE:
1984       break;
1985   }
1986 }
1987 //|
1988 /// FUNC: SeparateCatStringOutput
1989
1990 /*
1991     SeparateCatStringOutput gets called to split a catalog into separate
1992     lines.
1993 */
1994 void SeparateCatStringOutput(void)
1995 {
1996     switch(OutputType)
1997     { case TYPE_C:
1998         if (!LongStrings)
1999         { fputs("\"\\\n\t\"", OutputFile);
2000         }
2001         break;
2002       case TYPE_E:
2003         if (!LongStrings)
2004         { fputs("\' +\n\t\'", OutputFile);
2005         }
2006         break;
2007       case TYPE_OBERON:
2008         if (!LongStrings)
2009         { fputs("\"\n\t\"", OutputFile);
2010         }
2011         break;
2012       case TYPE_ASSEMBLER:
2013         if (!LongStrings)
2014         { if (OutputMode == OutputMode_Ascii)
2015           { putc('\'', OutputFile);
2016           }
2017           putc('\n', OutputFile);
2018           OutputMode = OutputMode_None;
2019         }
2020         break;
2021       case TYPE_NONE:
2022         break;
2023     }
2024 }
2025 //|
2026 /// FUNC: WriteBinChar
2027
2028 /*
2029     WriteBinChar writes one binary character into the source file
2030 */
2031 void WriteBinChar(int c)
2032 {
2033
2034   switch(OutputType)
2035   { case TYPE_C:
2036     case TYPE_E:
2037     case TYPE_OBERON:
2038       switch(c)
2039       { case '\b':
2040           fputs("\\b", OutputFile);
2041           break;
2042         case '\n':
2043           fputs("\\n", OutputFile);
2044           break;
2045         case '\r':
2046           fputs("\\r", OutputFile);
2047           break;
2048         case '\t':
2049           fputs("\\t", OutputFile);
2050           break;
2051         case '\f':
2052           fputs("\\f", OutputFile);
2053           break;
2054         case '\0':
2055           fputs("\\000", OutputFile);
2056           break;
2057         default:
2058           if(OutputType == TYPE_E  &&  c == '\033')
2059             {
2060             fputs("\\e", OutputFile);
2061             }
2062           else
2063            {
2064            fprintf(OutputFile, "\\%c%c%c", ((c >> 6) & 3) + '0',
2065                     ((c >> 3) & 7) + '0', (c & 7) + '0');
2066            }
2067           break;
2068       }
2069       ++OutputLen;
2070       OutputMode = OutputMode_Bin;
2071       break;
2072     case TYPE_ASSEMBLER:
2073       switch(OutputMode)
2074       { case OutputMode_None:
2075           fprintf(OutputFile, "\tdc.b\t$%02x", c & 0xff);
2076           break;
2077         case OutputMode_Ascii:
2078           putc('\'', OutputFile);
2079         case OutputMode_Bin:
2080           fprintf(OutputFile, ",$%02x", c & 0xff);
2081           break;
2082       }
2083       ++OutputLen;
2084       OutputMode = OutputMode_Bin;
2085       break;
2086     case TYPE_NONE:
2087       ShowWarn(msgNoBinChars);
2088       break;
2089   }
2090 }
2091 //|
2092 /// FUNC: WriteAsciiChar
2093
2094 /*
2095     WriteAsciiChar writes one ascii character into the source file.
2096 */
2097 void WriteAsciiChar(int c)
2098 {
2099
2100   switch(OutputType)
2101   { case TYPE_C:
2102     case TYPE_OBERON:
2103       switch(c)
2104       { case '\"':
2105           fputs("\\\"", OutputFile);
2106           break;
2107         default:
2108           putc(c, OutputFile);
2109           break;
2110       }
2111       ++OutputLen;
2112       OutputMode = OutputMode_Ascii;
2113       break;
2114     case TYPE_E:
2115       switch(c)
2116       { case '\'':
2117           fputs("''", OutputFile);
2118           break;
2119         default:
2120           putc(c, OutputFile);
2121           break;
2122       }
2123       ++OutputLen;
2124       OutputMode = OutputMode_Ascii;
2125       break;
2126     case TYPE_ASSEMBLER:
2127       if (c == '\'')
2128       { WriteBinChar(c);
2129       }
2130       else
2131       { switch (OutputMode)
2132         { case OutputMode_None:
2133             fprintf(OutputFile, "\tdc.b\t\'%c", c);
2134             break;
2135           case OutputMode_Ascii:
2136             putc(c, OutputFile);
2137             break;
2138           case OutputMode_Bin:
2139             fprintf(OutputFile, ",\'%c", c);
2140             break;
2141         }
2142         ++OutputLen;
2143         OutputMode = OutputMode_Ascii;
2144       }
2145       break;
2146     case TYPE_NONE:
2147       putc(c, OutputFile);
2148       break;
2149   }
2150 }
2151 //|
2152 /// FUNC: TerminateCatStringOutput
2153
2154 /*
2155     TerminateCatStringOutput finishs the output of a catalog string.
2156 */
2157 void TerminateCatStringOutput(void)
2158 {
2159   switch(OutputType)
2160   { case TYPE_C:
2161     case TYPE_OBERON:
2162       putc('\"', OutputFile);
2163       break;
2164     case TYPE_E:
2165       putc('\'', OutputFile);
2166       break;
2167     case TYPE_ASSEMBLER:
2168       switch(OutputMode)
2169       { case OutputMode_Ascii:
2170           putc('\'', OutputFile);
2171         case OutputMode_Bin:
2172           break;
2173         case OutputMode_None:
2174           break;
2175       }
2176     case TYPE_NONE:
2177       break;
2178   }
2179 }
2180 //|
2181
2182 /// FUNC: WriteString
2183 /*
2184     This writes a sourcestring.
2185 */
2186 void WriteString(FILE *fpout, char *str, long Len)
2187 {
2188   char bytes[10];
2189   int bytesread;
2190   int needseparate = FALSE;
2191
2192   InitCatStringOutput(fpout);
2193   if (Len >= 0)
2194   { int i;
2195
2196     for(i = LengthBytes;  i >= 1;  i--)
2197     { WriteBinChar((int) ((char *) &Len)[sizeof(Len)-i]);
2198     }
2199   }
2200
2201   while (*str)
2202   { bytesread = ReadChar(&str, bytes);
2203     if (bytesread)
2204     { unsigned char c;
2205
2206       if (needseparate)
2207       { SeparateCatStringOutput();
2208         needseparate = FALSE;
2209       }
2210
2211       c = bytes[bytesread-1];
2212       if ((c >= 0x20  &&  c < 0x7f)  ||  c >= 0xa0)
2213       { WriteAsciiChar((int) c);
2214       }
2215       else
2216       { WriteBinChar((int) c);
2217       }
2218     }
2219     else
2220     { needseparate = TRUE;
2221     }
2222   }
2223   TerminateCatStringOutput();
2224 }
2225 //|
2226 /// FUNC: AllocFileName
2227 /*
2228     This function creates a copy of a filename, removes an
2229     optional ending and pathname components, if desired.
2230
2231     Inputs: filename - the filename to copy
2232             howto - a set of bits
2233                         bit 0: 1 = remove ending, 0 = leave it
2234                         bit 1: 1 = remove pathname, 0 = leave it
2235
2236     Result: The copy of the filename
2237 */
2238 char *AllocFileName(char *filename, int howto)
2239 {
2240   char *tempstr, *ptr;
2241
2242   if (!(tempstr = strdup(filename)))
2243   { MemError();
2244     MyExit(10);
2245   }
2246
2247   /*  Remove pathname components, if desired    */
2248   if (howto & 2)
2249   { if ((ptr = strchr(tempstr, ':')))
2250     { tempstr = ptr+1;
2251     }
2252     if ((ptr = strrchr(tempstr, '/')))
2253     { tempstr = ptr+1;
2254     }
2255   }
2256
2257   /*  Remove ending, if desired.                */
2258   if (howto & 1)
2259   { if ((ptr = strrchr(tempstr, '.')))
2260     { *ptr = '\0';
2261     }
2262   }
2263
2264   return(tempstr);
2265 }
2266 //|
2267 /// FUNC: AddFileName
2268 /*
2269     This function adds a pathname and a filename to a full
2270     filename.
2271
2272     Inputs: pathname - the leading pathname
2273             filename - the filename
2274
2275     Result: The new filename
2276 */
2277 char *AddFileName(char *pathname, char *filename)
2278 {
2279   char *buffer;
2280   int size = strlen(pathname) + strlen(filename) + 2;
2281
2282   if (!(buffer = malloc(size)))
2283   { MemError();
2284     MyExit(10);
2285   }
2286
2287 #if defined(__amigados)
2288   strcpy(buffer, pathname);
2289   AddPart((char *) buffer, (char *) filename, size);
2290 #else
2291   sprintf(buffer, "%s/%s", pathname, filename);
2292 #endif
2293
2294   return(buffer);
2295 }
2296 //|
2297
2298 /// FUNC: CreateSourceFile
2299
2300 /*
2301     Finally the source creation.
2302 */
2303 void CreateSourceFile(char *SourceFile, char *TemplateFile, char *CDFile)
2304 {
2305
2306   FILE *fpin, *fpout;
2307   char *line;
2308   char *OrigTemplateFile = TemplateFile;
2309
2310   ScanFile = SourceFile;
2311   ScanLine = 0;
2312
2313   /*
2314     Open the source file. This may be found in various places
2315   */
2316   if(!(fpin = fopen(TemplateFile, "r")))
2317     {
2318 #ifdef __amigados
2319     if(*prefs_sddir != 0)
2320       {
2321       TemplateFile = AddFileName(prefs_sddir, OrigTemplateFile);
2322       fpin = fopen(TemplateFile, "r");
2323       }
2324 #endif
2325     }
2326
2327   if(!fpin)
2328     {
2329     char *sddir;
2330
2331     if((sddir = getenv(FLEXCAT_SDDIR)))
2332       {
2333       TemplateFile = AddFileName(sddir, OrigTemplateFile);
2334       fpin = fopen(TemplateFile, "r");
2335       }
2336     }
2337
2338   if (!fpin)
2339   { TemplateFile = AddFileName(DEFAULT_FLEXCAT_SDDIR, OrigTemplateFile);
2340     fpin = fopen(TemplateFile, "r");
2341   }
2342
2343   if (!fpin)
2344     {
2345       ShowError(msgNoSourceDescription, OrigTemplateFile);
2346       return;
2347     }
2348
2349   if (!(fpout = fopen(SourceFile, "w")))
2350   {
2351     ShowError(msgNoSource, SourceFile);
2352     return;
2353   }
2354
2355   if(!NoBufferedIO)
2356     setvbuf(fpin, NULL, _IOFBF, buffer_size);
2357   if(!NoBufferedIO)
2358     setvbuf(fpout, NULL, _IOFBF, buffer_size);
2359
2360
2361   while(!feof(fpin)  &&  (line = ReadLine(fpin, FALSE)))
2362   { struct CatString *cs;
2363     int NeedRepeat;
2364     char bytes[10];
2365     int bytesread;
2366
2367     cs = FirstCatString;
2368     do
2369     { char *currentline = line;
2370       NeedRepeat = FALSE;
2371
2372       if (*currentline == '#'  &&  *(++currentline) == '#')
2373       { ++currentline;
2374         OverSpace(&currentline);
2375
2376         if(strnicmp( currentline, "rem", 3 ) == 0)
2377            {
2378            // we just skip this line
2379            continue;
2380            }
2381
2382         if (strnicmp(currentline, "stringtype", 10) == 0)
2383         { currentline += 10;
2384           OverSpace(&currentline);
2385           if (strnicmp(currentline, "c", 1) == 0)
2386           { OutputType = TYPE_C;
2387             ++currentline;
2388           }
2389           else if (strnicmp(currentline, "assembler", 9) == 0)
2390           { OutputType = TYPE_ASSEMBLER;
2391             currentline += 9;
2392           }
2393           else if (strnicmp(currentline, "oberon", 6) == 0)
2394           { OutputType = TYPE_OBERON;
2395             currentline += 6;
2396           }
2397           else if (strnicmp(currentline, "e", 1)  ==  0)
2398           { OutputType = TYPE_E;
2399             ++currentline;
2400           }
2401           else if (strnicmp(currentline, "none", 4)  ==  0)
2402           { OutputType = TYPE_NONE;
2403             currentline += 4;
2404           }
2405           else
2406           { ShowWarn(msgUnknownStringType);
2407             currentline += strlen(currentline);
2408           }
2409           OverSpace(&currentline);
2410           if (*currentline)
2411           { ShowWarn(msgExtraCharacters);
2412           }
2413           continue;
2414         }
2415         else if (strnicmp(currentline, "shortstrings", 12) == 0)
2416         { currentline += 12;
2417           LongStrings = FALSE;
2418           OverSpace(&currentline);
2419           if (*currentline)
2420           { ShowWarn(msgExtraCharacters);
2421           }
2422           continue;
2423         }
2424       }
2425
2426       currentline = line;
2427       while(*currentline)
2428       { bytesread = ReadChar(&currentline, bytes);
2429         if (bytesread)
2430         { if (*bytes == '%')
2431           { char c;
2432
2433             switch(c = *(currentline++))
2434             { case 'b':
2435                 fputs(BaseName, fpout);
2436                 break;
2437               case 'n':
2438                 fprintf(fpout, "%d", NumStrings);
2439                 break;
2440               case 'v':
2441                 fprintf(fpout, "%d", CatVersion);
2442                 break;
2443               case 'l':
2444                 WriteString(fpout, Language, -1);
2445                 break;
2446               case 'f':
2447                 { char *tempstr;
2448
2449                   if ((c = *currentline++) == 'v')
2450                   { fputs(VERS, fpout);
2451                   }
2452                   else
2453                   { tempstr = AllocFileName(CDFile, c - '0');
2454                     fputs(tempstr, fpout);
2455                   }
2456                 }
2457                 break;
2458               case 'o':
2459                 { char *tempstr;
2460
2461                   tempstr = AllocFileName(SourceFile, *currentline++ - '0');
2462                   fputs(tempstr, fpout);
2463                 }
2464                 break;
2465               case 'i':
2466                 NeedRepeat = TRUE;
2467                 if (cs) fputs(cs->ID_Str, fpout);
2468                 break;
2469
2470               case 'a':
2471               case 't':
2472
2473               case 'd':
2474               case 'x':
2475               case 'c':
2476               case '0':
2477               case '1':
2478               case '2':
2479               case '3':
2480               case '4':
2481               case '5':
2482               case '6':
2483               case '7':
2484               case '8':
2485               case '9':
2486                   {
2487                   int len = 0;
2488
2489                   while(c >= '0'  &&  c <= '9')
2490                     {
2491                     len = (c - '0') + len * 10;
2492                     c = *currentline++;
2493                     }
2494
2495
2496                   if(c ==  'a')
2497                     {
2498                     int _len = len ? len : 4;
2499                     char *start;
2500                     char _StrLen[20 + 1];
2501
2502                     sprintf(_StrLen, "%020lx", cs->ID);
2503
2504                     start = &_StrLen[20-_len*2];
2505                     while(_len>0)
2506                        {
2507                        fprintf(fpout, "\\x%.2s", start);
2508                        start+=2;
2509                        _len--;
2510                        }
2511                     }
2512
2513                   if(c ==  't')
2514                     {
2515                     int _len = len ? len : 4;
2516                     char *start;
2517                     char _StrLen[20 + 1];
2518
2519                     sprintf(_StrLen, "%020lx", ((CalcRealLength(cs->CD_Str) + 1) & 0xfffffe));
2520
2521                     start = &_StrLen[20-_len*2];
2522                     while(_len>0)
2523                        {
2524                        fprintf(fpout, "\\x%.2s", start);
2525                        start+=2;
2526                        _len--;
2527                        }
2528                     }
2529
2530                   if(c == 'c' || c == 'd' || c == 'x')
2531                     {
2532                     char buffer[20];
2533
2534                     if(c == 'c') c = 'o';
2535
2536                     if(len)
2537                       sprintf(buffer, "%%0%d%c", len, c);
2538                     else
2539                       sprintf(buffer, "%%%c", c);
2540
2541                     if(cs) fprintf(fpout, buffer, cs->ID);
2542                     }
2543
2544
2545                   NeedRepeat = TRUE;
2546                   }
2547                   break;
2548
2549               case 'e':
2550                 NeedRepeat = TRUE;
2551                 if (cs) fprintf(fpout, "%d", cs->Nr);
2552                 break;
2553               case 's':
2554                 NeedRepeat = TRUE;
2555                 if (cs)
2556                 { char *idstr;
2557                   unsigned long len = 0;
2558
2559                   if (LengthBytes)
2560                   { idstr = cs->CD_Str;
2561                     while(*idstr)
2562                     { bytesread = ReadChar(&idstr, bytes);
2563                       if (bytesread)
2564                       { ++len;
2565                       }
2566                     }
2567                   }
2568                   WriteString(fpout, cs->CD_Str, LengthBytes ? len : -1);
2569                 }
2570                 break;
2571               case '(':
2572                 NeedRepeat = TRUE;
2573                 while(*currentline  &&  *currentline != ')')
2574                 { bytesread = ReadChar(&currentline, bytes);
2575                   if (bytesread  &&  cs  &&  cs->Next)
2576                   { putc((int) bytes[bytesread-1], fpout);
2577                   }
2578                 }
2579                 if (!*currentline)
2580                 { ShowWarn(msgNoTerminateBracket);
2581                 }
2582                 else
2583                 { ++currentline;
2584                 }
2585                 break;
2586
2587 // !!!! FIX !!!!
2588
2589               case 'z':
2590                 {
2591                 int diff = (((CalcRealLength(cs->CD_Str) + 1) & 0xfffffe) - (CalcRealLength(cs->CD_Str)));
2592
2593                 NeedRepeat = TRUE;
2594
2595                 while(diff > 0)
2596                    {
2597                    fprintf(fpout, "\\x00");
2598                    diff--;
2599                    }
2600
2601                 break;
2602                 }
2603
2604               default:
2605                 { int c = *currentline++;
2606
2607                   putc(c, fpout);
2608                 }
2609             }
2610           }
2611           else
2612           { putc((int) bytes[bytesread-1], fpout);
2613           }
2614         }
2615       }
2616       putc('\n', fpout);
2617     }
2618     while(NeedRepeat  &&  cs  &&  (cs = cs->Next));
2619
2620     free(line);
2621   }
2622
2623   fclose(fpin);
2624   fclose(fpout);
2625 }
2626 //|
2627
2628 /// FUNC: Usage
2629 /*
2630     The Usage function describes the programs calling syntax.
2631 */
2632 void Usage(void)
2633
2634 {
2635   fputs((char *) msgUsageHead, stderr);
2636   fprintf(stderr, ": FlexCat CDFILE/A,CTFILE,CATALOG/K,NEWCTFILE/K,SOURCES/M,\n                WARNCTGAPS/S,NOOPTIM/S,FILL/S,FLUSH/S,NOBEEP/S,\n                QUIET/S,NOLANGTOLOWER/S,NOBUFFEREDIO/S,\n                MODIFIED/S,COPYMSGNEW/S,OLDMSGNEW/K, NOSPACE/S\n\n", VString);
2637   fprintf(stderr, "%s\n%s\n%s\n%s\n", msgUsage, msgUsage_2, msgUsage_3, msgUsage_4 );
2638   fprintf(stderr, "\n\n%s"
2639 /*
2640   #ifdef _M68040
2641     " [040]"
2642   #else
2643     #ifdef _M68060
2644       " [060]"
2645     #else
2646       #ifdef _M68030
2647         " [030]"
2648       #else
2649         #ifdef _M68020
2650           " [020]"
2651         #else
2652           #ifdef _M68010
2653             " [010]"
2654           #endif
2655         #endif
2656       #endif
2657     #endif
2658   #endif
2659 */
2660   "\n", VString);
2661
2662
2663   fprintf(stderr, "%s\n", EString);
2664   MyExit(5);
2665 }
2666 //|
2667 /// FUNC: main
2668 /*
2669     Finally the main function. Does nothing special except for scanning
2670     the arguments.
2671 */
2672 int main(int argc, char *argv [])
2673 {
2674   char *cdfile, *ctfile, *newctfile, *catalog;
2675   char *source, *template;
2676   int i;
2677
2678   if(argc == 0)    /*  Aztec's entry point for workbench programs  */
2679    {
2680    fprintf(stderr, "FlexCat can't be run from Workbench!\n\n");
2681    fprintf(stderr, "Open a Shell session and type FlexCat ?\n");
2682    fprintf(stderr, "for more information\n");
2683    exit(5);
2684    }
2685
2686   cdfile = ctfile = newctfile = catalog = NULL;
2687
2688
2689   /* let's open catalog files by hand if necessary */
2690   /* should be done automatically anyway for most  */
2691   /* cases, but, that depends on compiler...       */
2692
2693 #if defined(_DCC)
2694   // STATIC __autoinit VOID _STIOpenFlexCatCatalog(VOID)
2695 #elif defined(__SASC)
2696   // VOID _STIOpenFlexCatCatalog(VOID)
2697 #elif defined(__GNUC__)
2698   // VOID _STIOpenFlexCatCatalog(VOID)
2699 #elif defined(__INTEL_COMPILER)
2700   // VOID _STIOpenFlexCatCatalog(VOID)
2701 #else
2702    OpenFlexCatCatalog();   /* no autoopen. we do it then */
2703 #endif
2704
2705
2706     // Big Endian vs Little Endian (both supported ;-)
2707     if( !SwapChoose() )
2708        {
2709        fprintf(stderr, "FlexCat is unable to determine the\n");
2710        fprintf(stderr, "the byte order used by your system.\n");
2711        fprintf(stderr, "It's neither Little nor Big Endian?!.\n");
2712        exit(5);
2713        }
2714
2715
2716
2717 #if defined(__amigados)
2718   ReadPrefs();
2719 #endif
2720
2721   if(argc == 1)
2722     {
2723     Usage();
2724     }
2725
2726   for (i = 1;  i < argc;  i++)
2727     {
2728     if(strnicmp (argv[i], "catalog=", 8) == 0)
2729       {
2730       catalog = argv[i] + 8;
2731       }
2732     else
2733     if(stricmp (argv[i], "catalog") == 0)
2734       {
2735       if(i+1 == argc)
2736         Usage();
2737       catalog = argv[++i];
2738       }
2739     else
2740     if(stricmp(argv[i], "nooptim") == 0)
2741      {
2742      NoOptim = TRUE;
2743      }
2744     else
2745     if(stricmp(argv[i], "fill") == 0)
2746      {
2747      Fill = TRUE;
2748      }
2749     else
2750     if(stricmp(argv[i], "quiet") == 0)
2751      {
2752      Quiet = TRUE;
2753      }
2754     else
2755     if(stricmp(argv[i], "flush") == 0)
2756      {
2757      DoExpunge = TRUE;
2758      }
2759     else
2760     if(stricmp(argv[i], "nobeep") == 0)
2761      {
2762      NoBeep = TRUE;
2763      }
2764     else
2765     if(stricmp(argv[i], "nobufferedio") == 0)
2766      {
2767      NoBufferedIO = TRUE;
2768      }
2769     else
2770     if (strnicmp (argv[i], "newctfile=", 10) == 0)
2771       {
2772       newctfile = argv[i] + 10;
2773       }
2774     else
2775     if(strnicmp (argv[i], "newctfile", 9) == 0)
2776       {
2777       if (i+1 == argc)
2778         Usage();
2779       newctfile = argv[++i];
2780       }
2781     else
2782     if(stricmp(argv[i], "nolangtolower") == 0)
2783       {
2784       LANGToLower = FALSE;
2785       }
2786     else
2787     if(stricmp(argv[i], "modified") == 0)
2788       {
2789       Modified = TRUE;
2790       }
2791     else
2792     if(stricmp(argv[i], "warnctgaps") == 0)
2793       {
2794       WarnCTGaps = TRUE;
2795       }
2796     else
2797     if(stricmp(argv[i], "copymsgnew") == 0)
2798       {
2799       CopyNEWs = TRUE;
2800       }
2801     else
2802     if(stricmp(argv[i], "nospace") == 0)
2803       {
2804       NoSpace = TRUE;
2805       }
2806     else
2807     if(stricmp(argv[i], "oldmsgnew") == 0)
2808       {
2809       sprintf( Old_Msg_New, "; %s", argv[++i] );
2810       }
2811     else
2812       if(cdfile == NULL)
2813         {
2814         if(stricmp(argv[i], "?") == 0 || stricmp(argv[i], "-h") == 0 || stricmp(argv[i], "help") == 0 || stricmp(argv[i], "--help") == 0)
2815           {
2816           Usage();
2817           }
2818         if(!ScanCDFile(cdfile = argv[i]))
2819           {
2820           MyExit(10);
2821           }
2822         }
2823     else
2824     if(strchr(argv[i], '='))
2825       {
2826       source = AllocString(argv[i]);
2827       *(template = strchr(source, '=')) = '\0';
2828       ++template;
2829
2830       CreateSourceFile(source, template, cdfile);
2831       }
2832     else
2833       {
2834       if (ctfile)
2835         {
2836         Usage();
2837         }
2838       ctfile = argv[i];
2839       }
2840     }
2841
2842
2843 #if defined(__amigados)
2844   if(Modified)
2845     {
2846     if(cdfile && ctfile && catalog)
2847        {
2848        long cd_time, ct_time, cat_time;
2849
2850        if((cd_time = getft(cdfile)) != -1)
2851            {
2852            if((ct_time = getft(ctfile)) != -1)
2853               {
2854               if((cat_time = getft(catalog)) == -1)
2855                 cat_time = 0;
2856
2857                 if((cat_time > ct_time) &&
2858                    (cat_time > cd_time))
2859                        {
2860                        if(!Quiet)
2861                          {
2862                          fprintf(stderr, (char *) msgUpToDate, catalog);
2863                          putc('\n', stderr);
2864                          }
2865
2866                        MyExit(GlobalReturnCode);
2867                        }
2868                   else
2869                     {
2870                     if(!Quiet)
2871                       {
2872                       fprintf(stderr, "--> %s", catalog);
2873                       putc('\n', stderr);
2874                       }
2875                     }
2876               }
2877             else
2878               {
2879               ShowError(msgCantCheckDate, ctfile);
2880               }
2881            }
2882         else
2883            {
2884            ShowError(msgCantCheckDate, cdfile);
2885            }
2886        }
2887     }
2888 #endif
2889
2890   if(ctfile)
2891     {
2892     if(!ScanCTFile(ctfile))
2893       MyExit(10);
2894     }
2895
2896   if(catalog)
2897     {
2898     if(!ctfile)
2899       {
2900       fprintf(stderr, (char *) msgNoCTArgument);
2901       Usage();
2902       }
2903     CreateCat(catalog);
2904     }
2905
2906   if(newctfile)
2907     {
2908     CreateCTFile(newctfile);
2909     }
2910
2911   MyExit(GlobalReturnCode);
2912 }
2913 //|
2914 /// FUNC: wbmain
2915
2916 /*
2917     Dice's entry point for workbench programs
2918 */
2919 #if defined(__amigados)  &&  defined(_DCC)
2920 void wbmain(struct WBStartup *wbmsg)
2921 {
2922    fprintf(stderr, "FlexCat can't be run from Workbench!\n\n");
2923    fprintf(stderr, "Open a Shell session and type FlexCat\n");
2924    fprintf(stderr, "for syntax and more information\n");
2925
2926    exit(5);
2927 }
2928 #endif
2929 //|
2930