tools/dtdesc/createdtdesc.c

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