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 'B':
 575                 {
 576                     char *basenamestr = BaseName;
 577                     int i;
 578                     for (i = 0; i < strlen(BaseName); i++)
 579                     {
 580                         c = *basenamestr++;
 581                         if (c >= '0' && c <= '9')
 582                             putc(c, fpout);
 583                         else if ((c >= 'A' && c <= 'Z') ||
 584                             (c >= 'a' && c <= 'z'))
 585                             putc(c & 0x5F, fpout);
 586                         else
 587                             putc('_', fpout);
 588                     }
 589                     break;
 590                 }
 591
 592               case 'n':
 593                 fprintf(fpout, "%d", NumStrings);
 594                 break;
 595
 596               case 'v':
 597                 fprintf(fpout, "%d", CatVersion);
 598                 break;
 599
 600               case 'l':
 601                 WriteString(fpout, Language, -1, cs->LenBytes, cs->POformat);
 602                 break;
 603
 604               case 'f':
 605                 {
 606                   char *tempstr;
 607
 608                   if((c = *currentline++) == 'v')
 609                   {
 610                     fputs(VERS, fpout);
 611                   }
 612                   else
 613                   {
 614                     tempstr = AllocFileName(CDFile, c - '0');
 615                     fputs(tempstr, fpout);
 616
 617                     free(tempstr);
 618                   }
 619                 }
 620                 break;
 621
 622               case 'o':
 623                 {
 624                   char *tempstr;
 625
 626                   tempstr = AllocFileName(SourceFile, *currentline++ - '0');
 627                   fputs(tempstr, fpout);
 628
 629                   free(tempstr);
 630                 }
 631                 break;
 632
 633               case 'i':
 634                 NeedRepeat = TRUE;
 635                 if(cs != NULL)
 636                   fputs(cs->ID_Str, fpout);
 637                 break;
 638
 639               case 'a':
 640               case 't':
 641               case 'd':
 642               case 'x':
 643               case 'c':
 644               case '0':
 645               case '1':
 646               case '2':
 647               case '3':
 648               case '4':
 649               case '5':
 650               case '6':
 651               case '7':
 652               case '8':
 653               case '9':
 654                 {
 655                   int len = 0;
 656
 657                   while(c >= '0' && c <= '9')
 658                   {
 659                     len = (c - '0') + len * 10;
 660                     c = *currentline++;
 661                   }
 662
 663                   if(c == 'a')
 664                   {
 665                     int _len = len ? len : 4;
 666                     char *start;
 667                     char _StrLen[20 + 1];
 668
 669                     snprintf(_StrLen, sizeof(_StrLen), "%020lx", (uint32)cs->ID);
 670                     start = &_StrLen[20 - _len * 2];
 671                     while(_len > 0)
 672                     {
 673                       fprintf(fpout, "\\x%.2s", start);
 674                       start += 2;
 675                       _len--;
 676                     }
 677                   }
 678                   else if(c == 't')
 679                   {
 680                     int _len = len ? len : 4;
 681                     char *start;
 682                     char _StrLen[20 + 1];
 683
 684                     snprintf(_StrLen, sizeof(_StrLen), "%020lx", (uint32)((CalcRealLength(cs->CD_Str) + 1) & 0xfffffe));
 685                     start = &_StrLen[20 - _len * 2];
 686                     while(_len > 0)
 687                     {
 688                       fprintf(fpout, "\\x%.2s", start);
 689                       start += 2;
 690                       _len--;
 691                     }
 692                   }
 693                   else if(c == 'c' || c == 'd' || c == 'x')
 694                   {
 695                     char buffer[20];
 696
 697                     if(c == 'c')
 698                       c = 'o';
 699                     if(len)
 700                       snprintf(buffer, sizeof(buffer), "%%0%d%c", len, c);
 701                     else
 702                       snprintf(buffer, sizeof(buffer), "%%%c", c);
 703
 704                     if(cs != NULL)
 705                       fprintf(fpout, buffer, cs->ID);
 706
 707                   }
 708                   NeedRepeat = TRUE;
 709                 }
 710                 break;
 711
 712               case 'e':
 713                 NeedRepeat = TRUE;
 714                 if(cs != NULL)
 715                   fprintf(fpout, "%d", cs->Nr);
 716                 break;
 717
 718               case 's':
 719                 NeedRepeat = TRUE;
 720                 if(cs != NULL)
 721                 {
 722                   char *idstr;
 723                   uint32 len = 0;
 724
 725                   if(cs->LenBytes)
 726                   {
 727                     idstr = cs->CD_Str;
 728                     while(*idstr != '\0')
 729                     {
 730                       bytesread = ReadChar(&idstr, bytes);
 731                       if(bytesread > 0)
 732                       {
 733                         ++len;
 734                       }
 735                     }
 736                   }
 737
 738                   WriteString(fpout, cs->CD_Str,  cs->LenBytes ? len : (uint32)-1, cs->LenBytes, cs->POformat);
 739                 }
 740                 break;
 741
 742               case '(':
 743                 NeedRepeat = TRUE;
 744                 while(*currentline != '\0' && *currentline != ')')
 745                 {
 746                   bytesread = ReadChar(&currentline, bytes);
 747                   if(bytesread > 0 && cs != NULL && cs->Next != NULL)
 748                   {
 749                     putc((int)bytes[bytesread - 1], fpout);
 750                   }
 751                 }
 752
 753                 if(*currentline == '\0')
 754                 {
 755                   /* FIXME: reuse MSG_ERR_NOTRAILINGBRACKET here? <tactica> */
 756                   ShowError(MSG_ERR_NOTERMINATEBRACKET);
 757                 }
 758                 else
 759                 {
 760                   ++currentline;
 761                 }
 762                 break;
 763
 764               /* !!!! FIXME !!!! */
 765               case 'z':
 766                 {
 767                   int diff = (((CalcRealLength(cs->CD_Str) + 1) & 0xfffffe) - (CalcRealLength(cs->CD_Str)));
 768
 769                   NeedRepeat = TRUE;
 770                   while(diff > 0)
 771                   {
 772                     fprintf(fpout, "\\x00");
 773                     diff--;
 774                   }
 775                   break;
 776                 }
 777
 778               default:
 779                 {
 780                   int ch = *currentline++;
 781
 782                   putc(ch, fpout);
 783                 }
 784             }
 785           }
 786           else
 787           {
 788             putc((int)bytes[bytesread - 1], fpout);
 789           }
 790         }
 791       }
 792       putc('\n', fpout);
 793     }
 794     while(NeedRepeat == TRUE && cs != NULL  && (cs = cs->Next) != NULL);
 795
 796     free(line);
 797   }
 798   fclose(fpin);
 799   fclose(fpout);
 800
 801 #ifdef AMIGA
 802   SetProtection(SourceFile, FILE_MASK);
 803 #endif
 804 }
 805
 806 ///