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;
 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  //ASSERT((sizeof(struct FileDataTypeHeader) & 1) == 0);
 513  if (TheDTDesc->DTH.dth_MaskLen > 0)
 514  {
 515   // Write the mask directly after the header to preserve its word alignment.
 516   FileDTH.dth_Mask     = (((unsigned int) sizeof(struct FileDataTypeHeader)));
 517   FileDTH.dth_Name     = (((unsigned int) FileDTH.dth_Mask) + (TheDTDesc->DTH.dth_MaskLen << 1));
 518   FileDTH.dth_Mask     = Swap32IfLE(((uint32_t) FileDTH.dth_Mask));
 519  }
 520  else
 521  {
 522   FileDTH.dth_Mask     = 0;
 523   FileDTH.dth_Name     = (((unsigned int) sizeof(struct FileDataTypeHeader)));
 524  }
 525  FileDTH.dth_BaseName = (((unsigned int) FileDTH.dth_Name) + strlen(TheDTDesc->DTH.dth_Name) + 1);
 526  FileDTH.dth_Pattern  = (((unsigned int) FileDTH.dth_BaseName) + strlen(TheDTDesc->DTH.dth_BaseName) + 1);
 527  FileDTH.dth_GroupID  = TheDTDesc->DTH.dth_GroupID;
 528  FileDTH.dth_ID       = TheDTDesc->DTH.dth_ID;
 529  FileDTH.dth_MaskLen  = TheDTDesc->DTH.dth_MaskLen;
 530  FileDTH.dth_Pad      = TheDTDesc->DTH.dth_Pad;
 531  FileDTH.dth_Flags    = TheDTDesc->DTH.dth_Flags;
 532  FileDTH.dth_Priority = TheDTDesc->DTH.dth_Priority;
 533
 534  FileDTH.dth_Name     = Swap32IfLE(((uint32_t) FileDTH.dth_Name));
 535  FileDTH.dth_BaseName = Swap32IfLE(((uint32_t) FileDTH.dth_BaseName));
 536  FileDTH.dth_Pattern  = Swap32IfLE(((uint32_t) FileDTH.dth_Pattern));
 537  FileDTH.dth_GroupID  = Swap32IfLE(FileDTH.dth_GroupID);
 538  FileDTH.dth_ID       = Swap32IfLE(FileDTH.dth_ID);
 539  FileDTH.dth_MaskLen  = Swap16IfLE(FileDTH.dth_MaskLen);
 540  FileDTH.dth_Pad      = Swap16IfLE(FileDTH.dth_Pad);
 541  FileDTH.dth_Flags    = Swap16IfLE(FileDTH.dth_Flags);
 542  FileDTH.dth_Priority = Swap16IfLE(FileDTH.dth_Priority);
 543
 544  if(WriteChunkData(IH, (char *) &FileDTH, sizeof(struct FileDataTypeHeader))<=0)
 545  {
 546   EndChunk(IH);
 547   CloseIFF(IH);
 548   remove(TheDTDesc->Name);
 549   return(FALSE);
 550  }
 551
 552  if (TheDTDesc->DTH.dth_MaskLen)
 553  {
 554   for(i=0; i<TheDTDesc->DTH.dth_MaskLen; i++)
 555   {
 556    TheDTDesc->DTH.dth_Mask[i]=Swap16IfLE(TheDTDesc->DTH.dth_Mask[i]);
 557   }
 558
 559   if(WriteChunkData(IH, (char *) TheDTDesc->DTH.dth_Mask, TheDTDesc->DTH.dth_MaskLen << 1)<=0)
 560   {
 561    EndChunk(IH);
 562    CloseIFF(IH);
 563    remove(TheDTDesc->Name);
 564    return(FALSE);
 565   }
 566  }
 567
 568  if(WriteChunkData(IH, TheDTDesc->DTH.dth_Name, (strlen(TheDTDesc->DTH.dth_Name) + 1))<=0)
 569  {
 570   EndChunk(IH);
 571   CloseIFF(IH);
 572   remove(TheDTDesc->Name);
 573   return(FALSE);
 574  }
 575
 576  if(WriteChunkData(IH, TheDTDesc->DTH.dth_BaseName, (strlen(TheDTDesc->DTH.dth_BaseName) + 1))<=0)
 577  {
 578   EndChunk(IH);
 579   CloseIFF(IH);
 580   remove(TheDTDesc->Name);
 581   return(FALSE);
 582  }
 583
 584  if(WriteChunkData(IH, TheDTDesc->DTH.dth_Pattern, (strlen(TheDTDesc->DTH.dth_Pattern) + 1))<=0)
 585  {
 586   EndChunk(IH);
 587   CloseIFF(IH);
 588   remove(TheDTDesc->Name);
 589   return(FALSE);
 590  }
 591
 592  EndChunk(IH);
 593
 594  CloseIFF(IH);
 595
 596  return(TRUE);
 597 }
 598
 599 int Init(int argc, char **argv, struct DTDesc **TheDTDesc)
 600 {
 601  struct DTDesc *NewDTDesc;
 602
 603  if(!(argv && TheDTDesc))
 604  {
 605   return(FALSE);
 606  }
 607
 608  *TheDTDesc=NULL;
 609
 610  NewDTDesc=(struct DTDesc *) malloc(sizeof(struct DTDesc));
 611  if(!NewDTDesc)
 612  {
 613   return(FALSE);
 614  }
 615
 616  *TheDTDesc=NewDTDesc;
 617
 618  memset(NewDTDesc, '\0', sizeof(struct DTDesc));
 619
 620  NewDTDesc->ProgName=argv[0];
 621  NewDTDesc->Input=stdin;
 622  NewDTDesc->OutputName=NewDTDesc->Name;
 623
 624  if(!ParseArgs(argc, argv, NewDTDesc))
 625  {
 626   return(FALSE);
 627  }
 628
 629  if(!OpenInput(NewDTDesc))
 630  {
 631   return(FALSE);
 632  }
 633
 634  return(TRUE);
 635 }
 636
 637 int OpenInput(struct DTDesc *TheDTDesc)
 638 {
 639
 640  if(!TheDTDesc)
 641  {
 642   return(FALSE);
 643  }
 644
 645  if(TheDTDesc->InputName)
 646  {
 647   TheDTDesc->Input=fopen(TheDTDesc->InputName, "r");
 648   if(!TheDTDesc->Input)
 649   {
 650    TheDTDesc->Input=stdin;
 651
 652    return(FALSE);
 653   }
 654  }
 655
 656  return(TRUE);
 657 }
 658
 659 int ParseArgs(int argc, char **argv, struct DTDesc *TheDTDesc)
 660 {
 661  int i;
 662
 663  if(!(argv && TheDTDesc))
 664  {
 665   return(FALSE);
 666  }
 667
 668  for(i=1; i<argc; i++)
 669  {
 670   if(strcmp(argv[i], "-o") == 0)
 671   {
 672    if(++i >= argc)
 673    {
 674     Usage(TheDTDesc->ProgName);
 675
 676     return(FALSE);
 677    }
 678
 679    TheDTDesc->OutputName=argv[i];
 680   }
 681   else
 682   {
 683    if(strcmp(argv[i], "-h") == 0)
 684    {
 685     Usage(TheDTDesc->ProgName);
 686
 687     return(FALSE);
 688    }
 689    else
 690    {
 691     TheDTDesc->InputName=argv[i];
 692    }
 693   }
 694  }
 695
 696  return(TRUE);
 697 }
 698
 699 void Usage(char *ProgName)
 700 {
 701  char DefaultName[]="createdtdesc";
 702  char *NamePtr;
 703
 704  NamePtr = ProgName ? ProgName : DefaultName;
 705
 706  fprintf(stderr, "\n"
 707                  "usage: %s [-o <Output-Name>] <Input-Name>\n"
 708                  "\n",
 709         NamePtr);
 710 }
 711
 712 void Cleanup(struct DTDesc *TheDTDesc)
 713 {
 714  if(TheDTDesc)
 715  {
 716   if((TheDTDesc->Input!=NULL) && (TheDTDesc->Input!=stdin))
 717   {
 718    fclose(TheDTDesc->Input);
 719   }
 720
 721   free((void *) TheDTDesc);
 722  }
 723 }
 724
 725