tools/flexcat/src/createcatsrc.c

   1 /*
   2  * $Id$
   3  *
   4  * Copyright (C) 1993-1999 by Jochen Wiedmann and Marcin Orlowski
   5  * Copyright (C) 2002-2010 by the FlexCat Open Source Team
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or (at
  10  * your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20  *
  21  */
  22
  23 #include "flexcat.h"
  24 #include "readprefs.h"
  25 #include "swapfuncs.h"
  26 #include "showfuncs.h"
  27 #include "scancd.h"
  28 #include "scanct.h"
  29 #include "createcat.h"
  30 #include "globals.h"
  31 #include "utils.h"
  32
  33 enum StringTypes
  34 {
  35   TYPE_C,           /* Produce C strings */
  36   TYPE_ASSEMBLER,       /* Produce Assembler strings */
  37   TYPE_OBERON,        /* Produce Oberon strings */
  38   TYPE_E,           /* Produce E strings. (Oops, thought
  39                    it allows only 32 bit integers? ;-) */
  40   TYPE_NONE           /* Simple strings */
  41 };
  42
  43 enum OutputModes
  44 {
  45   OutputMode_None,      /* Nothing written yet */
  46   OutputMode_Bin,       /* Last character written was binary */
  47   OutputMode_Ascii      /* Last character written was Ascii */
  48 };
  49
  50 int OutputMode = OutputMode_None;
  51 int OutputType = TYPE_C;
  52
  53 FILE *OutputFile;
  54 int OutputLen;
  55 int LongStrings = TRUE;   /* Generate long or short strings */
  56
  57 /// CalcRealLength
  58
  59 /* This function measures the real (binary) length of source
  60    string. It correctly process 'slash chars' (\n, \000 etc),
  61    and gives the real length such source string have.
  62
  63    Inputs: source - pointer to NULL terminated source string
  64    Result: real length */
  65
  66 int CalcRealLength(char *source)
  67 {
  68   int count = 0;
  69   int len;
  70   char *src = source;
  71   char bytes[10];
  72
  73   while(*src != '\0')
  74   {
  75     len = ReadChar(&src, bytes);
  76     // substract one byte for double backslashes
  77     if(len == 2)
  78       len--;
  79
  80     count += len;
  81   }
  82
  83 /* printf("%ld: '%s'\n", count, source); */
  84   return count;
  85 }
  86
  87 ///
  88 /// InitCatStringOutput
  89
  90 /* InitCatStringOutput gets called before writing a catalog string as source.
  91    Inputs: fp   = file pointer to the output file
  92    type = one of TYPE_C      create C strings
  93          TYPE_ASSEMBLER  create Assembler strings
  94          TYPE_OBERON   create Oberon strings
  95          TYPE_E      create E strings
  96          TYPE_NONE     create simple strings */
  97
  98 void InitCatStringOutput(FILE *fp)
  99 {
 100   OutputLen = 0;
 101   OutputFile = fp;
 102   OutputMode = OutputMode_None;
 103
 104   switch(OutputType)
 105   {
 106     case TYPE_C:
 107     case TYPE_OBERON:
 108       putc('\"', fp);
 109       OutputMode = OutputMode_Ascii;
 110       break;
 111
 112     case TYPE_E:
 113       putc('\'', fp);
 114
 115     case TYPE_ASSEMBLER:
 116     case TYPE_NONE:
 117       break;
 118   }
 119 }
 120
 121 ///
 122 /// SeparateCatStringOutput
 123
 124 /* SeparateCatStringOutput gets called to split a catalog into
 125    separate lines. */
 126
 127 void SeparateCatStringOutput(void)
 128 {
 129   switch(OutputType)
 130   {
 131     case TYPE_C:
 132       if(!LongStrings)
 133       {
 134         fputs("\"\\\n\t\"", OutputFile);
 135       }
 136       break;
 137
 138     case TYPE_E:
 139       if(!LongStrings)
 140       {
 141         fputs("\' +\n\t\'", OutputFile);
 142       }
 143       break;
 144
 145     case TYPE_OBERON:
 146       if(!LongStrings)
 147       {
 148         fputs("\"\n\t\"", OutputFile);
 149       }
 150       break;
 151
 152     case TYPE_ASSEMBLER:
 153       if(!LongStrings)
 154       {
 155         if(OutputMode == OutputMode_Ascii)
 156         {
 157           putc('\'', OutputFile);
 158         }
 159         putc('\n', OutputFile);
 160         OutputMode = OutputMode_None;
 161       }
 162       break;
 163
 164     case TYPE_NONE:
 165       break;
 166   }
 167 }
 168
 169 ///
 170 /// WriteBinChar
 171
 172 /* WriteBinChar writes one binary character into the source file. */
 173
 174 void WriteBinChar(int c)
 175 {
 176   switch(OutputType)
 177   {
 178     case TYPE_C:
 179     case TYPE_E:
 180     case TYPE_OBERON:
 181       switch(c)
 182       {
 183         case '\b':
 184           fputs("\\b", OutputFile);
 185           break;
 186
 187         case '\n':
 188           fputs("\\n", OutputFile);
 189           break;
 190
 191         case '\r':
 192           fputs("\\r", OutputFile);
 193           break;
 194
 195         case '\t':
 196           fputs("\\t", OutputFile);
 197           break;
 198
 199         case '\f':
 200           fputs("\\f", OutputFile);
 201           break;
 202
 203         case '\0':
 204           fputs("\\000", OutputFile);
 205           break;
 206
 207         default:
 208           if(OutputType == TYPE_E && c == '\033')
 209           {
 210             fputs("\\e", OutputFile);
 211           }
 212           else
 213           {
 214             fprintf(OutputFile, "\\%c%c%c", ((c >> 6) & 3) + '0', ((c >> 3) & 7) + '0', (c & 7) + '0');
 215           }
 216           break;
 217
 218       }
 219       ++OutputLen;
 220       OutputMode = OutputMode_Bin;
 221       break;
 222
 223     case TYPE_ASSEMBLER:
 224       switch(OutputMode)
 225       {
 226         case OutputMode_None:
 227           fprintf(OutputFile, "\tdc.b\t$%02x", c & 0xff);
 228           break;
 229
 230         case OutputMode_Ascii:
 231           putc('\'', OutputFile);
 232
 233         case OutputMode_Bin:
 234           fprintf(OutputFile, ",$%02x", c & 0xff);
 235           break;
 236       }
 237       ++OutputLen;
 238       OutputMode = OutputMode_Bin;
 239       break;
 240
 241     case TYPE_NONE:
 242       ShowError(MSG_ERR_NOBINCHARS);
 243       break;
 244   }
 245 }
 246
 247 ///
 248 /// WriteAsciiChar
 249
 250 /* WriteAsciiChar writes one ascii character into the source file. */
 251
 252 void WriteAsciiChar(int c)
 253 {
 254   switch(OutputType)
 255   {
 256     case TYPE_C:
 257     case TYPE_OBERON:
 258       switch(c)
 259       {
 260         case '\"':
 261           fputs("\\\"", OutputFile);
 262           break;
 263
 264         default:
 265           putc(c, OutputFile);
 266           break;
 267       }
 268       ++OutputLen;
 269       OutputMode = OutputMode_Ascii;
 270       break;
 271
 272     case TYPE_E:
 273       switch(c)
 274       {
 275         case '\'':
 276           fputs("''", OutputFile);
 277           break;
 278
 279         default:
 280           putc(c, OutputFile);
 281           break;
 282       }
 283       ++OutputLen;
 284       OutputMode = OutputMode_Ascii;
 285       break;
 286
 287     case TYPE_ASSEMBLER:
 288       if(c == '\'')
 289       {
 290         WriteBinChar(c);
 291       }
 292       else
 293       {
 294         switch(OutputMode)
 295         {
 296           case OutputMode_None:
 297             fprintf(OutputFile, "\tdc.b\t\'%c", c);
 298             break;
 299
 300           case OutputMode_Ascii:
 301             putc(c, OutputFile);
 302             break;
 303
 304           case OutputMode_Bin:
 305             fprintf(OutputFile, ",\'%c", c);
 306             break;
 307         }
 308         ++OutputLen;
 309         OutputMode = OutputMode_Ascii;
 310       }
 311       break;
 312
 313     case TYPE_NONE:
 314       putc(c, OutputFile);
 315       break;
 316   }
 317 }
 318
 319 ///
 320 /// TerminateCatStringOutput
 321
 322 /* TerminateCatStringOutput finishes the output of a catalog string. */
 323
 324 void TerminateCatStringOutput(void)
 325 {
 326   switch(OutputType)
 327   {
 328     case TYPE_C:
 329     case TYPE_OBERON:
 330       putc('\"', OutputFile);
 331       break;
 332
 333     case TYPE_E:
 334       putc('\'', OutputFile);
 335       break;
 336
 337     case TYPE_ASSEMBLER:
 338       switch(OutputMode)
 339       {
 340         case OutputMode_Ascii:
 341           putc('\'', OutputFile);
 342           // fall through...
 343
 344         case OutputMode_Bin:
 345           break;
 346
 347         case OutputMode_None:
 348           break;
 349       }
 350       break;
 351
 352     case TYPE_NONE:
 353       break;
 354
 355   }
 356
 357 }
 358
 359 ///
 360 /// WriteString
 361
 362 /* This writes a source string. */
 363
 364 static void WriteString(FILE * fpout, char *str, int32 Len, int lenbytes, int allbytes)
 365 {
 366   char bytes[10];
 367   int bytesread;
 368   int needseparate = FALSE;
 369
 370   InitCatStringOutput(fpout);
 371   if(Len >= 0)
 372   {
 373     int i;
 374
 375     for(i = lenbytes; i >= 1; i--)
 376     {
 377       WriteBinChar((int)((char *)&Len)[sizeof(Len) - i]);
 378     }
 379
 380   }
 381
 382   while(*str != '\0')
 383   {
 384     bytesread = ReadChar(&str, bytes);
 385     if(bytesread > 0)
 386     {
 387       if(needseparate == TRUE)
 388       {
 389         SeparateCatStringOutput();
 390         needseparate = FALSE;
 391       }
 392
 393       do
 394       {
 395         unsigned char c = bytes[bytesread - 1];
 396
 397         if((c >= 0x20 && c < 0x7f) || c >= 0xa0)
 398           WriteAsciiChar((int)c);
 399         else
 400           WriteBinChar((int)c);
 401
 402         if(allbytes == 0)
 403           break;
 404       }
 405       while(--bytesread > 0);
 406     }
 407     else
 408       needseparate = TRUE;
 409   }
 410
 411   TerminateCatStringOutput();
 412 }
 413
 414 ///
 415 /// CreateSourceFile
 416
 417 /* Finally, the source creation. */
 418
 419 void CreateSourceFile(char *SourceFile, char *TemplateFile, char *CDFile)
 420 {
 421   FILE *fpin, *fpout;
 422   char *line;
 423   char *OrigTemplateFile = TemplateFile;
 424
 425   ScanFile = SourceFile;
 426   ScanLine = 0;
 427
 428   /* Open the source file. This may be found in various places. */
 429
 430   if((fpin = fopen(TemplateFile, "r")) == NULL)
 431   {
 432 #ifdef AMIGA
 433     if(*prefs_sddir != '\0')
 434     {
 435       TemplateFile = AddFileName(prefs_sddir, OrigTemplateFile);
 436       fpin = fopen(TemplateFile, "r");
 437     }
 438 #endif
 439   }
 440
 441   if(fpin == NULL)
 442   {
 443 #ifdef AMIGA
 444     char sddir[80];
 445
 446     if(GetVar(FLEXCAT_SDDIR, sddir, 80, 0) != 0)
 447 #else
 448     char *sddir;
 449
 450     if((sddir = getenv(FLEXCAT_SDDIR)) != NULL)
 451 #endif
 452     {
 453       TemplateFile = AddFileName(sddir, OrigTemplateFile);
 454       fpin = fopen(TemplateFile, "r");
 455     }
 456   }
 457
 458   if(fpin == NULL)
 459   {
 460     TemplateFile = AddFileName(strdup(DEFAULT_FLEXCAT_SDDIR), OrigTemplateFile);
 461     fpin = fopen(TemplateFile, "r");
 462   }
 463
 464   if(fpin == NULL)
 465   {
 466     ShowError(MSG_ERR_NOSOURCEDESCRIPTION, OrigTemplateFile);
 467     return;
 468   }
 469
 470   if((fpout = fopen(SourceFile, "w")) == NULL)
 471   {
 472     ShowError(MSG_ERR_NOSOURCE, SourceFile);
 473     return;
 474   }
 475
 476   if(!NoBufferedIO)
 477     setvbuf(fpin, NULL, _IOFBF, buffer_size);
 478   if(!NoBufferedIO)
 479     setvbuf(fpout, NULL, _IOFBF, buffer_size);
 480
 481   while(!feof(fpin) && (line = ReadLine(fpin, FALSE)) != NULL)
 482   {
 483     struct CatString *cs;
 484     int NeedRepeat;
 485     char bytes[10];
 486     int bytesread;
 487
 488     cs = FirstCatString;
 489
 490     do
 491     {
 492       char *currentline = line;
 493
 494       NeedRepeat = FALSE;
 495       if(*currentline == '#' && *(++currentline) == '#')
 496       {
 497         ++currentline;
 498         OverSpace(&currentline);
 499         if(Strnicmp(currentline, "rem", 3) == 0)
 500         {
 501           /* We just skip this line. */
 502           continue;
 503         }
 504
 505         if(Strnicmp(currentline, "stringtype", 10) == 0)
 506         {
 507           currentline += 10;
 508           OverSpace(&currentline);
 509           if(Strnicmp(currentline, "c", 1) == 0)
 510           {
 511             OutputType = TYPE_C;
 512             ++currentline;
 513           }
 514           else if(Strnicmp(currentline, "assembler", 9) == 0)
 515           {
 516             OutputType = TYPE_ASSEMBLER;
 517             currentline += 9;
 518           }
 519           else if(Strnicmp(currentline, "oberon", 6) == 0)
 520           {
 521             OutputType = TYPE_OBERON;
 522             currentline += 6;
 523           }
 524           else if(Strnicmp(currentline, "e", 1) == 0)
 525           {
 526             OutputType = TYPE_E;
 527             ++currentline;
 528           }
 529           else if(Strnicmp(currentline, "none", 4) == 0)
 530           {
 531             OutputType = TYPE_NONE;
 532             currentline += 4;
 533           }
 534           else
 535           {
 536             ShowWarn(MSG_ERR_UNKNOWNSTRINGTYPE);
 537             currentline += strlen(currentline);
 538           }
 539           OverSpace(&currentline);
 540           if(*currentline != '\0')
 541           {
 542             ShowError(MSG_ERR_EXTRA_CHARACTERS);
 543           }
 544           continue;
 545         }
 546         else if(Strnicmp(currentline, "shortstrings", 12) == 0)
 547         {
 548           currentline += 12;
 549           LongStrings = FALSE;
 550           OverSpace(&currentline);
 551           if(*currentline != '\0')
 552           {
 553             ShowError(MSG_ERR_EXTRA_CHARACTERS);
 554           }
 555           continue;
 556         }
 557       }
 558       currentline = line;
 559       while(*currentline != '\0')
 560       {
 561         bytesread = ReadChar(&currentline, bytes);
 562         if(bytesread > 0)
 563         {
 564           if(*bytes == '%')
 565           {
 566             char c = *currentline++;
 567
 568             switch(c)
 569             {
 570               case 'b':
 571                 fputs(BaseName, fpout);
 572                 break;
 573
 574               case 'n':
 575                 fprintf(fpout, "%d", NumStrings);
 576                 break;
 577
 578               case 'v':
 579                 fprintf(fpout, "%d", CatVersion);
 580                 break;
 581
 582               case 'l':
 583                 WriteString(fpout, Language, -1, cs->LenBytes, cs->POformat);
 584                 break;
 585
 586               case 'f':
 587                 {
 588                   char *tempstr;
 589
 590                   if((c = *currentline++) == 'v')
 591                   {
 592                     fputs(VERS, fpout);
 593                   }
 594                   else
 595                   {
 596                     tempstr = AllocFileName(CDFile, c - '0');
 597                     fputs(tempstr, fpout);
 598
 599                     free(tempstr);
 600                   }
 601                 }
 602                 break;
 603
 604               case 'o':
 605                 {
 606                   char *tempstr;
 607
 608                   tempstr = AllocFileName(SourceFile, *currentline++ - '0');
 609                   fputs(tempstr, fpout);
 610
 611                   free(tempstr);
 612                 }
 613                 break;
 614
 615               case 'i':
 616                 NeedRepeat = TRUE;
 617                 if(cs != NULL)
 618                   fputs(cs->ID_Str, fpout);
 619                 break;
 620
 621               case 'a':
 622               case 't':
 623               case 'd':
 624               case 'x':
 625               case 'c':
 626               case '0':
 627               case '1':
 628               case '2':
 629               case '3':
 630               case '4':
 631               case '5':
 632               case '6':
 633               case '7':
 634               case '8':
 635               case '9':
 636                 {
 637                   int len = 0;
 638
 639                   while(c >= '0' && c <= '9')
 640                   {
 641                     len = (c - '0') + len * 10;
 642                     c = *currentline++;
 643                   }
 644
 645                   if(c == 'a')
 646                   {
 647                     int _len = len ? len : 4;
 648                     char *start;
 649                     char _StrLen[20 + 1];
 650
 651                     snprintf(_StrLen, sizeof(_StrLen), "%020lx", (uint32)cs->ID);
 652                     start = &_StrLen[20 - _len * 2];
 653                     while(_len > 0)
 654                     {
 655                       fprintf(fpout, "\\x%.2s", start);
 656                       start += 2;
 657                       _len--;
 658                     }
 659                   }
 660                   else if(c == 't')
 661                   {
 662                     int _len = len ? len : 4;
 663                     char *start;
 664                     char _StrLen[20 + 1];
 665
 666                     snprintf(_StrLen, sizeof(_StrLen), "%020lx", (uint32)((CalcRealLength(cs->CD_Str) + 1) & 0xfffffe));
 667                     start = &_StrLen[20 - _len * 2];
 668                     while(_len > 0)
 669                     {
 670                       fprintf(fpout, "\\x%.2s", start);
 671                       start += 2;
 672                       _len--;
 673                     }
 674                   }
 675                   else if(c == 'c' || c == 'd' || c == 'x')
 676                   {
 677                     char buffer[20];
 678
 679                     if(c == 'c')
 680                       c = 'o';
 681                     if(len)
 682                       snprintf(buffer, sizeof(buffer), "%%0%d%c", len, c);
 683                     else
 684                       snprintf(buffer, sizeof(buffer), "%%%c", c);
 685
 686                     if(cs != NULL)
 687                       fprintf(fpout, buffer, cs->ID);
 688
 689                   }
 690                   NeedRepeat = TRUE;
 691                 }
 692                 break;
 693
 694               case 'e':
 695                 NeedRepeat = TRUE;
 696                 if(cs != NULL)
 697                   fprintf(fpout, "%d", cs->Nr);
 698                 break;
 699
 700               case 's':
 701                 NeedRepeat = TRUE;
 702                 if(cs != NULL)
 703                 {
 704                   char *idstr;
 705                   uint32 len = 0;
 706
 707                   if(cs->LenBytes)
 708                   {
 709                     idstr = cs->CD_Str;
 710                     while(*idstr != '\0')
 711                     {
 712                       bytesread = ReadChar(&idstr, bytes);
 713                       if(bytesread > 0)
 714                       {
 715                         ++len;
 716                       }
 717                     }
 718                   }
 719
 720                   WriteString(fpout, cs->CD_Str,  cs->LenBytes ? len : (uint32)-1, cs->LenBytes, cs->POformat);
 721                 }
 722                 break;
 723
 724               case '(':
 725                 NeedRepeat = TRUE;
 726                 while(*currentline != '\0' && *currentline != ')')
 727                 {
 728                   bytesread = ReadChar(&currentline, bytes);
 729                   if(bytesread > 0 && cs != NULL && cs->Next != NULL)
 730                   {
 731                     putc((int)bytes[bytesread - 1], fpout);
 732                   }
 733                 }
 734
 735                 if(*currentline == '\0')
 736                 {
 737                   /* FIXME: reuse MSG_ERR_NOTRAILINGBRACKET here? <tactica> */
 738                   ShowError(MSG_ERR_NOTERMINATEBRACKET);
 739                 }
 740                 else
 741                 {
 742                   ++currentline;
 743                 }
 744                 break;
 745
 746               /* !!!! FIXME !!!! */
 747               case 'z':
 748                 {
 749                   int diff = (((CalcRealLength(cs->CD_Str) + 1) & 0xfffffe) - (CalcRealLength(cs->CD_Str)));
 750
 751                   NeedRepeat = TRUE;
 752                   while(diff > 0)
 753                   {
 754                     fprintf(fpout, "\\x00");
 755                     diff--;
 756                   }
 757                   break;
 758                 }
 759
 760               default:
 761                 {
 762                   int ch = *currentline++;
 763
 764                   putc(ch, fpout);
 765                 }
 766             }
 767           }
 768           else
 769           {
 770             putc((int)bytes[bytesread - 1], fpout);
 771           }
 772         }
 773       }
 774       putc('\n', fpout);
 775     }
 776     while(NeedRepeat == TRUE && cs != NULL  && (cs = cs->Next) != NULL);
 777
 778     free(line);
 779   }
 780   fclose(fpin);
 781   fclose(fpout);
 782
 783 #ifdef AMIGA
 784   SetProtection(SourceFile, FILE_MASK);
 785 #endif
 786 }
 787
 788 ///