tools/dtdesc/createdtdesc.c

   1 /*
   2     Copyright © 2000-2019, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: DataTypesDescriptorCreator
   6     Lang: English.
   7 */
   8
   9 #include "createdtdesc.h"
  10 #include "parser.h"
  11
  12 int main(int argc, char **argv)
  13 {
  14  struct DTDesc *TheDTDesc;
  15
  16  if(Init(argc, argv, &TheDTDesc))
  17  {
  18   Work(TheDTDesc);
  19  }
  20
  21  Cleanup(TheDTDesc);
  22
  23  return(0);
  24 }
  25
  26 int HandleName(struct DTDesc *TheDTDesc)
  27 {
  28  uint8_t *DataPtr;
  29
  30  if(!TheDTDesc)
  31  {
  32   return(FALSE);
  33  }
  34
  35  TheDTDesc->ReadBuffer[READBUFFERSIZE-1]='\0';
  36
  37  DataPtr=TheDTDesc->ReadBuffer+KeywordLength[Name];
  38
  39  /*
  40   *  What, who yells buffer-overflow here?
  41   */
  42
  43  strcpy(TheDTDesc->Name, DataPtr);
  44
  45  TheDTDesc->DTH.dth_Name=TheDTDesc->Name;
  46
  47  return(TRUE);
  48 }
  49
  50 int HandleVersion(struct DTDesc *TheDTDesc)
  51 {
  52  uint8_t *DataPtr;
  53
  54  if(!TheDTDesc)
  55  {
  56   return(FALSE);
  57  }
  58
  59  TheDTDesc->ReadBuffer[READBUFFERSIZE-1]='\0';
  60
  61  DataPtr=TheDTDesc->ReadBuffer+KeywordLength[Version];
  62
  63  /*
  64   *  What, who yells buffer-overflow here?
  65   */
  66
  67  strcpy(TheDTDesc->Version, DataPtr);
  68
  69  return(TRUE);
  70 }
  71
  72 int HandleBaseName(struct DTDesc *TheDTDesc)
  73 {
  74  uint8_t *DataPtr;
  75
  76  if(!TheDTDesc)
  77  {
  78   return(FALSE);
  79  }
  80
  81  TheDTDesc->ReadBuffer[READBUFFERSIZE-1]='\0';
  82
  83  DataPtr=TheDTDesc->ReadBuffer+KeywordLength[BaseName];
  84
  85  /*
  86   *  What, who yells buffer-overflow here?
  87   */
  88
  89  strcpy(TheDTDesc->BaseName, DataPtr);
  90
  91  TheDTDesc->DTH.dth_BaseName=TheDTDesc->BaseName;
  92
  93  return(TRUE);
  94 }
  95
  96 int HandlePattern(struct DTDesc *TheDTDesc)
  97 {
  98  uint8_t *DataPtr;
  99
 100  if(!TheDTDesc)
 101  {
 102   return(FALSE);
 103  }
 104
 105  TheDTDesc->ReadBuffer[READBUFFERSIZE-1]='\0';
 106
 107  DataPtr=TheDTDesc->ReadBuffer+KeywordLength[Pattern];
 108
 109  /*
 110   *  What, who yells buffer-overflow here?
 111   */
 112
 113  strcpy(TheDTDesc->Pattern, DataPtr);
 114
 115  TheDTDesc->DTH.dth_Pattern=TheDTDesc->Pattern;
 116
 117  return(TRUE);
 118 }
 119
 120 int HandleMask(struct DTDesc *TheDTDesc)
 121 {
 122  uint8_t *DataPtr;
 123  int i;
 124
 125  if(!TheDTDesc)
 126  {
 127   return(FALSE);
 128  }
 129
 130  TheDTDesc->ReadBuffer[READBUFFERSIZE-1]='\0';
 131
 132  DataPtr=TheDTDesc->ReadBuffer+KeywordLength[Mask];
 133
 134 #if 1
 135  {
 136   uint8_t *NewDataPtr;
 137   int done = 0;
 138
 139   TheDTDesc->DTH.dth_MaskLen = 0;
 140
 141   while(!done)
 142   {
 143    uint8_t c = *DataPtr++;
 144
 145    switch(c)
 146    {
 147     case '\0':
 148      done = 1;
 149      break;
 150
 151     case '\'':
 152      c = *DataPtr++;
 153      TheDTDesc->Mask[TheDTDesc->DTH.dth_MaskLen++] = c;
 154      if (c) c = *DataPtr++;
 155      if (!c) done = 1;
 156      break;
 157
 158     case 'A':
 159      c = *DataPtr++;
 160      if (!c) done = 1;
 161      if (c != 'N') break;
 162      c = *DataPtr++;
 163      if (!c) done = 1;
 164      if (c != 'Y') break;
 165      TheDTDesc->Mask[TheDTDesc->DTH.dth_MaskLen++] = 0xFFFF;
 166      break;
 167
 168     case ' ':
 169     case '\t':
 170      break;
 171
 172     default:
 173      DataPtr--;
 174      i = strtol(DataPtr, (char **)(&NewDataPtr), 0);
 175      if (DataPtr != NewDataPtr)
 176      {
 177       DataPtr = NewDataPtr;
 178       TheDTDesc->Mask[TheDTDesc->DTH.dth_MaskLen++] = i;
 179      }
 180      else
 181      {
 182       DataPtr++;
 183      }
 184      break;
 185
 186    }
 187   }
 188  }
 189
 190 #else
 191  TheDTDesc->DTH.dth_MaskLen=(uint16_t) strlen(DataPtr);
 192  if(!TheDTDesc->DTH.dth_MaskLen)
 193  {
 194   return(TRUE);
 195  }
 196
 197  for(i=0; i<TheDTDesc->DTH.dth_MaskLen; i++)
 198  {
 199   TheDTDesc->Mask[i] = (DataPtr[i]==0xFF) ? 0xFFFF : (uint16_t) DataPtr[i];
 200  }
 201 #endif
 202
 203  TheDTDesc->DTH.dth_Mask=TheDTDesc->Mask;
 204
 205  return(TRUE);
 206 }
 207
 208 int HandleGroupID(struct DTDesc *TheDTDesc)
 209 {
 210  uint8_t *DataPtr;
 211
 212  if(!TheDTDesc)
 213  {
 214   return(FALSE);
 215  }
 216
 217  TheDTDesc->ReadBuffer[READBUFFERSIZE-1]='\0';
 218
 219  DataPtr=TheDTDesc->ReadBuffer+KeywordLength[GroupID];
 220
 221  if(strlen(DataPtr)<4)
 222  {
 223   return(FALSE);
 224  }
 225
 226  TheDTDesc->DTH.dth_GroupID=MAKE_ID(DataPtr[0], DataPtr[1], DataPtr[2], DataPtr[3]);
 227
 228  return(TRUE);
 229 }
 230
 231 int HandleID(struct DTDesc *TheDTDesc)
 232 {
 233  uint8_t *DataPtr;
 234
 235  if(!TheDTDesc)
 236  {
 237   return(FALSE);
 238  }
 239
 240  TheDTDesc->ReadBuffer[READBUFFERSIZE-1]='\0';
 241
 242  DataPtr=TheDTDesc->ReadBuffer+KeywordLength[ID];
 243
 244  if(strlen(DataPtr)<4)
 245  {
 246   return(FALSE);
 247  }
 248
 249  TheDTDesc->DTH.dth_ID=MAKE_ID(DataPtr[0], DataPtr[1], DataPtr[2], DataPtr[3]);
 250
 251  return(TRUE);
 252 }
 253
 254 int HandleFlags(struct DTDesc *TheDTDesc)
 255 {
 256  uint8_t *DataPtr;
 257  long Len;
 258  int i;
 259
 260  const char *TheFlags[] =
 261  {
 262   "DTF_BINARY",
 263   "DTF_ASCII",
 264   "DTF_IFF",
 265   "DTF_MISC",
 266   "DTF_CASE",
 267   "DTF_SYSTEM1"
 268  };
 269
 270  const int FlagLength[] =
 271  {
 272   10,
 273   9,
 274   7,
 275   8,
 276   8,
 277   11
 278  };
 279
 280  const int NumFlags=6;
 281
 282  const uint16_t FlagValues[] =
 283  {
 284   0x0000,
 285   0x0001,
 286   0x0002,
 287   0x0003,
 288   0x0010,
 289   0x1000
 290  };
 291
 292  if(!TheDTDesc)
 293  {
 294   return(FALSE);
 295  }
 296
 297  TheDTDesc->ReadBuffer[READBUFFERSIZE-1]='\0';
 298
 299  DataPtr=TheDTDesc->ReadBuffer+KeywordLength[Flags];
 300
 301  TheDTDesc->DTH.dth_Flags=0;
 302
 303  Len=strlen(DataPtr);
 304  if(!Len)
 305  {
 306   return(TRUE);
 307  }
 308
 309  while(Len>0)
 310  {
 311   for(i=0; i<NumFlags; i++)
 312   {
 313    if(Len<FlagLength[i])
 314    {
 315     continue;
 316    }
 317
 318    if(strncmp(TheFlags[i], DataPtr, FlagLength[i])==0)
 319    {
 320     TheDTDesc->DTH.dth_Flags |= FlagValues[i];
 321
 322     Len-=(FlagLength[i]-1);
 323     DataPtr+=(FlagLength[i]-1);
 324
 325     break;
 326    }
 327   }
 328
 329   Len--;
 330   DataPtr++;
 331  }
 332
 333  return(TRUE);
 334 }
 335
 336 int HandlePriority(struct DTDesc *TheDTDesc)
 337 {
 338  uint8_t *DataPtr;
 339  unsigned long Pri;
 340
 341  if(!TheDTDesc)
 342  {
 343   return(FALSE);
 344  }
 345
 346  TheDTDesc->ReadBuffer[READBUFFERSIZE-1]='\0';
 347
 348  DataPtr=TheDTDesc->ReadBuffer+KeywordLength[Priority];
 349
 350  Pri=strtoul(DataPtr, NULL, 10);
 351
 352  TheDTDesc->DTH.dth_Priority=(uint16_t) Pri;
 353
 354  return(TRUE);
 355 }
 356
 357 int HandleLine(struct DTDesc *TheDTDesc)
 358 {
 359  int RetVal;
 360  int i;
 361
 362  if(!TheDTDesc)
 363  {
 364   return(FALSE);
 365  }
 366
 367  RetVal=TRUE;
 368
 369  for(i=0; i<NumKeywords; i++)
 370  {
 371   if(strncmp(TheDTDesc->ReadBuffer, Keywords[i], KeywordLength[i])==0)
 372   {
 373    RetVal=KeywordHandler[i](TheDTDesc);
 374
 375    break;
 376   }
 377  }
 378
 379  return(RetVal);
 380 }
 381
 382 int RemoveNewLine(struct DTDesc *TheDTDesc)
 383 {
 384  int Len;
 385
 386  if(!TheDTDesc)
 387  {
 388   return(FALSE);
 389  }
 390
 391  Len=strlen(TheDTDesc->ReadBuffer);
 392
 393  if(TheDTDesc->ReadBuffer[Len-1]=='\n')
 394  {
 395   TheDTDesc->ReadBuffer[Len-1]='\0';
 396  }
 397
 398  return(TRUE);
 399 }
 400
 401 void Work(struct DTDesc *TheDTDesc)
 402 {
 403
 404  if(!TheDTDesc)
 405  {
 406   return;
 407  }
 408
 409  memset(TheDTDesc->ReadBuffer, '\0', READBUFFERSIZE);
 410
 411  while(fgets(TheDTDesc->ReadBuffer, READBUFFERSIZE, TheDTDesc->Input))
 412  {
 413   RemoveNewLine(TheDTDesc);
 414
 415   if(!HandleLine(TheDTDesc))
 416   {
 417    break;
 418   }
 419
 420   memset(TheDTDesc->ReadBuffer, '\0', READBUFFERSIZE);
 421  }
 422
 423  WriteOutDTD(TheDTDesc);
 424
 425 }
 426
 427 int WriteOutDTD(struct DTDesc *TheDTDesc)
 428 {
 429  struct IFFHandle *IH;
 430  struct FileDataTypeHeader FileDTH;
 431  int i = 0;
 432
 433  if(!TheDTDesc)
 434  {
 435   return(FALSE);
 436  }
 437
 438  if(strlen(TheDTDesc->Name)==0)
 439  {
 440   return(FALSE);
 441  }
 442
 443  if(strlen(TheDTDesc->BaseName)==0)
 444  {
 445   return(FALSE);
 446  }
 447
 448 #if 0
 449  if(TheDTDesc->DTH.dth_MaskLen==0)
 450  {
 451   return(FALSE);
 452  }
 453 #endif
 454
 455  if(strlen(TheDTDesc->Pattern)==0)
 456  {
 457   TheDTDesc->Pattern[0]='#';
 458   TheDTDesc->Pattern[1]='?';
 459   TheDTDesc->Pattern[2]='\0';
 460  }
 461
 462  IH=NewIFF(TheDTDesc->OutputName, MAKE_ID('D','T','Y','P'));
 463  if(!IH)
 464  {
 465   return(FALSE);
 466  }
 467
 468  if(!NewChunk(IH, MAKE_ID('N','A','M','E')))
 469  {
 470   CloseIFF(IH);
 471   remove(TheDTDesc->Name);
 472   return(FALSE);
 473  }
 474
 475  if(WriteChunkData(IH, TheDTDesc->Name, (strlen(TheDTDesc->Name)+1))<=0)
 476  {
 477   EndChunk(IH);
 478   CloseIFF(IH);
 479   remove(TheDTDesc->Name);
 480   return(FALSE);
 481  }
 482
 483  EndChunk(IH);
 484
 485  if(strlen(TheDTDesc->Version) > 0)
 486  {
 487   if(!NewChunk(IH, MAKE_ID('F','V','E','R')))
 488   {
 489    CloseIFF(IH);
 490    remove(TheDTDesc->Name);
 491    return(FALSE);
 492   }
 493
 494   if(WriteChunkData(IH, TheDTDesc->Version, (strlen(TheDTDesc->Version)+1))<=0)
 495   {
 496    EndChunk(IH);
 497    CloseIFF(IH);
 498    remove(TheDTDesc->Name);
 499    return(FALSE);
 500   }
 501
 502   EndChunk(IH);
 503  }
 504
 505  if(!NewChunk(IH, MAKE_ID('D','T','H','D')))
 506  {
 507   CloseIFF(IH);
 508   remove(TheDTDesc->Name);
 509   return(FALSE);
 510  }
 511
 512  FileDTH.dth_Name     = (((unsigned int) sizeof(struct FileDataTypeHeader)));
 513  FileDTH.dth_BaseName = (((unsigned int) FileDTH.dth_Name) + strlen(TheDTDesc->DTH.dth_Name) + 1);
 514  FileDTH.dth_Pattern  = (((unsigned int) FileDTH.dth_BaseName) + strlen(TheDTDesc->DTH.dth_BaseName) + 1);
 515  // dth_Mask _must_ be word aligned
 516  FileDTH.dth_Mask     = (((unsigned int) FileDTH.dth_Pattern) + strlen(TheDTDesc->DTH.dth_Pattern) + 1);
 517  if (FileDTH.dth_Mask & 1)
 518  {
 519   FileDTH.dth_Mask += 1;
 520   i = 1;
 521  }
 522  FileDTH.dth_GroupID  = TheDTDesc->DTH.dth_GroupID;
 523  FileDTH.dth_ID       = TheDTDesc->DTH.dth_ID;
 524  FileDTH.dth_MaskLen  = TheDTDesc->DTH.dth_MaskLen;
 525  FileDTH.dth_Pad      = TheDTDesc->DTH.dth_Pad;
 526  FileDTH.dth_Flags    = TheDTDesc->DTH.dth_Flags;
 527  FileDTH.dth_Priority = TheDTDesc->DTH.dth_Priority;
 528
 529  FileDTH.dth_Name     = Swap32IfLE(((uint32_t) FileDTH.dth_Name));
 530  FileDTH.dth_BaseName = Swap32IfLE(((uint32_t) FileDTH.dth_BaseName));
 531  FileDTH.dth_Pattern  = Swap32IfLE(((uint32_t) FileDTH.dth_Pattern));
 532  FileDTH.dth_Mask     = Swap32IfLE(((uint32_t) FileDTH.dth_Mask));
 533  FileDTH.dth_GroupID  = Swap32IfLE(FileDTH.dth_GroupID);
 534  FileDTH.dth_ID       = Swap32IfLE(FileDTH.dth_ID);
 535  FileDTH.dth_MaskLen  = Swap16IfLE(FileDTH.dth_MaskLen);
 536  FileDTH.dth_Pad      = Swap16IfLE(FileDTH.dth_Pad);
 537  FileDTH.dth_Flags    = Swap16IfLE(FileDTH.dth_Flags);
 538  FileDTH.dth_Priority = Swap16IfLE(FileDTH.dth_Priority);
 539
 540  if(WriteChunkData(IH, (char *) &FileDTH, sizeof(struct FileDataTypeHeader))<=0)
 541  {
 542   EndChunk(IH);
 543   CloseIFF(IH);
 544   remove(TheDTDesc->Name);
 545   return(FALSE);
 546  }
 547
 548  if(WriteChunkData(IH, TheDTDesc->DTH.dth_Name, (strlen(TheDTDesc->DTH.dth_Name) + 1))<=0)
 549  {
 550   EndChunk(IH);
 551   CloseIFF(IH);
 552   remove(TheDTDesc->Name);
 553   return(FALSE);
 554  }
 555
 556  if(WriteChunkData(IH, TheDTDesc->DTH.dth_BaseName, (strlen(TheDTDesc->DTH.dth_BaseName) + 1))<=0)
 557  {
 558   EndChunk(IH);
 559   CloseIFF(IH);
 560   remove(TheDTDesc->Name);
 561   return(FALSE);
 562  }
 563
 564  if(WriteChunkData(IH, TheDTDesc->DTH.dth_Pattern, (strlen(TheDTDesc->DTH.dth_Pattern) + 1 + i))<=0)
 565  {
 566   EndChunk(IH);
 567   CloseIFF(IH);
 568   remove(TheDTDesc->Name);
 569   return(FALSE);
 570  }
 571
 572  if (TheDTDesc->DTH.dth_MaskLen)
 573  {
 574   for(i=0; i<TheDTDesc->DTH.dth_MaskLen; i++)
 575   {
 576    TheDTDesc->DTH.dth_Mask[i]=Swap16IfLE(TheDTDesc->DTH.dth_Mask[i]);
 577   }
 578
 579   if(WriteChunkData(IH, (char *) TheDTDesc->DTH.dth_Mask, TheDTDesc->DTH.dth_MaskLen * sizeof(uint16_t))<=0)
 580   {
 581    EndChunk(IH);
 582    CloseIFF(IH);
 583    remove(TheDTDesc->Name);
 584    return(FALSE);
 585   }
 586  }
 587
 588  EndChunk(IH);
 589
 590  CloseIFF(IH);
 591
 592  return(TRUE);
 593 }
 594
 595 int Init(int argc, char **argv, struct DTDesc **TheDTDesc)
 596 {
 597  struct DTDesc *NewDTDesc;
 598
 599  if(!(argv && TheDTDesc))
 600  {
 601   return(FALSE);
 602  }
 603
 604  *TheDTDesc=NULL;
 605
 606  NewDTDesc=(struct DTDesc *) malloc(sizeof(struct DTDesc));
 607  if(!NewDTDesc)
 608  {
 609   return(FALSE);
 610  }
 611
 612  *TheDTDesc=NewDTDesc;
 613
 614  memset(NewDTDesc, '\0', sizeof(struct DTDesc));
 615
 616  NewDTDesc->ProgName=argv[0];
 617  NewDTDesc->Input=stdin;
 618  NewDTDesc->OutputName=NewDTDesc->Name;
 619
 620  if(!ParseArgs(argc, argv, NewDTDesc))
 621  {
 622   return(FALSE);
 623  }
 624
 625  if(!OpenInput(NewDTDesc))
 626  {
 627   return(FALSE);
 628  }
 629
 630  return(TRUE);
 631 }
 632
 633 int OpenInput(struct DTDesc *TheDTDesc)
 634 {
 635
 636  if(!TheDTDesc)
 637  {
 638   return(FALSE);
 639  }
 640
 641  if(TheDTDesc->InputName)
 642  {
 643   TheDTDesc->Input=fopen(TheDTDesc->InputName, "r");
 644   if(!TheDTDesc->Input)
 645   {
 646    TheDTDesc->Input=stdin;
 647
 648    return(FALSE);
 649   }
 650  }
 651
 652  return(TRUE);
 653 }
 654
 655 int ParseArgs(int argc, char **argv, struct DTDesc *TheDTDesc)
 656 {
 657  int i;
 658
 659  if(!(argv && TheDTDesc))
 660  {
 661   return(FALSE);
 662  }
 663
 664  for(i=1; i<argc; i++)
 665  {
 666   if(strcmp(argv[i], "-o") == 0)
 667   {
 668    if(++i >= argc)
 669    {
 670     Usage(TheDTDesc->ProgName);
 671
 672     return(FALSE);
 673    }
 674
 675    TheDTDesc->OutputName=argv[i];
 676   }
 677   else
 678   {
 679    if(strcmp(argv[i], "-h") == 0)
 680    {
 681     Usage(TheDTDesc->ProgName);
 682
 683     return(FALSE);
 684    }
 685    else
 686    {
 687     TheDTDesc->InputName=argv[i];
 688    }
 689   }
 690  }
 691
 692  return(TRUE);
 693 }
 694
 695 void Usage(char *ProgName)
 696 {
 697  char DefaultName[]="createdtdesc";
 698  char *NamePtr;
 699
 700  NamePtr = ProgName ? ProgName : DefaultName;
 701
 702  fprintf(stderr, "\n"
 703                  "usage: %s [-o <Output-Name>] <Input-Name>\n"
 704                  "\n",
 705         NamePtr);
 706 }
 707
 708 void Cleanup(struct DTDesc *TheDTDesc)
 709 {
 710  if(TheDTDesc)
 711  {
 712   if((TheDTDesc->Input!=NULL) && (TheDTDesc->Input!=stdin))
 713   {
 714    fclose(TheDTDesc->Input);
 715   }
 716
 717   free((void *) TheDTDesc);
 718  }
 719 }
 720
 721