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